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

//

/**

 @file handshakestep.cpp

 @internalTechnology

*/

#include "handshakestep.h"

#include <tlsprovinterface.h>

_LIT(KWebAddress,"WebAddress");

_LIT(KWebPage,"WebPage");

_LIT(KPortNum,"PortNum");

_LIT(KExpectedFinalCipher, "ExpectedFinalCipherSuit");

_LIT(KExpectedSetCipherError, "ExpectedSetCipherError");

_LIT(KExpectedHandshakeError, "ExpectedHandshakeError");

_LIT8(KSimpleGet, "GET /");

_LIT8(KGetTail, " HTTP/1.0\r\n\r\n");

_LIT8(KExpectedPageContent, "Hello world");

_LIT8(KPSK_IDENTITY, "Client_identity");

_LIT8(KPSK_KEY, "0123456789"); 

_LIT(KNumServerNames, "NumServerNames");

_LIT(KServerNameBase, "ServerName");

// CertRequest tester active.

CHandShakeTesterActive::CHandShakeTesterActive( CTestExecuteLogger& aLogger ) : 

   CActive( EPriorityStandard ),

   iLogger( aLogger )

	{

	CActiveScheduler::Add( this );

	}

CHandShakeTesterActive::~CHandShakeTesterActive()

	{

	}

/** This is the core of the test, it handshakes a TLS test server, if succesfull it

    requests a web page from the TLS server, if the page was received succesfully it

    checks its content. Finally it checks the cipher suite used is what was expected. 

	@param None

	@return TVeredic EPass if all test sequence was completed an succesful.

	*/

TVerdict CHandShakeTesterActive::DoSecureConnectionTestL(CHandShakeStep* master)

	{

	TInt error_Returned;

	iStepPointer = master;

	// Negociates secure connection.

	error_Returned = HandShakeL();

	if (error_Returned != iStepPointer->iExpectedHandshakeError)

		{

		ERR_PRINTF3(_L("Handshake failed, Expected error: %D Received Error: %D"), iStepPointer->iExpectedHandshakeError, error_Returned);

		return EFail;

		} 

	else if( error_Returned != KErrNone) 

		{

		// An error was received but it was expected, communication can not continue as handshake failed.

		ERR_PRINTF2(_L("Test abbreviated as expected handshake error %D was received."), error_Returned);

		return EPass;  // Terminates test.	

		}

	// request a web page to server.

	if (MakePageRequest() != KErrNone)

		{

		ERR_PRINTF1(_L("Page request failed"));

		return EFail;

		} 

	// Invokes appropiate methods to receive web page.

	GetPageReceivedL();

	//	Verify that the page received has the expected content.

 	if (VerifyPageReceived() != KErrNone)

		{

		ERR_PRINTF1(_L("Page received not what expected"));

		return EFail;

		}   

	// debug, outputs page received to file.

	// OutputPageToFileL(iStepPointer->iRcvPage); // debug 	

	// 	Check that the cipher suite negociated on handshake is the one

	//  expected by the tester.

	if (VerifyFinalCipherUsed() != KErrNone)

		{

		ERR_PRINTF1(_L("The final cipher Suite used not what expected"));

		return EFail;

		}   

	return EPass; 

	}

void CHandShakeStep::GetPskL(const HBufC8 */*aPskIdentityHint*/, HBufC8 *&aPskIdentity, HBufC8 *&aPskKey)

	{   

	aPskIdentity = KPSK_IDENTITY().AllocL();

	aPskKey = KPSK_KEY().AllocL();

	return;

	}

/** Establishes secure connection to TLS test server by using 

    CSecureSocket::StartClientHandshake method.

	@param None

	@return TInt ,return error code returned by status of StartClientHandshake method.

	*/

