/*

* Copyright (c) 2005-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: 

* CTrainingMgr - Auth Server helper class

*

*/

/**

 @file 

*/

#include <e32debug.h>

#include <s32mem.h>

#include "authserver_impl.h"

#include "log.h"

#include "authrepository.h"

using namespace AuthServer;

CTrainingMgr::CTrainingMgr(CPluginMgr&      aPluginMgr,

						   CAuthDb2&        aAuthDb,

						   CAuthRepository& aAuthRepository) :

	CActive(EPriorityStandard),

	iPluginMgr(&aPluginMgr),

	iAuthDb(&aAuthDb),

	iAuthRepository(aAuthRepository)

	{

	CActiveScheduler::Add(this);

	}

CTrainingMgr::~CTrainingMgr()

    {

    Cancel();

    Cleanup();

    }

/**

 * @param aMessage

 * @param aId The id number to use for the identity

 * @param aProtKey the protection key will be returned here

 */

void CTrainingMgr::RegisterIdentityL(const RMessage2& aMessage,

									TIdentityId aId,

									CProtectionKey&  aProtKey)

	{

	__ASSERT_ALWAYS(!IsActive(),

					User::Panic(KAuthServerShortName,

								EPanicTrainingMgrBusy));	

	iProtKey = &aProtKey;

	iMessage = new (ELeave) RMessage2(aMessage);

	iCurrentPluginIdx = 0;

	iIdentity = aId;

	iDescription = HBufC::NewL(aMessage.GetDesLength(1));

	TPtr ptr = iDescription->Des();

	aMessage.Read(1,ptr); 

	iState = ERegistrationFirstStep;

	DoRegistrationStepL();

	}

TBool CTrainingMgr::RegisterFirstIdentityL(TIdentityId aId,

										  CProtectionKey& aProtKey)

	{

	__ASSERT_ALWAYS(!IsActive(),

					User::Panic(KAuthServerShortName,

								EPanicTrainingMgrBusy));	

	iIdentity = aId;

	iProtKey  = &aProtKey;

    iDescription = HBufC::NewL(KDefaultUserDescription().Length());

    *iDescription = KDefaultUserDescription;

    TBool result = EFalse;

    //Get the default plugin id from the configuration file.

    TPluginId defaultPluginId = iAuthRepository.DefaultPluginL();

    CAuthPluginInterface* plugin = 0;

	TRAPD(err, plugin = iPluginMgr->PluginL(defaultPluginId));

	if ((err == KErrNone) &&

		(plugin->IsActive()) &&

		(plugin->Type() == EAuthKnowledge) && 

	    (plugin->DefaultData(aId, iResult) == KErrNone))

		{

		iCurrentPlugin = plugin->Id(); 

		AddIdentityL(); 

		AddTrainingResultL();

		result = ETrue;

		}	

	Cleanup();		    	

	return result;

	}

void CTrainingMgr::TrainPluginL(const RMessage2& aMessage,

							   CProtectionKey&  aProtKey)

	{

	__ASSERT_ALWAYS(!IsActive(),

					User::Panic(KAuthServerShortName,

								EPanicTrainingMgrBusy));	

	iProtKey = &aProtKey;

 	iIdentity = aMessage.Int0();

	iCurrentPlugin = aMessage.Int1();

	iMessage = new (ELeave) RMessage2(aMessage);

	CAuthPluginInterface* plugin = 0;

	TRAPD(err, plugin = iPluginMgr->PluginL(iCurrentPlugin));

	if (err != KErrNone)

		{

		iMessage->Complete(err);

		Cleanup();

		return;

		}

	else

		{

		SetActive();

		iState=ETrainingDone;

		if (plugin->IsActive())

			{

			plugin->Train(iIdentity, iResult, iStatus);

			}

		else

			{

			TRequestStatus* status = &iStatus;

			User::RequestComplete(status, KErrAuthServPluginNotActive);

			}

		}

	}

TInt CTrainingMgr::RunError(TInt aError)

    {

    iMessage->Complete(aError);

	return KErrNone;

  }

void CTrainingMgr::RunL()

	{

	if (iStatus != KErrNone && 

		(iStatus != KErrAuthServPluginCancelled && 

		iStatus != KErrAuthServPluginNotActive))

		{	

		// error results other than plugin cancelled or inactive handled  here

		Complete();

		return;

		}

	switch (iState)

		{

    	case ERegistrationFirstStep:

			if (AddIdentityL())

				{

				iState = ERegistering;

				}

			DoRegistrationStepL();

			break;

       case ERegistering:

			AddTrainingResultL();

    		DoRegistrationStepL();

    		break;

       case ETrainingDone:

            if (iStatus == KErrAuthServPluginCancelled)

			  {

    		  DEBUG_PRINTF(_L8("Plugin cancelled in training"));

			  }

    	    AddTrainingResultL();

    		Complete();

    		break;

    	case ERegistrationDone:

			WriteResultToMsgL();

    		Complete();

    		break;

    	}

	}

