/*

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

* CPinPluginAO implementation

*

*/

/**

 @file 

*/

#include "pinpluginao.h"

#include <hash.h>

#include <authserver/auth_srv_errs.h>

#include <authserver/authtypes.h>

#include <e32math.h>

using namespace AuthServer;

/** 

 KDefaultPinDigit is used to generate the default pinvalue for the DefaultData().

 The default pinvalue is generated by appending KDefaultPinDigit for iPinSize times.

 */

const TUint KDefaultPinDigit = 1;

/** 

 The selected pin index for the Train/Retrain operation, returned by

 Dialog Notifier should be in the range KIndexLow and KIndexHigh. This should

 be validated in the Dialog implementation. If Pinplugin receives any other

 values, then pinplugin will panic.

 */

const TInt KIndexLow = 0;

const TInt KIndexHigh = 3;

CPinPluginAO* CPinPluginAO::NewL(TInt aPinSize, TInt aPinMinSize, TInt aPinMaxSize, TInt aRetryCount)

	{

	CPinPluginAO* self = CPinPluginAO::NewLC(aPinSize, aPinMinSize, aPinMaxSize, aRetryCount);

	CleanupStack::Pop(self);

	return self;

	}

CPinPluginAO* CPinPluginAO::NewLC(TInt aPinSize, TInt aPinMinSize, TInt aPinMaxSize, TInt aRetryCount)

	{

	CPinPluginAO* self = new(ELeave) CPinPluginAO(aPinSize, aPinMinSize, aPinMaxSize, aRetryCount);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CPinPluginAO::CPinPluginAO(TInt aPinSize, TInt aPinMinSize, TInt aPinMaxSize, TInt aRetryCount)

	:CActive(EPriorityStandard), iRetryCount(aRetryCount), iPinSize(aPinSize), iPinMinSize(aPinMinSize),

	iPinMaxSize(aPinMaxSize)

	{

	CActiveScheduler::Add(this);

	}

void CPinPluginAO::ConstructL()

	{

	iNewPinSize = iPinSize;

	// construct PinpluginDialog

	iPinPluginDialog = CPinPluginDialog::NewL();

	// construct the DB

	iPinPluginDb = CPinPluginDB::NewL();

	iDialogResult = new (ELeave) TPinPluginDialogResult;

	iRetryRefCount = iRetryCount;

	}

CPinPluginAO::~CPinPluginAO()

	{

	Deque();

	delete iDialogResult;

	delete iPinPluginDialog;

	delete iPinPluginDb;

	iPinList.ResetAndDestroy();

	iIdKeyList.ResetAndDestroy();

	iIdKeyHashList.ResetAndDestroy();

	}

void CPinPluginAO::Identify(TIdentityId& aId, const TDesC& aClientMessage,

							HBufC8*& aResult, TRequestStatus& aRequest)

	{

	iState = EIdentify;

	iIdentityId = aId;

	iIdentityIdPtr = &aId;

	aRequest = KRequestPending;

	iRequestStatus = &aRequest;

	iClientMessage = static_cast<const HBufC*>(&aClientMessage);

	iResult = &aResult;

	aResult = NULL;	

	SetActive();

	TRequestStatus* stat = &iStatus;

	User::RequestComplete(stat, KErrNone);

	}

void CPinPluginAO::Train(TIdentityId aId, HBufC8*& aResult, TRequestStatus& aRequest)

	{

	iState = ETrain;

	iIdentityId = aId;

	aRequest = KRequestPending;

	iRequestStatus = &aRequest;

	iResult = &aResult;

	aResult = NULL;	

	SetActive();

	TRequestStatus* stat = &iStatus;

	User::RequestComplete(stat, KErrNone);

    }

TInt CPinPluginAO::DefaultData(TIdentityId aId, HBufC8*& aOutputBuf)

	{

	aOutputBuf = NULL;

	TPinValue defaultPin;

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

		{

		defaultPin.AppendNum(KDefaultPinDigit);	

		}

	HBufC8* identityKey = NULL;

	HBufC8* identityKeyHash = NULL;

	TRAPD(err, 

		identityKeyHash = GenerateKeyHashL(defaultPin, identityKey);

		CleanupStack::PushL(identityKeyHash);

		CleanupStack::PushL(identityKey);

		aOutputBuf = (*identityKey).AllocL();

		iPinPluginDb->AddPinL(aId, *identityKeyHash);

		CleanupStack::PopAndDestroy(2, identityKeyHash));

	return err;

	}

TInt CPinPluginAO::Forget(TIdentityId aId)

	{

	TInt err = KErrNone;

	TRAP(err, iPinPluginDb->RemovePinL(aId));

	if (err == KErrNotFound)

		{

		err = KErrAuthServNoSuchIdentity;

		}

	return err;

	}

void CPinPluginAO::ResetL(TIdentityId aIdentityId, const TDesC& aRegistrationData, HBufC8*& aResult)

	{

	// Remove the current trained information and register using the newly supplied registration

	// data (Since pin plugin is a knowledge based plugin, the registration data supplied is assumed to be the pin)

	// For other plugin types this information is ignored and the identity is simply set as untrained

	// If no registration data is supplied then just perform a forget

	if (aRegistrationData == KNullDesC)

		{

		aResult = NULL;

		TInt err = Forget(aIdentityId);

		User::LeaveIfError(err);

		return;

		}

	// Ensure registration data length is less than or equal to max allowed pin length

	TInt pinLen = aRegistrationData.Length();

	if (pinLen > KMaxPinLength)

		{

		User::Leave(KErrArgument);

		}

	// Convert registration data to 8 bit 

	// Note that no unicode conversion is being done here since a pin cannot be in unicode

	RBuf8 pinBuf;

	pinBuf.CreateL(pinLen);

	CleanupClosePushL(pinBuf);

	pinBuf.Copy(aRegistrationData.Left(pinLen));

	TPinValue pin(pinBuf);

	CleanupStack::PopAndDestroy(&pinBuf);

	// Generate the identity key and identity key hash

	HBufC8* identityKey = NULL;

	HBufC8* identityKeyHash = GenerateKeyHashL(pin, identityKey);

	CleanupStack::PushL(identityKeyHash);

	CleanupStack::PushL(identityKey);

	// Ensure another identity doesn't have the same pin

	TIdentityId tempId = iPinPluginDb->IdFromPin(*identityKeyHash);

	if ((tempId != aIdentityId) && (tempId != KUnknownIdentity))

		{

		CleanupStack::PopAndDestroy(2, identityKeyHash);

		// This appears to be the most appropriate error code - The important point is to convery Reset has failed.

		User::Leave(KErrInUse);

		}

	else if (tempId == aIdentityId)

		{

		// Nothing to do

		aResult = identityKey;		// Ownership transferred to caller

		CleanupStack::Pop(identityKey);

		CleanupStack::PopAndDestroy(identityKeyHash);

		return;

		}

	// Replace the training data

	iPinPluginDb->UpdatePinL(aIdentityId, *identityKeyHash);

	aResult = identityKey;		// Ownership transferred to caller

	CleanupStack::Pop(identityKey);

	CleanupStack::PopAndDestroy(identityKeyHash);

	}

void CPinPluginAO::DoCancel()

	{

	iPinPluginDialog->Cancel();

	if(iRequestStatus)

		{

		User::RequestComplete(iRequestStatus, KErrCancel);

		}

	}

void CPinPluginAO::RunL()

	{

	// Leave if there has been an error

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

	switch(iState)

		{

		case EIdentify:

			{

			IdentifyId();	

			}

			break;

		case EIdentifyResult:

			{

			if (*iDialogResult == EOk)

				{

				IdentifyResultL();

				}

			else if (*iDialogResult == ECancel)

				{

				User::RequestComplete(iRequestStatus, KErrAuthServPluginCancelled);

				}

			else if (*iDialogResult == EQuit)

				{

				User::RequestComplete(iRequestStatus, KErrAuthServPluginQuit);

				}

			*iDialogResult = static_cast<TPinPluginDialogResult>(0);

			}

			break;

		case ETrain:

			{

			TrainIdL();	

			}

			break;

		case ETrainResult:

			{

			if (*iDialogResult == EOk)

				{

				AddTrainResultToDBL();

				}

			else if (*iDialogResult == ECancel)

				{

				User::RequestComplete(iRequestStatus, KErrAuthServPluginCancelled);

				}

			else if (*iDialogResult == EQuit)

				{

				User::RequestComplete(iRequestStatus, KErrAuthServPluginQuit);

				}

			else if (*iDialogResult == ENext)

				{

				iState = ETrain;

				TRequestStatus* status = &iStatus;

				User::RequestComplete(status, KErrNone);

				SetActive();

				}

			*iDialogResult = static_cast<TPinPluginDialogResult>(0);

			}

			break;

		case EInfo:

			{

			iPinPluginDialog->PinInfo(iMessage, iStatus);

			iState = EFinished;

			SetActive();

			}

			break;

		case EFinished:

			{

			User::RequestComplete(iRequestStatus, iStatus.Int());

			}

			break;

		default:

			{

			User::Leave(KErrNotSupported);

			}

			break;

		}

	}

TInt CPinPluginAO::RunError(TInt aError)

	{

	if(iRequestStatus)

		{

		User::RequestComplete(iRequestStatus, aError);

		}

	return KErrNone;

	}

void CPinPluginAO::IdentifyId()

	{

	if (iRetryRefCount--)

		{

		iPinPluginDialog->PinIdentify(iPinMinSize, iPinMaxSize, ETrue, iPinValue, *iDialogResult, iStatus);

		iState = EIdentifyResult;

		}

	else

		{

		iRetryRefCount = iRetryCount;

		*iIdentityIdPtr = KUnknownIdentity;

		iMessage = EPinPluginIdentificationFailure;

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, KErrNone);

		iState = EInfo;

		}

	SetActive();

	}

