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

// SSL3.0 and TLS1.0 Connection source file.

// Describes the implementation of a secure (SSL/TLS) connection.

// 

//

/**

 @file

*/

#include "tlsconnection.h"

#include "recordprotocolevents.h"

#include "tlshandshake.h"

#include "applicationdata.h"

#include <es_sock.h>

#include <in_sock.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <ssl_internal.h>

#endif

EXPORT_C MSecureSocket* CTlsConnection::NewL(RSocket& aSocket, const TDesC& aProtocol)

/**

 * Creates and initialises a new CTlsConnection object.

 * 

 * @param aSocket is a reference to an already open and connected socket.

 * @param aProtocol is a descriptor containing the name of the protocol (SSL3.0 or 

 * TLS1.0) the application specified when the secure socket was created.

 * @return A pointer to a newly created Secure socket object.

 */

{

	LOG(Log::Printf(_L("CTlsConnection::NewL(RSocket,Protocol)"));)

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

  	LOG(Log::Printf(_L("self %x - %x"), self, (TUint)self + sizeof( CTlsConnection ));)

#ifdef _DEBUG

   TInt nBlock;

  	LOG(Log::Printf(_L("RHeap::Size(), RHeap::Size() - RHeap::Available() %d, %d"), User::Heap().Size(), User::Heap().Size() - User::Heap().Available( nBlock ) );)

#endif

	CleanupStack::PushL(self);

	self->ConstructL(aSocket, aProtocol);

	CleanupStack::Pop();

	return self;

}

EXPORT_C MSecureSocket* CTlsConnection::NewL(MGenericSecureSocket& aSocket, const TDesC& aProtocol)

/**

 * Creates and initialises a new CTlsConnection object.

 * 

 * @param aSocket is a reference to socket like object derived from MGenericSecureSocket.

 * @param aProtocol is a descriptor containing the name of the protocol (SSL3.0 or 

 * TLS1.0) the application specified when the secure socket was created.

 * @return A pointer to a newly created Secure socket object.

 */

{

	LOG(Log::Printf(_L("CTlsConnection::NewL(GenericSocket,Protocol)"));)

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

  	LOG(Log::Printf(_L("self %x - %x"), self, (TUint)self + sizeof( CTlsConnection ));)

#ifdef _DEBUG

   TInt nBlock;

  	LOG(Log::Printf(_L("RHeap::Size(), RHeap::Size() - RHeap::Available() %d, %d"), User::Heap().Size(), User::Heap().Size() - User::Heap().Available( nBlock ) );)

#endif

	CleanupStack::PushL(self);

	self->ConstructL(aSocket, aProtocol);

	CleanupStack::Pop();

	return self;

}

EXPORT_C void CTlsConnection::UnloadDll(TAny* /*aPtr*/)

/**

 Function called prior to unloading DLL.  

 Does nothing in this implementation but is needed to be exported.

 */

{

	LOG(Log::Printf(_L("CTlsConnection::UnloadDll()"));)

}

CTlsConnection::~CTlsConnection()

/**

 * Destructor.

 * The user should ensure that the connection has been closed before destruction,

 * as there is no check for any pending asynch event here (apart from the panic 

 * in ~CActive).

 */

{

	LOG(Log::Printf(_L("CTlsConnection::~CTlsConnection()"));)

#ifdef _DEBUG

   TInt nBlock;

  	LOG(Log::Printf(_L("RHeap::Size(), RHeap::Size() - RHeap::Available() %d, %d"), User::Heap().Size(), User::Heap().Size() - User::Heap().Available( nBlock ) );)

#endif

	DeleteStateMachines();

	delete iRecordParser; //don't change the order of the deletion (see ~CRecordParser & CRecordParser:;Reset)

	delete iRecordComposer;

	delete iGenericSocket;

	delete iClientCert;

	delete iServerCert;

#ifdef _DEBUG

  	LOG(Log::Printf(_L("RHeap::Size(), RHeap::Size() - RHeap::Available() %d, %d"), User::Heap().Size(), User::Heap().Size() - User::Heap().Available( nBlock ) );)

#endif

	delete iTlsProvider;

	delete iTlsSession; 

#ifdef _DEBUG

  	LOG(Log::Printf(_L("RHeap::Size(), RHeap::Size() - RHeap::Available() %d, %d"), User::Heap().Size(), User::Heap().Size() - User::Heap().Available( nBlock ) );)

#endif

}