void CTrainingMgr::DoCancel()

	{

	CAuthPluginInterface* plugin = 0;

	TRAPD(err, plugin = iPluginMgr->PluginL(iCurrentPlugin));

	if (err == KErrNone)

		{

		iMessage->Complete(KErrCancel);

		plugin->Cancel();

		}

	else

		{

		User::Panic(KAuthServerShortName, EPanicNoSuchAuthPlugin);

		}

	Cleanup();

	}

TBool CTrainingMgr::IsBusy() const

  {

  return iState != EIdle;

  }

CTransientKeyInfo* CTrainingMgr::CreateKeyInfoLC()

	{

    __ASSERT_ALWAYS(iResult != 0 && iResult->Size() > 0,

					User::Panic(KAuthServerShortName,

								EPanicInvalidDefaultData));	

	CTransientKeyInfo* keyInfo = CTransientKeyInfo::NewLC(iCurrentPlugin);

	CTransientKey* key = keyInfo->CreateTransientKeyL(*iResult);

	CleanupStack::PushL(key);

	CEncryptedProtectionKey* encKey = key->EncryptL(*iProtKey);

	CleanupStack::PushL(encKey);

	keyInfo->SetEncryptedProtectionKeyL(encKey);

	CleanupStack::Pop(encKey);

	CleanupStack::PopAndDestroy(key);

	return keyInfo;

	}

TBool CTrainingMgr::AddTrainingResultL()

	{

	TBool result = EFalse;

	if (iStatus == KErrNone)

		{	

		CTransientKeyInfo* keyInfo = CreateKeyInfoLC();

		iAuthDb->SetTrainedPluginL(iIdentity, keyInfo->PluginId(),

								   *keyInfo);

		CleanupStack::PopAndDestroy(keyInfo);

		result = ETrue;

		}

	return result;

	}

TBool CTrainingMgr::AddIdentityL()

	{

	TBool result = EFalse;

	if (iStatus == KErrNone)

		{

		CTransientKeyInfo* keyInfo = CreateKeyInfoLC();

		iAuthDb->AddIdentityWithTrainedPluginL(iIdentity, *iDescription, *keyInfo);

		CleanupStack::PopAndDestroy(keyInfo);

		result = ETrue;

		}

	return result;

	}

void CTrainingMgr::DoRegistrationStepL()

	{

	if (iCurrentPluginIdx == iPluginMgr->ImplementationsL().Count())

		{	

		SetActive();

		iState = ERegistrationDone;

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, KErrNone);

		return;

		}

	iCurrentPlugin  =

		iPluginMgr->ImplementationsL()[iCurrentPluginIdx++]

	      ->ImplementationUid().iUid;

	CAuthPluginInterface* plugin = 0;

	TRAPD(err, plugin = iPluginMgr->PluginL(iCurrentPlugin));

	SetActive();

	switch (err)

		{

    	case KErrAuthServNoSuchPlugin:

			{

			// skip this plugin

			TRequestStatus* status = &iStatus;

			User::RequestComplete(status, KErrNone);

			return;

			}

    	case KErrNone:

			break;

    	default:

			User::Leave(err);

			break;

		}

	delete iResult;

	iResult = 0;

	if (plugin->IsActive())

		{

		plugin->Train(iIdentity, iResult, iStatus);

		}

	else

		{

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, KErrAuthServPluginNotActive);

		}

	}

void CTrainingMgr::WriteResultToMsgL()

    {

	if (iAuthDb->NumTrainedPluginsL(iIdentity) > 0)

		{

		CIdentity* identity = CIdentity::NewLC(iIdentity, iProtKey,

											   iDescription);

		iProtKey = 0;

		iDescription = 0;

		HBufC8* idBuff = HBufC8::NewLC(KDefaultBufferSize);

		TPtr8  idPtr =  idBuff->Des();

		RDesWriteStream writeStream(idPtr);

		CleanupClosePushL(writeStream);

		writeStream << *identity;

		writeStream.CommitL();

		TInt clientBuffSize = iMessage->GetDesMaxLength(0);

		if (clientBuffSize >= idBuff->Size())

			{

				iMessage->Write(0, *idBuff);

			}

		else

			{

				User::Leave(KErrUnderflow);

			}

		CleanupStack::PopAndDestroy(3,identity);

		}

	else

		{

		iStatus = KErrAuthServRegistrationFailed;

		}

    }

void CTrainingMgr::Complete()

	{

	iMessage->Complete(iStatus.Int());

	Cleanup();

	}

void CTrainingMgr::Cleanup()

	{

	if(iDescription)

		{

		delete iDescription;

		iDescription = 0;

		}

	if(iResult)

		{

		delete iResult;

		iResult = 0;

		}

	if(iMessage)

		{

		delete iMessage;

		iMessage = 0;

		}

	if(iProtKey)

		{

		delete iProtKey;

		iProtKey = 0;

		}

	iState = EIdle;

	}