void CPinPluginAO::IdentifyResultL()

	{

	TIdentityId identityId;

	HBufC8* identityKey = NULL;

	HBufC8* identityKeyHash = GenerateKeyHashL(iPinValue, identityKey);

	CleanupStack::PushL(identityKeyHash);

	CleanupStack::PushL(identityKey);	

	identityId = iPinPluginDb->IdFromPin(*identityKeyHash);

	if (identityId != KUnknownIdentity)

		{

		*iIdentityIdPtr = identityId;

		iRetryRefCount = iRetryCount;

		*iResult = identityKey;

		iMessage = EPinPluginIdentificationSuccess;

		iState = EInfo;

		CleanupStack::Pop(identityKey);

		}

	else

		{	

		CleanupStack::PopAndDestroy(identityKey);

		iState = EIdentify;

		}

	CleanupStack::PopAndDestroy(identityKeyHash);

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	SetActive();

	}

void CPinPluginAO::TrainIdL()

	{

        // Check for invalid pinsize.

	if( !(iNewPinSize >= iPinMinSize && iNewPinSize <= iPinMaxSize)  )

                {

                User::Leave(KErrAuthServRegistrationFailed);

                }

	iPinList.ResetAndDestroy();

	iIdKeyList.ResetAndDestroy();

	iIdKeyHashList.ResetAndDestroy();

	GenerateUniquePinsL(iPinList, iIdKeyList, iIdKeyHashList);

	TInt indexValue = iPinPluginDb->IdIndex(iIdentityId);

	TPinPluginTrainingMessage trainMessage;

	if (indexValue >= 0)

		{

		trainMessage = EReTraining;

		}

	else

		{

		trainMessage = ETraining;

		}

	iPinPluginDialog->PinTraining(trainMessage, iPinList, iPinMinSize, iPinMaxSize, iIndex, iNewPinSize, *iDialogResult, iStatus);

	iState = ETrainResult;

	SetActive();	

	}