CTlsConnection::CTlsConnection() : CActive( EPriorityHigh )

/**

 * Constructor .

 * Sets the Active object priority.

 */

{

}

void CTlsConnection::ConstructL(RSocket& aSocket, const TDesC& aProtocol)

/** 

 * Two-phase constructor.

 * Called by CTlsConnection::NewL() to initialise all the 

 * CTlsConnection objects (bar the State machines). It also sets the 

 * protocol for the connection. The Provider interface is created and the Session

 * interface pointer is set to NULL (as no session currently exists).

 * The dialog mode for the connection is set to Attended mode (default) and the current 

 * cipher suite is set to [0x00],[0x00].

 *

 * @param aSocket is a reference to an already open and connected socket.

 * @param aProtocol is a descriptor containing the name of the protocol (SSL3.0 or 

 * TLS1.0) the application specified when the secure socket was created.

 */

{

	LOG(Log::Printf(_L("CTlsConnection::ConstructL(RSocket,Protocol)"));)

	CActiveScheduler::Add(this);		

	iTlsProvider = CTLSProvider::ConnectL();		// Set up Security/crypto interfaces

	User::LeaveIfError( SetProtocol(aProtocol) );

	iTlsProvider->Attributes()->iCurrentCipherSuite.iLoByte = 0x00;

	iTlsProvider->Attributes()->iCurrentCipherSuite.iHiByte = 0x00;

	iTlsProvider->Attributes()->iDialogNonAttendedMode = EFalse;

	iDialogMode = EDialogModeAttended;

	iGenericSocket = new(ELeave)CGenericSecureSocket<RSocket>(aSocket);

	iRecordParser = new(ELeave)CRecordParser( *iGenericSocket, *iTlsProvider );

  	LOG(Log::Printf(_L("iRecordParser %x - %x"), iRecordParser, (TUint)iRecordParser + sizeof( CRecordParser ));)

	iRecordComposer = new(ELeave)CRecordComposer( *iGenericSocket, *iTlsProvider );

  	LOG(Log::Printf(_L("iRecordComposer %x - %x"), iRecordComposer, (TUint)iRecordComposer + sizeof( CRecordComposer ));)

#ifdef _DEBUG

   TInt nBlock;

  	LOG(Log::Printf(_L("RHeap::Size(), RHeap::Size() - RHeap::Available() %d, %d"), User::Heap().Size(), User::Heap().Size() - User::Heap().Available( nBlock ) );)

#endif

}

void CTlsConnection::ConstructL(MGenericSecureSocket& aSocket, const TDesC& aProtocol)

/** 

 * Two-phase constructor.

 * Called by CTlsConnection::NewL() to initialise all the 

 * CTlsConnection objects (bar the State machines). It also sets the 

 * protocol for the connection. The Provider interface is created and the Session

 * interface pointer is set to NULL (as no session currently exists).

 * The dialog mode for the connection is set to Attended mode (default) and the current 

 * cipher suite is set to [0x00],[0x00].

 *

 * @param aSocket is a reference to socket like object derived from MGenericSecureSocket.

 * @param aProtocol is a descriptor containing the name of the protocol (SSL3.0 or 

 * TLS1.0) the application specified when the secure socket was created.

 */

