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

// Record protocol source file. 

// Describes the implementation of the Record protocol classes: Record parser 

// (CRecordParser) and the Record composer (CRecordComposer).

//

//

/**

 @file

*/

#include <es_sock.h>

#include "recordprotocolevents.h"

#include "AlertProtocolEvents.h"

#include "handshakereceiveevents.h"

#include "changecipherevents.h"

#include "tlshandshake.h"

void CRecordParser::ReConstructL( CStateMachine* aStateMachine, const TPtr8& /*aHeldData*/, CSendAlert& aSendAlert )

/**

 * This method sets the iStateMachine and iNext (CAsynchEvent*) data members 

 * inherited from the CAsynchEvent class, in addition to some of its own data members. 

 * It also creates a list of the expected Record protocol content types.

 */

    {

	LOG(Log::Printf(_L("CRecordParser::ReConstructL(CStateMachine*, const TPtr8&, CSendAlert&)"));)

	iStateMachine = aStateMachine;

    if (!iDataIn)

        {

        iDataIn = HBufC8::NewL( KTlsRecordPrealocate );

        }

    ReConstructL();

	CTlsEvent* alertItem = new(ELeave)CRecvAlert( *iStateMachine, *this, aSendAlert );

	//coverity[leave_without_push]

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

	iExpRecordTypes.AddLast( *alertItem );

	iHandshakeParser = new(ELeave)CHandshakeParser( *iStateMachine, *this);

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

	iExpRecordTypes.AddLast( *iHandshakeParser );

    }

void CRecordParser::ReConstructL()

/**

 * This method resets the state of the object as if it had just been created.

 */

    {

	LOG(Log::Printf(_L("CRecordParser::ReConstructL()"));)

	DestroyList();

	iHeldData.Zero();

	iReadState = iHeldData.Length() ? ETlsFragmentRecord : ETlsReceiveRecordHeader; 

	// Add TLS record protocol content types to the list of expected types

	// It is important that the Handshake parser object is last in the list

	if (iStateMachine->History() == ETlsHandshakeStart)

    	{

		// Change Cipher Spec protocol applies only during handshake negotiation

		__ASSERT_DEBUG( iTlsProvider, TlsPanic(ETlsPanicTlsProviderNotReady));

		CTlsEvent* ccsItem = new(ELeave)CRecvChangeCipherSpec( *iStateMachine, *this );

		//coverity[leave_without_push]

		LOG(Log::Printf(_L("RecvChangeCipherSpec %x - %x"), ccsItem, (TUint)ccsItem + sizeof( CRecvChangeCipherSpec ));)

		iExpRecordTypes.AddLast( *ccsItem );

	    }

	iNext = NULL;

    }

CRecordParser::~CRecordParser()

{

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

	DestroyList();

	delete iDecryptedData;

   delete iDataIn;

   Reset();

}

void CRecordParser::DestroyList()

{

	LOG(Log::Printf(_L("CRecordParser::DestroyList() of expected record protocol Content types"));)

	CTlsEvent* listItem;

   TSglQueIter<CTlsEvent> expListIter( iExpRecordTypes );

    expListIter.SetToFirst(); 

    while ( (listItem = expListIter++) != NULL )

        {

        iExpRecordTypes.Remove(*listItem);

        delete listItem;

        };

}

void CRecordParser::ChangeCipher()

{

   if ( iStateMachine->History() & ETlsChangeCipherSent )

   {

		__ASSERT_DEBUG( iActiveTlsSession != iTlsProvider->TlsSessionPtr(), TlsPanic(ETlsPanicInvalidTlsSession));

      delete iActiveTlsSession;

   }

   iActiveTlsSession = iTlsProvider->TlsSessionPtr();

   iReadSequenceNum = 0;

}

void CRecordParser::Reset()

{

	iReadSequenceNum = 0;	// reset the sequence number

   if ( iTlsProvider && iTlsProvider->TlsSessionPtr() && iActiveTlsSession != iTlsProvider->TlsSessionPtr() )

   {//this could happen just in case we re-negotiated unsuccessfully but passed CTlsProvider::Create()

      delete iActiveTlsSession;

   }

   iActiveTlsSession = NULL;

}