TInt CHandShakeTesterActive::HandShakeL()

	{

	_LIT(KTLS1,"TLS1.0");

	iStepPointer->iTlsSocket = CSecureSocket::NewL( iStepPointer->iSocket, KTLS1 );

	// Clears any previous options

	iStepPointer->iTlsSocket->FlushSessionCache();

	// Sets Call back if needed.

	iStepPointer->SetPskL();

	// Sets Null cipher if needed.

	iStepPointer->SetNullCipherL();

	// No client authentication or dialogs for this test.

	iStepPointer->iTlsSocket->SetClientCertMode(EClientCertModeIgnore);

	iStepPointer->iTlsSocket->SetDialogMode(EDialogModeUnattended);

	// Sets Server Name

	if(iStepPointer->iUseServerNames)

		{

		TPckgC<CDesC8Array *> serverNamePkg(iStepPointer->iServerNamesArray);

		User::LeaveIfError(iStepPointer->iTlsSocket->SetOpt(KSoServerNameIndication, KSolInetSSL, serverNamePkg));	

		}

	// Alternatively dialog mode attended could be used for manual tests.

	// 	iStepPointer->iTlsSocket->SetClientCertMode(EClientCertModeOptional); // debug

	// 	iStepPointer->iTlsSocket->SetDialogMode(EDialogModeAttended); // debug

	// Set cipher suits to be presented in client hello message for handshake.

	TInt setCipherSuitesError;

	setCipherSuitesError = iStepPointer->iTlsSocket->SetAvailableCipherSuites( *(iStepPointer->iBufCipherSuitesFromIni));   

	if ( setCipherSuitesError != iStepPointer->iExpectedSetSuitesError)

		{

		ERR_PRINTF3(_L("The SetAvailableCipherSuites method returned error: %d but error expected was: %d"), setCipherSuitesError , iStepPointer->iExpectedSetSuitesError);

		User::Leave(KErrGeneral);	

		}

	// start the handshake 

	iStepPointer->iTlsSocket->StartClientHandshake( iStatus);  

	iState = ESecureConnected; 

	SetActive();

	CActiveScheduler::Start(); 

	return iStatus.Int();  

	}	

/** Requests web page to TLS test server. 

	@param None

	@return TInt ,return error code returned by status of CSecureSocket::Send method.

	*/

TInt  CHandShakeTesterActive::MakePageRequest()

	{

	// Create a GET request

	iStepPointer->iSndBuffer += KSimpleGet;

	iStepPointer->iSndBuffer += iStepPointer->iConnectSettings.iPage;

	iStepPointer->iSndBuffer += KGetTail;

	// Send the request

	iStepPointer->iTlsSocket->Send( iStepPointer->iSndBuffer, iStatus, iStepPointer->iBytesSent );

	iState = EGetRequestSent;

	SetActive();

	CActiveScheduler::Start();

	return iStatus.Int();  

	}

/** Receives web page previously requested to TLS test server. 

	@param None

	@return TInt ,return error code returned by status of CSecureSocket::Recv method.

	*/

void CHandShakeTesterActive::GetPageReceivedL()

	{

	// check for unexpected error.

	if(iStatus != KErrEof && iStatus != KErrNone)

		{

		ERR_PRINTF2(_L("Unexpected error received on get page requested: %d"), iStatus.Int());

		User::Leave(iStatus.Int());		

		}

	// First receive invoked (status equals to KErrNone)

	if(iStatus == KErrNone) 

		{

		iStepPointer->iRcvBuffer.SetLength( 0 );

		iStepPointer->iTlsSocket->Recv( iStepPointer->iRcvBuffer, iStatus );

		iState = EGetPageReceived;

		SetActive();

		CActiveScheduler::Start();

		INFO_PRINTF1(_L("New packet received (for page request)"));

		// Append received packet to page received so far. 

		iStepPointer->iRcvPage.Append(iStepPointer->iRcvBuffer);	

		}

	// KErrEof or buffer with length zero  received.

	if(iStatus == KErrEof || iStepPointer->iRcvBuffer.Length() == 0)

		{

		// Tells the state machine to stop requesting for more packets.

		iState = EIdle;

		return;

		}

	}

/** Compares the received page content against expected content.

    At present the expected content is hardcoded in constant KExpectedPageContent,

    if more sofisticated web pages checkings are needed test code may need to be modified to

    read expected content from binary file.  

	@param None

	@return KErrNone if webpage is what is expected , otherwise returns KErrGeneral.

	*/	

TInt CHandShakeTesterActive::VerifyPageReceived()

	{

	if( iStepPointer->iRcvPage == KExpectedPageContent)

		{

		return KErrNone;

		}

	else

		{

		return KErrGeneral;

		}

	}

/** Checks that the cipher suit agreed in the TLS handshake is what the tester

	was expecting.

   	@param None

	@return KErrNone if final cipher suite is what is expected , otherwise returns KErrGeneral.

	*/

