/*

* Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

* secdlgImpl.cpp

*

*/

#include "Tsecdlg.h"

#include <secdlgimpldefs.h>

#include <certificateapps.h>

#include <x509cert.h>

// These are not really allocated to us, but this is only for finding errors

// while debugging, so it doesn't really matter

const TInt KErrTooManyDialogs			= -12000;

const TInt KErrLabelMismatch 			= -12001;

const TInt KErrOperationMismatch		= -12002;

const TInt KErrOperationNotSupported	= -12003;

_LIT(KpinValue,"pinkcloud");

_LIT(KYes,"Yes");

// ----------------------------------------------------------------------------

// Lib main entry point.

// This can leave and should leave (if failure occurs) despite the lack of trailing L.

//

#ifdef _T_SECDLG_TEXTSHELL

EXPORT_C CArrayPtr<MNotifierBase2>* NotifierArray()

#else

CArrayPtr<MNotifierBase2>* NotifierArray()

#endif

	{

	//The notifierArray function CAN leave, despite no trailing L

	CArrayPtrFlat<MNotifierBase2>* subjects = new (ELeave) CArrayPtrFlat<MNotifierBase2>( 1 );

	CleanupStack::PushL(subjects);

	CTestSecDlgNotifier* notifier = CTestSecDlgNotifier::NewL();

	CleanupStack::PushL( notifier );

	subjects->AppendL( notifier );

	CleanupStack::Pop( 2,subjects);	//notifier, subjects

	return subjects;

	}

// ----------------------------------------------------------------------------

// Ecom plugin implementation for UI notifier

//

#ifndef _T_SECDLG_TEXTSHELL

const TImplementationProxy ImplementationTable[] =

	{

		IMPLEMENTATION_PROXY_ENTRY(KTSecDlgNotiferUid, NotifierArray)

	};

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

	{

	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

	return (ImplementationTable);

	}

#endif

// ----------------------------------------------------------------------------

// CInputSpec

//

CInputSpec::CInputSpec(TSecurityDialogOperation aOp, HBufC* aLabelSpec, HBufC* aResponse1, HBufC* aResponse2) :

	iOp(aOp), iLabelSpec(aLabelSpec), iResponse1(aResponse1), iResponse2(aResponse2)

	{

	}

CInputSpec::~CInputSpec()

	{

	delete iLabelSpec;

	delete iResponse1;

	delete iResponse2;

	}

// ----------------------------------------------------------------------------

// CTestSecDlgNotifier

//

_LIT(KInputFile, "\\t_secdlg_in.dat");

_LIT(KOutputFile, "\\t_secdlg_out.dat");

CTestSecDlgNotifier* CTestSecDlgNotifier::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CTestSecDlgNotifier::CTestSecDlgNotifier()

	{

	iInfo.iUid = KUidSecurityDialogNotifier;

	iInfo.iChannel = TUid::Uid(0x00001234); // dummy

	iInfo.iPriority = ENotifierPriorityHigh;

	}

void CTestSecDlgNotifier::ConstructL()

	{

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

	}

TInt CTestSecDlgNotifier::GetInputIndexL()

	{

	RFileReadStream stream;

	TDriveUnit sysDrive (RFs::GetSystemDrive());

	TDriveName driveName(sysDrive.Name());

	TBuf<128> outputFile (driveName);

	outputFile.Append(KOutputFile);

	TInt err = stream.Open(iFs, outputFile, EFileRead | EFileShareExclusive);

	// If the file doesn't exist yet just return zero

	if (err == KErrNotFound)

		{

		return 0;

		}

	User::LeaveIfError(err);

	stream.PushL();

	TInt index = stream.ReadInt32L();

	CleanupStack::PopAndDestroy(); // stream

	return index;

	}

void CTestSecDlgNotifier::WriteDialogCountL(TInt aCount)

	{

	RFileWriteStream stream;

	TDriveUnit sysDrive (RFs::GetSystemDrive());

	TDriveName driveName(sysDrive.Name());

	TBuf<128> outputFile (driveName);

	outputFile.Append(KOutputFile);

	TInt err = stream.Replace(iFs, outputFile, EFileWrite | EFileShareExclusive);

	if (err == KErrNotFound)

		{

		err = stream.Create(iFs, outputFile, EFileWrite | EFileShareExclusive);

		}

	User::LeaveIfError(err);

	stream.PushL();

	stream.WriteInt32L(aCount);

	stream.CommitL();

	CleanupStack::PopAndDestroy(); // stream	

	}