CTlsEvent* CRecordParser::LookUpEventL( TInt aRecordType )

/**

 * This method is used to determine which record protocol content type (handshake,

 * change cipher spec, alert, application data) will process a received message.

 * It cycles through the list of expected record types to see which one would

 * accept the received record.

 * 

 * @param aRecordType An integer representing the content type.

 * @return CTlsEvent* A pointer to the event that will process the received message.

 */

{

	LOG(Log::Printf(_L("CRecordParser::LookUpEventL()"));)

   TSglQueIter<CTlsEvent> expListIter( iExpRecordTypes );

	expListIter.SetToFirst();

	CTlsEvent* pEvent;

	while ( ((pEvent = expListIter++) != 0) && !pEvent->AcceptRecord( aRecordType ) )

      {

      }

	// When processing application data, NULL is returned as this is the only class processing it

	if ( !pEvent )

   {

      if ( aRecordType != ETlsAppDataContentType )

      {

		   User::Leave( KErrSSLAlertUnexpectedMessage );

      }

      else if ( iStateMachine->History() != KTlsApplicationData )

      {//application adta received during handshaking

         if ( iIgnoreRecordAllowed )

         {//in case client's initiated re-negotiation while the server is still sending some app data

   			LOG(Log::Printf(_L("Application data received while re-negotiating => skip the record"));)

            iIgnoreRecord = 1;

         }

         else

         {

     		   User::Leave( KErrSSLAlertUnexpectedMessage );

         }

      }

   }

   else

   {//once i've received any record but application data one no record will be ignored

      iIgnoreRecordAllowed = 0;

      iIgnoreRecord = 0;

   }

	return pEvent;

}

TInt CRecordParser::ParseHeaderL()

/**

 * This method parses the record header to check that the Protocol version is as 

 * expected. It also retrieves and returns the length of the record fragment from 

 * the Record Protocol header.

 */

{

	LOG(Log::Printf(_L("CRecordParser::ParseHeaderL()"));)

	TUint8* dataPtr = (TUint8*) iDataIn->Des().Ptr();

   iTlsRecordType = static_cast<ETlsRecordType>(dataPtr[KTlsRecordTypeOffset]);

	iNext = LookUpEventL( iTlsRecordType );

   const TTLSProtocolVersion& tlsVersion = iTlsProvider->Attributes()->iNegotiatedProtocol;

   if ( tlsVersion.iMajor )

      {

	   if ( dataPtr[KTlsRecordVersionOffset] != tlsVersion.iMajor ||

		   dataPtr[KTlsRecordVersionOffset + 1] != tlsVersion.iMinor )

	      {

		   User::Leave( KErrSSLAlertProtocolVersion );

	      }

      }

   //no protocol's been agreed yet => must be one of these

	else if ( (dataPtr[KTlsRecordVersionOffset] != KSSL3_0.iMajor ||

		   dataPtr[KTlsRecordVersionOffset + 1] != KSSL3_0.iMinor) &&

         (dataPtr[KTlsRecordVersionOffset] != KTLS1_0.iMajor ||

		   dataPtr[KTlsRecordVersionOffset + 1] != KTLS1_0.iMinor) )

	      {

		   User::Leave( KErrSSLAlertProtocolVersion );

	      }

	//extract and return the fragment length from the header

	TBigEndian value;

	return value.GetValue( dataPtr + KTlsRecordLengthOffset, KTlsRecordBodyLength );

}

void CRecordParser::CancelAll()

/**

 * Cancel all read functionality.

 * This method should also cancel decompression when it is supported.

 */

{

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

	iSocket.CancelRead();

	// Cancel the asynchronous service request made.

	iSocket.CancelRecv();

	iTlsProvider->CancelRequest();

	if ( iActiveTlsSession )

	    {

		iActiveTlsSession->CancelRequest();

		}

}

void CRecordParser::DispatchData()

