// 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 Application Data source file.
// Describes the implementation of the Application data (transmission
// and reception) state machines.
// 
//

/**
 @file
*/

#include "applicationdata.h"
#include "tlsconnection.h"
#include "recordprotocolevents.h"
#include "AlertProtocolEvents.h"
#include "hellorequest.h"


CSendAppData* CSendAppData::NewL( CRecordComposer& aRecordComposer )
{
	LOG(Log::Printf(_L("CSendAppData::NewL()"));)
	CSendAppData* self = new(ELeave) CSendAppData( aRecordComposer );
  	LOG(Log::Printf(_L("self %x - %x"), self, (TUint)self + sizeof( CSendAppData ));)
	CleanupStack::PushL( self );
	self->ConstructL( aRecordComposer );
	CleanupStack::Pop();
	return self;
}

inline CSendAppData::CSendAppData( CRecordComposer& aRecordComposer ) :
   iRecordComposer( aRecordComposer  )
{
	LOG(Log::Printf(_L("CSendAppData::CSendAppData()\n"));)
	iHistory = KTlsApplicationData; // This shows explicitly where we are
}

CSendAppData::~CSendAppData()
{
	LOG(Log::Printf(_L("CSendAppData::~CSendAppData()\n"));)
   SetSockXfrLength( NULL );
   Cancel( KErrNone );
	delete iSendAlert;
}

inline void CSendAppData::ConstructL( CRecordComposer& aRecordComposer )
{
	iSendAlert = new(ELeave)CSendAlert( *this, aRecordComposer );
	LOG(Log::Printf(_L("CSendAppData::ConstructL() %x\n"), SendAlert());)
	ResumeL();
}

void CSendAppData::Suspend()
{
	LOG(Log::Printf(_L("CSendAppData::Suspend()\n"));)
   
	iCurrentPos = iRecordComposer.CurrentPos();
	iAppData = iRecordComposer.UserData();
	iRecordComposer.SetUserData( NULL );
}

void CSendAppData::ResumeL()
{
	LOG(Log::Printf(_L("CSendAppData::ResumeL()\n"));)
   
	iRecordComposer.SetUserData( iAppData );
	iRecordComposer.ReConstructL( this, iCurrentPos ); //it sets record type to ETlsAppDataContentType
	iCurrentPos = 0;
	
	if ( !iActiveEvent )
	{	//active event is the record composer
		iActiveEvent = &iRecordComposer;
	}
}

void CSendAppData::SetSockXfrLength( TInt* aLen )
{
	LOG(Log::Printf(_L("CSendAppData::SetSockXfrLength()\n"));)

	iSockXfrLength = aLen;
	if ( iSockXfrLength )
	{
		*iSockXfrLength = 0;
	}
}

void CSendAppData::OnCompletion()
{
	LOG(Log::Printf(_L("CSendAppData::OnCompletion()\n"));)
   
	TDesC8* pAppData = iRecordComposer.UserData();
	if ( pAppData ) //could have finished via an error
	{
		if ( iSockXfrLength )
		{
			*iSockXfrLength = iRecordComposer.CurrentPos();
		}
		if ( iLastError == KErrNone && iStatus.Int() == KErrNone )
		{
			//hello request received?
			if ( iStateMachineNotify == iHelloReq && iHelloReq )
			{//no user request completion, signal to hello request
				iHelloReq->OnCompletion( this );
				return;
			}
			// Anything more to send?
			else if ( pAppData->Length() > iRecordComposer.CurrentPos() )
			{	// No error (cancel) && still some app data in the app buffer =>
				// => write another fragment
				iActiveEvent = &iRecordComposer;
				Start( iClientStatus, iStateMachineNotify );
				return;
			}
		}
	}
   
	iRecordComposer.SetUserData( NULL ); //we'r finished
	iRecordComposer.ResetCurrentPos();

	/* Fix for the TLS Client hang issue DEF130128.
	 * In the case of where one of the state machines receives the 
	 * asynchronous event alert due to TLS server reset, the state 
	 * machine triggers the cleanup activities. The TlsConnection 
	 * fails to clean up  the resources allocated for handling data 
	 * transfer and TLS handshake in such cases if one of the state 
	 * machines has issued the asynchronous server request and is 
	 * waiting for the request to complete. The change made below 
	 * will allow the code complete the pending status in such cases 
	 * and allow the cleanup to proceed.
	 */
	if ( iStatus.Int() == KRequestPending )
		{
			TRequestStatus* p=&iStatus;
			User::RequestComplete( p, iLastError );
		}
	/* End of fix for the TLS Client hang issue DEF130128. */
	
	CStateMachine::OnCompletion();
}

void CSendAppData::DoCancel()
{
	LOG(Log::Printf(_L("CSendAppData::DoCancel()\n"));)

	iLastError = KErrCancel;
	iRecordComposer.CancelAll();
	CStateMachine::DoCancel();
}

//
//
CRecvAppData* CRecvAppData::NewL( CTlsConnection& aTlsConnection )
{
	LOG(Log::Printf(_L("CRecvAppData::NewL()"));)
	CRecvAppData* self = new(ELeave) CRecvAppData( aTlsConnection );
  	LOG(Log::Printf(_L("self %x - %x"), self, (TUint)self + sizeof( CRecvAppData ));)
	CleanupStack::PushL( self );
	self->ConstructL( aTlsConnection );
	CleanupStack::Pop();
	return self;
}