CInputSpec* CTestSecDlgNotifier::ReadInputSpecL(TInt aIndex)

	{

	RFileReadStream stream;

	TDriveUnit sysDrive (RFs::GetSystemDrive());

	TDriveName driveName(sysDrive.Name());

	TBuf<128> inputFile (driveName);

	inputFile.Append(KInputFile);

	User::LeaveIfError(stream.Open(iFs, inputFile, EFileRead | EFileShareExclusive));

	stream.PushL();

	// Update dialog count here so test code can see how many dialogs were

	// requested if there were more than expected

	WriteDialogCountL(aIndex + 1);

	MStreamBuf* streamBuf = stream.Source();

	TInt labelSize, response1Size, response2Size;

	// Skip records until we reach the one we want

	for (TInt i = 0 ; i < aIndex ; ++i)

		{

		stream.ReadInt32L();

		labelSize = stream.ReadInt32L();

		streamBuf->SeekL(MStreamBuf::ERead, EStreamMark, labelSize * 2);

		response1Size = stream.ReadInt32L();

		streamBuf->SeekL(MStreamBuf::ERead, EStreamMark, response1Size * 2);

		response2Size = stream.ReadInt32L();

		streamBuf->SeekL(MStreamBuf::ERead, EStreamMark, response2Size * 2);

		}

	TSecurityDialogOperation op = static_cast<TSecurityDialogOperation>(stream.ReadInt32L());

	labelSize = stream.ReadInt32L();

	HBufC* labelSpec = HBufC::NewMaxLC(labelSize);

	TPtr labelPtr(labelSpec->Des());

	stream.ReadL(labelPtr, labelSize);

	response1Size = stream.ReadInt32L();

	HBufC* response1 = HBufC::NewMaxLC(response1Size);

	TPtr response1Ptr(response1->Des());

	stream.ReadL(response1Ptr, response1Size);

	response2Size = stream.ReadInt32L();

	HBufC* response2 = HBufC::NewMaxLC(response2Size);

	TPtr response2Ptr(response2->Des());

	stream.ReadL(response2Ptr, response2Size);

	CInputSpec* inputSpec = new (ELeave) CInputSpec(op, labelSpec, response1, response2);	

	CleanupStack::Pop(3, labelSpec);	

	CleanupStack::PopAndDestroy(); // stream

	return inputSpec;

	}

void CTestSecDlgNotifier::DoEnterPINL(const CInputSpec& aSpec, const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage)

	{

	const TPINInput& pinInput = reinterpret_cast<const TPINInput&>(*aBuffer.Ptr());

	if (pinInput.iPIN.iPINLabel.Find(aSpec.LabelSpec()) == KErrNotFound)

		{

		User::Leave(KErrLabelMismatch);

		}

	TPINValue pinValue = aSpec.Response1();

	TPckg<TPINValue> pinValueBufPtr(pinValue);

	aMessage.WriteL(aReplySlot, pinValueBufPtr);

	}

void CTestSecDlgNotifier::DoChangePINL(const CInputSpec& aSpec, const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage)

	{

	const TPINInput& input = reinterpret_cast<const TPINInput&>(*aBuffer.Ptr());

	if (input.iPIN.iPINLabel.Find(aSpec.LabelSpec()) == KErrNotFound)

		{

		User::Leave(KErrLabelMismatch);

		}

	TTwoPINOutput output;

	output.iPINValueToCheck = aSpec.Response1();

	output.iNewPINValue = aSpec.Response2();

	TPckg<TTwoPINOutput> outputPckg(output);

	aMessage.WriteL(aReplySlot, outputPckg);

	}

void CTestSecDlgNotifier::Release()

	{

	delete this;

	}

CTestSecDlgNotifier::TNotifierInfo CTestSecDlgNotifier::RegisterL()

	{

	return iInfo;

	}

CTestSecDlgNotifier::TNotifierInfo CTestSecDlgNotifier::Info() const

	{

	return iInfo;

	}

void CTestSecDlgNotifier::StartL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage)

	{

	TRAPD(err, DoStartL(aBuffer, aReplySlot, aMessage));

	aMessage.Complete(err);

	}