{

	TInt nUserFree = iUserData ? iUserMaxLength - iUserData->Length() : 0; 

	LOG(Log::Printf(_L("CRecordParser::DispatchData() - %x, %d"), iUserData, nUserFree);)

	if ( iHeldData.Length() )

	{

   	LOG(Log::Printf(_L("iHeldData.Length(), %d"), iHeldData.Length());)

		// Client has data left. Assert that its buffer exists.

		__ASSERT_DEBUG( iUserData, TlsPanic(ETlsPanicNoUserData));

		TInt nToCopy = Min( nUserFree, iHeldData.Length() ); // amount of data to copy

		iUserData->Append( iHeldData.Ptr(), nToCopy );

		TInt n = iHeldData.Length() - nToCopy;	// Reset the held data ptr to what is left-over

		iHeldData.Set( (TUint8*)iHeldData.Ptr() + nToCopy, n, n );

	}	

	else

	{

		iHeldData.Set(iPtrHBuf);

     	LOG(Log::Printf(_L("iHeldData.Length() == 0 %d"), iHeldData.Length());)

      if ( iUserData && nUserFree >= iHeldData.Length() )

		{	// User's data buffer is big enough, copy data directly into it.

			iUserData->Append(iHeldData.Ptr(), iHeldData.Length());

			iHeldData.Zero();

		}

		else if ( iUserData && nUserFree < iHeldData.Length() )

		{	// User's data buffer is not long enough. Copy nUserFree bytes and

			// save the rest for later

			iUserData->Append( iHeldData.Ptr(), nUserFree );

			TInt n = iHeldData.Length() - nUserFree;

			iHeldData.Set( (TUint8*)iHeldData.Ptr() + nUserFree, n, n ); // Left-over data is in iHeldData

		}

	}

#ifdef _DEBUG

   if ( iUserData )

      {

  	   LOG(Log::Printf(_L("CRecordParser::DispatchData() end iUserData->Length() = %d, %d"), iUserData->Length(), iHeldData.Length());)

      }

#endif

}

CAsynchEvent* CRecordParser::ProcessL( TRequestStatus& aStatus )

/**

 * This asynchronous method parses a received SSL/TLS record.

 * The record protocol is responsible for decrypting, message authentication (verifying 

 * data), decompressing and reassembling data. 

 *

 * Note that the record header is transmitted in the clear (i.e., it is not encrypted 

 * or MACed). As such, only the record body is passed through to Security for deciphering

 * and validation. Also, only NULL compression is supported. MAC verification + Decryption 

 * only happen when security services are active.

 * 

 * @param aStatus TRequestStatus object

 * @return CAsynchEvent* A pointer to an asynchronous event (the next event to be processed).

 */