{

	LOG(Log::Printf(_L("CTlsConnection::ConstructL(GenericSocket,Protocol)"));)

	CActiveScheduler::Add(this);		

	iTlsProvider = CTLSProvider::ConnectL();		// Set up Security/crypto interfaces

	User::LeaveIfError( SetProtocol(aProtocol) );

	iTlsProvider->Attributes()->iCurrentCipherSuite.iLoByte = 0x00;

	iTlsProvider->Attributes()->iCurrentCipherSuite.iHiByte = 0x00;

	iTlsProvider->Attributes()->iDialogNonAttendedMode = EFalse;

	iDialogMode = EDialogModeAttended;

	iRecordParser = new(ELeave)CRecordParser( aSocket, *iTlsProvider );

  	LOG(Log::Printf(_L("iRecordParser %x - %x"), iRecordParser, (TUint)iRecordParser + sizeof( CRecordParser ));)

	iRecordComposer = new(ELeave)CRecordComposer( aSocket, *iTlsProvider );

  	LOG(Log::Printf(_L("iRecordComposer %x - %x"), iRecordComposer, (TUint)iRecordComposer + sizeof( CRecordComposer ));)

#ifdef _DEBUG

   TInt nBlock;

  	LOG(Log::Printf(_L("RHeap::Size(), RHeap::Size() - RHeap::Available() %d, %d"), User::Heap().Size(), User::Heap().Size() - User::Heap().Available( nBlock ) );)

#endif

}

void CTlsConnection::RunL()

{

	LOG(Log::Printf(_L("CTlsConnection::RunL()"));)

#ifdef _DEBUG

   TInt nBlock;

  	LOG(Log::Printf(_L("RHeap::Size(), RHeap::Size() - RHeap::Available() %d, %d"), User::Heap().Size(), User::Heap().Size() - User::Heap().Available( nBlock ) );)

#endif

	CActiveScheduler::Stop();

}

void CTlsConnection::DoCancel()

{

}

// MSecureSocket interface

TInt CTlsConnection::AvailableCipherSuites( TDes8& aCiphers )

/** 

 * Retrieves the list of cipher suites that are available to use

 * for handshake negotiation. 

 * Cipher suites are returned in two byte format as is specified in the SSL/TLS 

 * specifications, e.g. [0x00][0x03]. 

 *

 * @param aCiphers A reference to a descriptor which will contain a list of cipher suites. 

 * @return Any one of the system error codes, or KErrNone on success. 

 */

{

	LOG(Log::Printf(_L("CTlsConnection::AvailableCipherSuites()"));)

   if ( !iTlsProvider )

      {

      return KErrNotReady;

      }

	RArray<TTLSCipherSuite> cipherList;

	TRAPD(ret,iTlsProvider->CipherSuitesL(cipherList, iStatus));

	if ( ret != KErrNone )

		return ret;

	SetActive();

	CActiveScheduler::Start();

	if ( iStatus.Int() != KErrNone )

	{

		LOG(Log::Printf(_L("Error retrieving the available cipher suites %d"), iStatus.Int() );)

		return iStatus.Int();

	}

	// Each cipher suite contains 2 TUint8 elements. Check the length of the user's 

	// descriptor, copy the available cipher suites into it and close the array.

	if ( aCiphers.MaxLength() < (cipherList.Count() * 2) ) 

		return KErrOverflow;

	for (TInt loop = 0; loop < cipherList.Count(); ++loop)

	{

		aCiphers.Append( cipherList[loop].iHiByte );

		aCiphers.Append( cipherList[loop].iLoByte );

	}

	cipherList.Close();

	return KErrNone;

}

void CTlsConnection::CancelAll()

/**

 * Cancels all outstanding operations. 

 */

{

	LOG(Log::Printf(_L("CTlsConnection::CancelAll()"));)

	CancelAll( KErrNone ); 

}

void CTlsConnection::CancelHandshake()

/**

 * Cancels an outstanding handshake operation. It is equivalent to

 * a CancelAll() call.

 */

{

	LOG(Log::Printf(_L("CTlsConnection::CancelHandshake()"));)

	CancelAll( KErrNone );

}

void CTlsConnection::CancelRecv()

/** 

 * Cancels any outstanding read data operation.

 */

{

	LOG(Log::Printf(_L("CTlsConnection::CancelRecv()"));)

	if ( iRecvAppData )

		iRecvAppData->Cancel( KErrNone ); //no alert sent ? maybe we should send user abort

		//but then it'll became be asynchronous fn	// @todo - Cancels have not been tested

}