TInt CHandShakeTesterActive::VerifyFinalCipherUsed()

	{

	TBuf8<2>	finalCipherBuffer; 

	TInt    	finalCipher=0;

	iStepPointer->iTlsSocket->CurrentCipherSuite(finalCipherBuffer);

	// Converts two bytes buffer in single integer.

	finalCipher += finalCipherBuffer[1];

	finalCipher += (finalCipherBuffer[0] << 8);

	if( iStepPointer->iExpectedFinalCipher == finalCipher)

		{

		return KErrNone;

		}

	else   

		{

		ERR_PRINTF3(_L("Used cipher: %d. Expected cipher: %d"), finalCipher, iStepPointer->iExpectedFinalCipher );

		return KErrGeneral;

		}

	}

void CHandShakeTesterActive::OutputPageToFileL(const TDesC8& aPageReceived)

	{

	RFs	fs;

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

	TDriveUnit sysDrive (RFs::GetSystemDrive());

	TBuf<128> rName (sysDrive.Name());;

	rName.Append(_L("\\tlstest2\\myresults\\"));

	TInt err = fs.MkDir(rName);

	if (err != KErrNone && err != KErrAlreadyExists)

		{

		// This line will panic if directory does not exist.

		User::Leave(err);	

		}

	RFile file;

	CleanupClosePushL(file);

	_LIT(KExtension, ".html");

	rName.Append(iStepPointer->ConfigSection());

	rName.Append(KExtension);

	rName.LowerCase();

	User::LeaveIfError(file.Replace(fs, rName, EFileWrite | EFileStream));

	User::LeaveIfError(file.Write(aPageReceived));

	CleanupStack::PopAndDestroy(&file);

	fs.Close ();

	}

TInt CHandShakeTesterActive::RunError(TInt aError)

	{

	iRunError = aError;

	CActiveScheduler::Stop();

	return KErrNone;

	}

/** RunL method used for all asyncronous requests made by test code.

   	*/

void CHandShakeTesterActive::RunL()

	{

		iRunError =KErrNone;

		User::LeaveIfError(iStatus.Int());

		switch(iState)

			{

			case EIdle:

				CActiveScheduler::Stop();

				break;

			case ESecureConnected:

				INFO_PRINTF1(_L(" secure connection made "));

				iState = EIdle;

				CActiveScheduler::Stop();

				break;

			case EGetRequestSent:

				INFO_PRINTF1(_L(" Page requested "));

				iState = EIdle;

				CActiveScheduler::Stop();

				break; 

			case EGetPageReceived:

				// Keeps getting packages until KErrEof is received.  

				GetPageReceivedL();

				// This line will be reach only after all packages received.

				CActiveScheduler::Stop();

				break; 

			default:

				{

				INFO_PRINTF1(_L("HandShakeTesterActive: State corrupted."));

				User::Leave(KErrCorrupt);

				}

			} 

	return; 

	}

CHandShakeStep::CHandShakeStep()

	{

	SetTestStepName(KHandShakeTestStep);

	}

CHandShakeStep::~CHandShakeStep()

	{

	delete iBufCipherSuitesFromIni;

	iSndBuffer.Close();

	iRcvBuffer.Close();	

	iRcvPage.Close();

	if (iActiveObjTest)

		{

		delete iActiveObjTest;

		}

	}

/** Test preamble reads all ini values needed for test, these are:

 	NumCipherSuites: (int) The number of cipher suit to be included in client hello message.

   	CipherSuiteX: (hex) individual cipher suite to be included in client hello message.

	WebAddress: (string) address of the test server could be decimal doted or human readable.

	WebPage: (string) Test page to be requested to test server.

	PortNum: (int) listening port used by test server.

	ExpectedFinalCipherSuit: (hex) The cipher suite that is expected to be adopted on hnadshake.

	UsePsk: (Bool) Use to indicate if optional PSK cipher suites are to be included in list 

	of cipher suites send client hello message. 	

	*/