{

	if ( iStateMachine->History() == KTlsApplicationData )

	{

	LOG(Log::Printf(_L("CRecordParser::ProcessL()"));)

	}

	switch ( iReadState )

	{

	case ETlsReceiveRecordHeader:	

		{

			LOG(Log::Printf(_L("CRecordParser::ProcessL() - ETlsReceiveRecordHeader"));)

			// Prepare to receive a new record fragment. Receive the header initially.

			// Parse it and determine the fragment length. Check that the record

			// fragment length does not exceed the allowed maximum for a SSL/TLS record

			if ( iStateMachine->Fragment() )	// For App data rx, this pointer is NULL

			{

				iStateMachine->Fragment()->Des().Zero(); 

			}

			iPtrHBuf.Set( (TUint8*)iDataIn->Des().Ptr(), 0, KTlsRecordHeaderSize );

			iSocket.Recv( iPtrHBuf, 0, aStatus );

			iReadState = ETlsReceiveRecordBody;

			break;

		}

	case ETlsReceiveRecordBody:

		{

			TInt fragLength = ParseHeaderL();	// Returns the length of the fragment

            //parameters swap due to the defect

			LOG(RFileLogger::HexDump(KSSLLogDir,KSSLLogFileName,EFileLoggingModeAppend, NULL, NULL, iPtrHBuf.Ptr(), iPtrHBuf.Length() ));

			LOG(Log::Printf(_L("CRecordParser::ProcessL() - ETlsReceiveRecordBody of length %x"), fragLength);)

    		User::LeaveIfError( fragLength > KTlsRecordMaxBodySize || fragLength < 0 ? KErrSSLAlertRecordOverflow : KErrNone );

         if ( fragLength > iDataIn->Des().MaxLength() )

            {

            delete iDataIn;

            iDataIn = NULL;

            iDataIn = HBufC8::NewL( fragLength );

            }

			// Read the record fragment and overwrite the header (already been evaluated)

			iPtrHBuf.Set( (TUint8*)iDataIn->Des().Ptr(), 0, fragLength );	

			iSocket.Recv( iPtrHBuf, 0, aStatus );

			iReadState = ETlsCipherRecord;

			break;

		}

	case ETlsCipherRecord:

		{

			LOG(Log::Printf(_L("CRecordParser::ProcessL() - ETlsCipherRecord"));)

         if ( iIgnoreRecord )

         {//nothing to be done => skip it all

				iReadState = ETlsReceiveRecordHeader;

         }

         else

         {

			   // Decrypt and verify the MACed record fragment, if appropriate

			   // Initialise the buffer for the plain text data.

			   if (iActiveTlsSession) // Security is active

			   {

				   TRecordProtocol type = (TRecordProtocol) iTlsRecordType;

				   User::LeaveIfError( iActiveTlsSession->DecryptAndVerifyL(iPtrHBuf, iDecryptedData, iReadSequenceNum, type ) );

				   // If error is not zero, it should generate an alert.

  				   iPtrHBuf.Set( iDecryptedData->Des() );

				   User::LeaveIfError( iPtrHBuf.Length() > KTlsRecordPlainText ? KErrSSLAlertRecordOverflow : KErrNone );

			   }

			   // Update the sequence number

			   iReadSequenceNum++;	// Increment the sequence number

			   iReadState = ETlsCompressRecord;

         }

         TRequestStatus* p=&aStatus;

			User::RequestComplete( p, KErrNone );

			break;

		}

	case ETlsCompressRecord:

		{

			LOG(Log::Printf(_L("CRecordParser::ProcessL() - ETlsCompressRecord"));)

			// De-compresses the SSL/TLS plain text data. Only NULL compression is 

			// currently supported (identity operation). Fall through to the next state. 

			iReadState = ETlsFragmentRecord;

		}

	case ETlsFragmentRecord:

		{

			LOG(Log::Printf(_L("CRecordParser::ProcessL() - ETlsFragmentRecord"));)

			// In application data mode, if the Client's data buffer is big enough,

			// then copy the verified data directly into it as an append. Otherwise,

			// copy as much as is possible (dependent on the free space in the client's

			// buffer.

			// The 'if' statement below solves the case where, in Application data 

			// mode, the clients data buffer (iUserData) is not big enough to hold the 

			// received record fragment. nUserFree is the amount of free space in the 

			// User's data buffer. This is the amount of data that is appended to its

			// buffer whilst the rest is held till the client frees up space.

         if ( (iStateMachine->History() == KTlsApplicationData && iTlsRecordType == ETlsAppDataContentType) ||

            (iStateMachine->History() != KTlsApplicationData && iTlsRecordType == ETlsHandshakeContentType))

         {//don't put wrong data into the user buffer

            DispatchData();

         }

	      if ( iHeldData.Length() == 0 )

	      {	//prepare to read new record and clear the statemachine buffer

		      iReadState = ETlsReceiveRecordHeader;

	      }

			TRequestStatus* p=&aStatus;

			User::RequestComplete( p, KErrNone );

        	LOG(Log::Printf(_L("CRecordParser::ProcessL() iNext == %x"), iNext);)

			return iNext;	// record body parser looked up in ParseHeaderL() function 

								// or NULL if in application data mode

		}	// case statement

	default:

		{

			LOG(Log::Printf(_L("CRecordParser::ProcessL() - Default statement, unknown state"));)

			__ASSERT_ALWAYS( EFalse, TlsPanic(ETlsPanicInvalidProcessState));

		}

	}	// switch statement

	return this;

}