void CTlsConnection::CancelSend()

/** 

 * Cancels any outstanding send data operation.

 */

{

	LOG(Log::Printf(_L("CTlsConnection::CancelSend()"));)

	if ( iSendAppData )

		iSendAppData->Cancel( KErrNone );  //no alert sent ? maybe we should send user abort

		//but then it'll became be asynchronous fn	// @todo

}

const CX509Certificate* CTlsConnection::ClientCert()

/**

 * Returns a pointer to the current client certificate if a Server has

 * requested one. If there is no suitable client certificate available, a NULL pointer 

 * will be returned.

 * A client certificate (if available) can only be returned after the negotiation

 * is complete.

 *

 * @return A pointer to the client certificate, or NULL if none exists or is yet

 * available.

 */

{

	LOG(Log::Printf(_L("CTlsConnection::ClientCert()"));)

	if (!iTlsProvider || !iTlsProvider->TlsSessionPtr())

	{

		LOG(Log::Printf(_L("The Client certificate is not yet available()"));)

		return NULL;

	}

	else

	{

      if ( !iClientCert )

         {

		   iTlsProvider->TlsSessionPtr()->ClientCertificate(iClientCert, iStatus);

		   SetActive();

   		CActiveScheduler::Start();		

         }

		return iClientCert;

	}

}

TClientCertMode CTlsConnection::ClientCertMode()

/** 

 * Returns the current client certificate mode. This is used when the 

 * socket is acting as a server, and determines if a client certificate is requested.

 * This method is not supported as this implementation only acts in Client mode.

 *

 * The closest value that the TClientCertMode enumeration provides that supports this

 * is EClientCertModeIgnore.

 */

{

	LOG(Log::Printf(_L("CTlsConnection::ClientCertMode() - Not Supported"));)

	return EClientCertModeIgnore;

}

void CTlsConnection::Close()

/** 

 * Closes the secure connection.

 * All outstanding operations are cancelled, the internal state machines are deleted

 * and the socket is closed.

 */

{

	LOG(Log::Printf(_L("CTlsConnection::Close()"));)

	//OK cancel with closure alert sent (=> asynch call) and delete the statemachines

	CancelAll( KErrNone /*KErrSSLAlertCloseNotify*/ ); //it's possible to make it asynch

   //(send an alert) but....

   DeleteStateMachines();

   iRecordParser->Socket().Close();

   iRecordComposer->SetVersion( NULL );

   ResetCryptoAttributes();

}

TInt CTlsConnection::CurrentCipherSuite( TDes8& aCipherSuite )

/**

 * Retrieves the current cipher suite in use. 

 * Cipher suites are returned in two byte format as is specified in the SSL/TLS 

 * specifications, i.e. [0x??][0x??]. 

 *

 * This method can only return the current cipher suite when the Server has proposed one

 * to use (i.e., anytime after the Server Hello has been received). Hence, it will only 

 * have a valid value after the Handshake negotiation has completed. If called before 

 * handshake negotiation, it will have the value of the NULL cipher, [0x00][0x00].

 *

 * @param aCipherSuite A reference to a descriptor at least 2 bytes long.

 * @return Any one of the system error codes, or KErrNone on success. 

 */

{

	LOG(Log::Printf(_L("CTlsConnection::CurrentCipherSuite()"));)

   if ( !iTlsProvider )

      {

      return KErrNotReady;

      }

	if ( aCipherSuite.MaxLength() < 2 )

	{

		LOG(Log::Printf(_L("CurrentCipherSuite() - Descriptor should be at least 2 bytes long"));)

		return KErrOverflow;

	}

	aCipherSuite.SetLength(2);		// A cipher suite has a 2 byte length.

	aCipherSuite[0] = iTlsProvider->Attributes()->iCurrentCipherSuite.iHiByte;

	aCipherSuite[1] = iTlsProvider->Attributes()->iCurrentCipherSuite.iLoByte;

	return KErrNone;

}

TDialogMode	CTlsConnection::DialogMode()