inline CRecvAppData::CRecvAppData( CTlsConnection& aTlsConnection ) :
   iHeldData( 0, 0 ),
   iRecordParser( aTlsConnection.RecordParser() )
{
	LOG(Log::Printf(_L("CRecvAppData::CRecvAppData()\n"));)
	iHistory = KTlsApplicationData; // This shows explicitly where we are
}

CRecvAppData::~CRecvAppData()
{
	LOG(Log::Printf(_L("CRecvAppData::~CRecvAppData()\n"));)
   SetSockXfrLength( NULL );
   Cancel( KErrNone );
	delete iSendAlert;
}

inline void CRecvAppData::ConstructL( CTlsConnection& aTlsConnection )
{
	iSendAlert = new(ELeave)CSendAlert( *this, aTlsConnection.RecordComposer() );
	LOG(Log::Printf(_L("CRecvAppData::ConstructL() %x\n"), SendAlert());)
	ResumeL( aTlsConnection );
}

void CRecvAppData::Suspend()
{
	LOG(Log::Printf(_L("CRecvAppData::Suspend()\n"));)
   
	iHeldData = iRecordParser.HeldData();
	iAppData = iRecordParser.UserData();
	iRecordParser.SetUserData( NULL );
	iRecordParser.SetUserMaxLength( 0 );
}

void CRecvAppData::ResumeL( CTlsConnection& aTlsConnection )
{
	LOG(Log::Printf(_L("CRecvAppData::ResumeL()"));)
	
	__ASSERT_DEBUG( (iAppData && iClientStatus) || (!iAppData && !iClientStatus), TlsPanic(ETlsPanicAppDataResumeButNotStarted));
	__ASSERT_DEBUG( iSendAlert, TlsPanic(ETlsPanicAlertReceived));
	iRecordParser.SetUserData( iAppData );
	iRecordParser.SetUserMaxLength( iAppData ? iAppData->MaxLength() : 0 );
	iRecordParser.ReConstructL( this, iHeldData, *iSendAlert );

	// Destroy the Rx list & add the only handshake event accepted during application data mode.
	CHandshakeParser* pParser = iRecordParser.HandshakeParser();
	pParser->DestroyRxList();
	CHelloRequest* helloReq = new(ELeave)CHelloRequest( aTlsConnection, *this );
	//coverity[leave_without_push]
	LOG(Log::Printf(_L("helloReq %x - %x"), helloReq, (TUint)helloReq + sizeof( CHelloRequest ));)
	pParser->AddToList( *helloReq );

	aTlsConnection.SendAppData()->SetHelloRequest( helloReq ); //no ownership passed
	if ( !iActiveEvent )
	{	//active event is the record parser
		iActiveEvent = &iRecordParser;
	}
}

void CRecvAppData::OnCompletion()
{
	LOG(Log::Printf(_L("CRecvAppData::OnCompletion()\n"));)

   if ( iLastError == KErrNone && iStatus.Int() == KErrNone )
   {
      if ( iRecordParser.TlsRecordType() == ETlsHandshakeContentType )
      {//it could be just hello request received => suspend() could have already happened
         return;
      }
	   TDes8* pAppData = iRecordParser.UserData();
	   if ( pAppData ) //could have finished via an error
	   {
		   if ( iSockXfrLength && pAppData->Length() ) //are we to report RecvOneOrMore?
		   {	//yes and finish
			   *iSockXfrLength = pAppData->Length();
		   }
		   else if ( pAppData->Length() < pAppData->MaxLength() )
		   {	//no error (cancel) && still some free room in the app data buffer =>
			   //=> read another fragment
			   iActiveEvent = &iRecordParser;
			   Start( iClientStatus, iStateMachineNotify );
			   return;
		   }
	   }
   }
   
	iRecordParser.SetUserData( NULL ); //we'r finished
	iRecordParser.SetUserMaxLength( 0 );
	
	/* Fix for the TLS Client hang issue DEF130128.
	 * In the case of where one of the state machines receives the 
	 * asynchronous event alert due to TLS server reset, the state 
	 * machine triggers the cleanup activities. The TlsConnection 
	 * fails to clean up  the resources allocated for handling data 
	 * transfer and TLS handshake in such cases if one of the state 
	 * machines has issued the asynchronous server request and is 
	 * waiting for the request to complete. The change made below 
	 * will allow the code complete the pending status in such cases 
	 * and allow the cleanup to proceed.
	 */
	if ( iStatus.Int() == KRequestPending )
		{
			TRequestStatus* p=&iStatus;
			User::RequestComplete( p, iLastError );
		}
	/* End of fix for the TLS Client hang issue DEF130128. */
	
	CStateMachine::OnCompletion();
}

void CRecvAppData::DoCancel()
{
	LOG(Log::Printf(_L("CRecvAppData::DoCancel()\n"));)
   
    iLastError = KErrCancel; 
	iRecordParser.CancelAll();
	CStateMachine::DoCancel();
}