//

void CRecordComposer::ReConstructL( CStateMachine* aStateMachine, TInt aCurrentPos )

/**

 * This method sets the iStateMachine and iNext (CAsynchEvent*) data members 

 * inherited from the CAsynchEvent class, in addition to some of its own data members.

 * It also sets the record's content type. Once set, this will remain, unless it's 

 * interrupted by an alert or handshake negotiation. In this instance, the 

 * ReConstructL() function will be called again.

 */

{

	LOG(Log::Printf(_L("CRecordComposer::ReConstructL()"));)

	iStateMachine = aStateMachine;

	iWriteState = ETlsFragmentRecord;

	iCurrentPos = aCurrentPos;

	TUint8* dataPtr = (TUint8*) iDataOut.Ptr();

	dataPtr[KTlsRecordTypeOffset] = ETlsAppDataContentType; // Default setting

	iNext = 0;

}

void CRecordComposer::ChangeCipher()

{

   if ( iStateMachine->History() & ETlsChangeCipherRecv )

   {

		__ASSERT_DEBUG( iActiveTlsSession != iTlsProvider->TlsSessionPtr(), TlsPanic(ETlsPanicInvalidTlsSession));

      delete iActiveTlsSession;

   }

   iActiveTlsSession = iTlsProvider->TlsSessionPtr();

   iWriteSequenceNum = 0;

}

void CRecordComposer::ComposeHeader( TInt aLength )

/**

 * This method composes a Record protocol header. It sets the Protocol version,

 * and the length of the Protocol message (the length is in big endian format). 

 *

 * Note that the content type has previously been set by the message class which 

 * prepared the Record payload. For the first transmitted message (ClientHello),

 * SSL v3.0 is used (to enable TLS to SSL fallback). The record composer's version

 * object is then set to NULL.

 * Subsequent transmitted messages then use the negotiated protocol version.

 */

{

	LOG(Log::Printf(_L("CRecordComposer::ComposeHeader()"));)

	TUint8* dataPtr = (TUint8*) iDataOut.Ptr();

   if ( iTlsVersion )

      {

   	dataPtr[KTlsRecordVersionOffset] = iTlsVersion->iMajor;

	   dataPtr[KTlsRecordVersionOffset + 1] = iTlsVersion->iMinor;

      }

   else

      {

   	dataPtr[KTlsRecordVersionOffset] = KSSL3_0.iMajor;

	   dataPtr[KTlsRecordVersionOffset + 1] = KSSL3_0.iMinor;

      }

	TBigEndian value;

	value.SetValue( (TUint8*)iDataOut.Ptr() + KTlsRecordLengthOffset, KTlsRecordBodyLength, aLength );

}

void CRecordComposer::CancelAll()

/**

 * Cancel all write functionality.

 * This method should also cancel compression when it is supported.

 */

{

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

	iSocket.CancelSend();

	iTlsProvider->CancelRequest();

	if (iActiveTlsSession)

		iActiveTlsSession->CancelRequest();

}

CAsynchEvent* CRecordComposer::ProcessL( TRequestStatus& aStatus )

/**

 * This asynchronous method composes a SSL/TLS record.

 * The record protocol is responsible for fragmenting, compressing, message 

 * authentication (adding a MAC) and encrypting data. It then transmits the result.

 *

 * Compression, MAC computation and Encryption only happen when security services are 

 * active. At present, only NULL compression is supported.

 * 

 * @param aStatus TRequestStatus object

 * @return CAsynchEvent* A pointer to an asynchronous event (the next event to be 

 * processed).

 */

{

	LOG(Log::Printf(_L("CRecordComposer::ProcessL()"));)

	// Get a pointer to the data to be transmitted via the Record layer.

	TDesC8* pFragment = iUserData ? iUserData : iStateMachine->Fragment();

	switch ( iWriteState )