void CTestSecDlgNotifier::DoStartL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage)

	{

	// Minimum length is 4

	__ASSERT_DEBUG( aBuffer.Length() >= 4, User::Panic(_L("CTestSecDlgNotifier"), 0));

	TUint operation = *reinterpret_cast<const TInt *>(aBuffer.Ptr()) & KSecurityDialogOperationMask;

	TInt index = GetInputIndexL();

	CInputSpec* spec = NULL;

	TRAPD(err, spec = ReadInputSpecL(index));

	// If the input file doesn't exist then we will answer PIN requests with the

	// "pinkcloud" passphrase - this is so the certstore tests work independantly

	// from keystore

	if (err == KErrNotFound)

		{

		switch(operation)

			{

			case EEnterPIN:

				{

				TPINValue pinValue(KpinValue);

				TPckg<TPINValue> pinValueBufPtr(pinValue);

				aMessage.WriteL(aReplySlot, pinValueBufPtr);

				break;

				}

			case EServerAuthenticationFailure:

				{

				TServerAuthenticationFailureDialogResult output;

				output = EStop;				

	    		TServerAuthenticationFailureOutputBuf outputPckg(output);	

				aMessage.WriteL(aReplySlot, outputPckg);

				break;

				}

			default:

				{

				User::Leave(KErrOperationMismatch);

				break;

				}			

			}

		return;	

		}

	if (err == KErrEof)

		{

		User::Leave(KErrTooManyDialogs);

		}

	User::LeaveIfError(err);

	CleanupStack::PushL(spec);

	if (operation != spec->Operation())

		{

		User::Leave(KErrOperationMismatch);

		}

	switch (operation)

		{

		case EEnterPIN:

			DoEnterPINL(*spec, aBuffer, aReplySlot, aMessage);

			break;

		case EChangePIN:

			DoChangePINL(*spec, aBuffer, aReplySlot, aMessage);

			break;

		case ESecureConnection:

 			DoSecureConnectionL(*spec, aBuffer, aReplySlot, aMessage);

 			break;

		case ESignText:

		case EEnablePIN:

		case EDisablePIN:

		case EUnblockPIN:		

		case EUnblockPINInClear:

		case EPINBlocked:

			// these operations are not yet implemented in this test harness

			User::Leave(KErrOperationNotSupported);

			break;

		case EServerAuthenticationFailure:

			DoServerAuthenticationFailureL(*spec, aBuffer, aReplySlot, aMessage);

			break;

		default:

			User::Panic(_L("CTestSecDlgNotifier"), 0);

		}

	CleanupStack::PopAndDestroy(spec);

	}

void CTestSecDlgNotifier::DoServerAuthenticationFailureL(const CInputSpec& aSpec, const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage )

	{

	// Test for valid packing of dialog data by extracting the encoded certificate

	// and attempting to construct an X509 certificate from it.

	CServerAuthenticationFailureInput* srvAuthFail = CServerAuthenticationFailureInput::NewLC(aBuffer);

	TPtrC8 encodedCert;

	srvAuthFail->GetEncodedCert(encodedCert);

	// If CX509Certificate::NewL leaves the encoded cert buffer must not be valid.

	const CX509Certificate* cert = CX509Certificate::NewL(encodedCert);

	// There is no further need for the cert, so it can be deleted immediately.

	delete cert;

	CleanupStack::PopAndDestroy(srvAuthFail);

	TServerAuthenticationFailureDialogResult output;

	output = EStop;

	if( (aSpec.Response1()).CompareF(KYes) == KErrNone )

		{

		output = EContinue;			

		}

	TServerAuthenticationFailureOutputBuf outputPckg(output);	

	aMessage.WriteL(aReplySlot, outputPckg);

	}

void CTestSecDlgNotifier::DoSecureConnectionL(const CInputSpec& aSpec, const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage )

	{

	// If the client does not want to continue

	if( (aSpec.Response1()).CompareF(KYes) != KErrNone )

		{

		User::Leave(KErrCancel);	

		}

	else

		{

		const TSignInput* secureConnectionInput =

								reinterpret_cast<const TSignInput*>( aBuffer.Ptr() );

		// if the client certificate is requested

		if (secureConnectionInput->iDoClientAuthentication)

			{			

			TLex lexi(aSpec.Response2());

			TInt32 selectionId=0;

			TInt err=lexi.Val(selectionId);

			TInt certHandleTotal = secureConnectionInput->iCertHandleArrayTotal;

			if (selectionId>certHandleTotal)

				{

				User::Leave(KErrNotFound);	

				}

			// Get index at start of list of TCTTokenObjectHandle objects

			TInt bufferIndex = sizeof( TSignInput );

			TInt certHandleSize = sizeof( TCTTokenObjectHandle );

			TPckgBuf<TCTTokenObjectHandle> certHandleBuf;

			TPtrC8 certHandleData( aBuffer.Mid( bufferIndex+(selectionId-1)*certHandleSize, certHandleSize ) );

			certHandleBuf.Copy( certHandleData );

			aMessage.WriteL( aReplySlot, certHandleBuf );			

			}			

		}	

	}	

TPtrC8 CTestSecDlgNotifier::StartL( const TDesC8& /*aBuffer*/ )

	{

	User::Panic(_L("CTestSecDlgNotifier"), 0);

	return TPtrC8(KNullDesC8);

	}

void CTestSecDlgNotifier::Cancel()

	{

	// Don't think there is much we can do here. If a client deletes the

	// client-side security dialog instance, after calling a method that 

	// displays a dialog, this will not get called until the user dismisses

	// the dialog. We can't do anything then.

	}

TPtrC8 CTestSecDlgNotifier::UpdateL( const TDesC8& /*aBuffer*/ )

	{

	User::Panic(_L("CTestSecDlgNotifier"), 0);

	return NULL;

	}