void CPinPluginAO::AddTrainResultToDBL()

	{

	__ASSERT_ALWAYS(iIndex >= KIndexLow && iIndex <= KIndexHigh,

		User::Panic(KPinPluginPanicString(), EPinPanicIncorrectIndex));

	TInt indexValue = iPinPluginDb->IdIndex(iIdentityId);

	if (indexValue >= 0)

		{

		iPinPluginDb->UpdatePinL(iIdentityId, *iIdKeyHashList[iIndex]);

		iMessage = EPinPluginReTrainingSuccess;

		}

	else

		{

		iPinPluginDb->AddPinL(iIdentityId, *iIdKeyHashList[iIndex]);

		iMessage = EPinPluginTrainingSuccess;

		}

	TPtrC8 idKeyPtr = *iIdKeyList[iIndex];

	HBufC8* identityKey = idKeyPtr.AllocL();

	*iResult = identityKey;

	iNewPinSize = iPinSize;

	iState = EInfo;

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	SetActive();

	}

HBufC8* CPinPluginAO::GenerateKeyHashL(TPinValue& aPinValue, HBufC8*& aIdentityKey)

	{

	CSHA1* sha1 = CSHA1::NewL();

	CleanupStack::PushL(sha1);

	HBufC8* pinValue = aPinValue.AllocLC();

	TPtrC8 hash = sha1->Hash(*pinValue);

	CleanupStack::PopAndDestroy(pinValue);

	aIdentityKey = hash.AllocLC();

	TPtrC8 hash1 = sha1->Hash(hash);

	HBufC8* idkeyHash = hash1.AllocL();

	CleanupStack::Pop(aIdentityKey);

	CleanupStack::PopAndDestroy(sha1);

	return idkeyHash;

	}

void CPinPluginAO::GenerateUniquePinsL(RPointerArray<TPinValue>& aPinList,

		RPointerArray<HBufC8>& aIdKeyList, RPointerArray<HBufC8>& aIdKeyHashList)

	{

	TInt count = 4; 

	while (count)

		{

		TPinValue* randomPin = new (ELeave) TPinValue;

		CleanupStack::PushL(randomPin);

		for (TInt k = 0; k < iNewPinSize ; k++)

			{

			TUint8 num = Math::Random();

			num = num % 10;

			randomPin->AppendNum(num);

			}

		HBufC8* identityKey = NULL;

		HBufC8* identityKeyHash = GenerateKeyHashL(*randomPin, identityKey);

		CleanupStack::PushL(identityKeyHash);

		CleanupStack::PushL(identityKey);

		if (iPinPluginDb->IsUniquePin(*identityKeyHash))

			{

			aIdKeyList.AppendL(identityKey);

			CleanupStack::Pop(identityKey);

			aIdKeyHashList.AppendL(identityKeyHash);

			CleanupStack::Pop(identityKeyHash);

			aPinList.AppendL(randomPin);

			CleanupStack::Pop(randomPin);

			count--;

			}

		}

	}