TVerdict CHandShakeStep::doTestStepPreambleL()

	{

	// Reads cipher suites to be sent in client hello message.

	iBufCipherSuitesFromIni = ReadCipherSuitesL();

	// Reads web address, this value is mandatory.

	TPtrC   webAddress;

	if(GetStringFromConfig(ConfigSection(), KWebAddress, webAddress))

		{

		iConnectSettings.iAddress = webAddress;

		}

	else

		{

		ERR_PRINTF1(_L("Failed to read web address value from INI file."));

		User::Leave(KErrNotFound);

		}

	// Reads page web to be requested, this value is mandatory

	TPtrC   page;

	if(GetStringFromConfig(ConfigSection(), KWebPage, page))

		{

		iConnectSettings.iPage.Copy(page) ;

		}

	else

		{

		ERR_PRINTF1(_L("Failed to read page value from INI file."));

		User::Leave(KErrNotFound);

		}

	// Reads port, this value is mandatory

	TInt   portNum;

	if(GetIntFromConfig(ConfigSection(), KPortNum, portNum))

		{

		iConnectSettings.iPortNum = portNum;

		}

	else

		{

		ERR_PRINTF1(_L("Failed to read Port Number from INI file"));

		User::Leave(KErrNotFound);

		}

	// Reads expected final cipher suits, mandatory value

	TInt cipher;	

	if(GetHexFromConfig(ConfigSection(), KExpectedFinalCipher, cipher))

		{

		iExpectedFinalCipher = cipher;

		}

	else

		{

		ERR_PRINTF1(_L("Failed to read Expect final cipher value from INI file."));

		User::Leave(KErrNotFound);

		}

	// Reads expected set cipher suites error, optional value

	TInt expectedSetSuitesError;	

	if(GetIntFromConfig(ConfigSection(), KExpectedSetCipherError, expectedSetSuitesError))

		{

		iExpectedSetSuitesError = expectedSetSuitesError;

		}

	else

		{

		iExpectedSetSuitesError = KErrNone; 

		}

	// Reads expected handshake  error, optional value

	TInt expectedHandshakeError;	

	if(GetIntFromConfig(ConfigSection(), KExpectedHandshakeError, expectedHandshakeError))

		{

		iExpectedHandshakeError = expectedHandshakeError;

		}

	else

		{

		iExpectedHandshakeError = KErrNone; 

		}

	// Initialises send and receive buffers

	iSndBuffer.CreateL(KSendBufferSize);

	iRcvBuffer.CreateL(KReceiveBufferSize);

	iRcvPage.CreateL(KReceiveBufferSize * 8); // Assumes 8 packages will be enough

	// Reads PSK options (optional)

	TBool option;	

	if(GetBoolFromConfig(ConfigSection(), KUsePsk, option))

		{

		iUsePsk = option;

		}

	else

		{

		iUsePsk = EFalse;

		} 

	// Reads Null cipher options (optional)

 	TBool nullCipher;	

	if(GetBoolFromConfig(ConfigSection(), KUseNullCipher, nullCipher))

		{

		iUseNullCipher = nullCipher;

		}

	else

		{

		iUseNullCipher = EFalse;

		}  

	// Read server names from INI file.	

	iServerNamesArray = ReadServerNamesL();

	return EPass;

	}

TVerdict CHandShakeStep::doTestStepL()

	{

	doTestL();

	return TestStepResult();

	}

TVerdict CHandShakeStep::doTestL()

	{

	TVerdict testResult;

    SetTestStepResult(EFail); 

	// Instantiates scheduler

 	iSched=new(ELeave) CActiveScheduler; 

    CleanupStack::PushL(iSched);  

	CActiveScheduler::Install(iSched);

	// Initialises and connects the RSocket

	ConnectL();

	// Creates active tester object which will deal will CSecureSocket instance 

	iActiveObjTest = new (ELeave) CHandShakeTesterActive(Logger());

	CleanupStack::PushL(iActiveObjTest);

	// Creates secure socket and start client handshake.

 	testResult = iActiveObjTest->DoSecureConnectionTestL(this);

	// Deletes and closes all production code been tested.

 	CloseConnection();

	CleanupStack::PopAndDestroy(iActiveObjTest);

	iActiveObjTest = NULL;

	CleanupStack::PopAndDestroy(iSched);

	iSched=NULL;

    SetTestStepResult(testResult);

	return TestStepResult();

	}

void  CHandShakeStep::SetPskL()

	{

	if(iUsePsk)

		{

		TPckgBuf<MSoPskKeyHandler *> pskConfigPkg;

		pskConfigPkg() = this;

		User::LeaveIfError(iTlsSocket->SetOpt(KSoPskConfig, KSolInetSSL, pskConfigPkg));