/**

 * Returns the current dialog mode.

 *

 * @return The current dialog mode.

 */ 

{

	LOG(Log::Printf(_L("CTlsConnection::DialogMode()"));)

	return iDialogMode;

}

void CTlsConnection::FlushSessionCache()

/** 

 * This method does NOT flush the session cache (as this is device-wide). As such, its

 * interpretation has changed from the pre-Zephyr TLS implementation.

 *

 * It is now used as an indication that the client does not intend to reuse an existing

 * session. As such it sets a flag which is called during handshake negotiation which 

 * indicates whether a new session or existing session will be used.

 * The other choice for implementation of this method will be:

 * 1) Call TLS Provider's GetSession() API to retrieve the session information.

 * 2) Call TLS Provider's ClearSessionCache() API (with the retrieved session information) 

 * to remove the particular session from the session cache. Both these APIs are asynchronous.

 *

 * Note that there is no means of indicating the success or failure of this operation

 * to the client.

 */

{

	LOG(Log::Printf(_L("CTlsConnection::FlushSessionCache()"));)

   if ( iTlsProvider )

      {

      TTLSSessionNameAndID sessionNameAndID;

      GetServerAddrInfo( sessionNameAndID.iServerName );

      TRAPD(ret,iTlsProvider->ClearSessionCacheL( sessionNameAndID, iStatus ));

      if (KErrNone!=ret)

      	{

      	LOG(Log::Printf(_L("CTlsConnection: ClearSessionCacheL error: %d"),ret));

      	return;

      	}

	  SetActive();

	  CActiveScheduler::Start();

      }

}

TInt CTlsConnection::GetOpt(TUint aOptionName,TUint aOptionLevel,TDes8& aOption)

/**

 * Gets a Socket option. 

 *

 * @param aOptionName An unsigned integer constant which identifies an option.

 * @param aOptionLevel An unsigned integer constant which identifies the level of an option.	 

 * @param aOption Option value packaged in a descriptor.

 * @return KErrNone if successful, otherwise another of the system-wide error codes.

 */

{

	LOG(Log::Printf(_L("CTlsConnection::GetOpt() method - descriptor Option"));)

	if ( !iTlsProvider || !iTlsProvider->Attributes())

    	{

    	return KErrNotReady;

    	}

	switch(aOptionLevel)

	{

	case KSolInetSSL:

		{

			switch (aOptionName)

			{

				case KSoCurrentCipherSuite:

					{

					// Call the API method that implements the functionality.

					LOG(Log::Printf(_L("Option name: KSoCurrentCipherSuite")));

					return CurrentCipherSuite(aOption);

					}

				case KSoAvailableCipherSuites:

					{

					// Call the API method that implements the functionality.

					LOG(Log::Printf(_L("Option name: KSoAvailableCipherSuites")));

					return AvailableCipherSuites(aOption);

					}

				case KSoDialogMode:

					{

					// Call the API method that implements the functionality.

					LOG(Log::Printf(_L("Option name: KSoDialogMode")));

					TDialogMode mode = DialogMode();

					TPckgBuf<TDialogMode> packedMode(mode); // Package the object into a descriptor

					if ( aOption.MaxLength() < packedMode.Length() )

						return KErrOverflow;

					aOption.Copy(packedMode); 

					return KErrNone;

					}

				case KSoSSLServerCert:

					{

						// Call the API method that implements the functionality.

						LOG(Log::Printf(_L("Option name: KSoSSLServerCert")));

						const CX509Certificate* cert = ServerCert();			

						TPckgBuf<const CX509Certificate*> packedCert(cert); // Package the pointer into a descriptor

						if ( aOption.MaxLength() < packedCert.Length() )

							return KErrOverflow;

						aOption.Copy( packedCert );

						return KErrNone;

					}

				case KSoUseSSLv2Handshake:

					{

					/*	

					This option is no longer supported, but returning KErrNotSupported

					or any other error code will result in a BC break. 

					Hence we return KErrNone untill the break gets approved by SCB

					*/

					return KErrNone;

					}

				case KSoKeyingMaterial:

					{