/*
* 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: 
* CPinPlugin implementation
*
*/


/**
 @file 
*/


#include "pinplugin.h"
#include <bautils.h>
#include <barsread.h>
#include <e32math.h>
#include <pinpluginconfig.rsg>
#include <ecom/ecom.h>
#include <ecom/implementationproxy.h>
#include <f32file.h>

using namespace AuthServer;

_LIT(KPinPluginResourceFile, "z:\\Resource\\pinplugin\\pinpluginconfig.rsc");

const TPluginId KPinPluginImplementationUid = 0x200032E5;

CPinPlugin* CPinPlugin::NewL()
 	{
 	CPinPlugin* self = CPinPlugin::NewLC();
 	CleanupStack::Pop();
 	return self;
	}
	
CPinPlugin* CPinPlugin::NewLC()
	{
	CPinPlugin* self = new(ELeave) CPinPlugin();
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}
	
CPinPlugin::~CPinPlugin()
	{
	delete iPinPluginAO;
	delete iPinName;
	delete iPinDescription;
	}

CPinPlugin::CPinPlugin()
	{	
	iActive = ETrue;
	}
		
void CPinPlugin::ConstructL()
	{
	TInt retryCount, pinSize, pinMinSize, pinMaxSize;
	TReal val;
	
	// Verifies the UID/SID of the Authentication server
	// to make sure pinplugin is loaded from Authentication server.  
	RProcess process;
        
	ReadResourceL(retryCount, pinSize, pinMinSize, pinMaxSize);

	__ASSERT_ALWAYS(retryCount >= 0 && pinSize >= 0 && pinMinSize >= 0 &&
	 		pinMaxSize >= 0 && pinSize >= pinMinSize && pinSize <= pinMaxSize,
	 		User::Panic(KPinPluginPanicString(), EPinPanicInvalidConfigValues));

	iName.Set(iPinName->Des());
	iDescription.Set(iPinDescription->Des());
	Math::Pow10(val, pinMinSize);
	// since pinMinSize is always a Int value, val never have a floating point
	// in future if entropy is changed to have real value also, it will work
	// now in our case, compiler do the default truncation.
	iMinEntropy = val;
	iFalsePositiveRate = 0;
	iFalseNegativeRate = 0;
	iType = AuthServer::EAuthKnowledge;
	 
	//Create a new implementation object
	iPinPluginAO = CPinPluginAO::NewL(pinSize, pinMinSize, pinMaxSize, retryCount);
	
	SetPluginStateL();
	
	}
	
	
//Implement CAuthPluginInterface definitions

void CPinPlugin::Identify(TIdentityId& aId,const TDesC& aClientMessage,
						  HBufC8*& aResult, TRequestStatus& aRequest)
	{
	iPinPluginAO->Identify(aId, aClientMessage, aResult, aRequest);
	}
	
void CPinPlugin::Cancel()
	{
	iPinPluginAO->Cancel();		
	}

void CPinPlugin::Train(TIdentityId aId, HBufC8*& aResult, TRequestStatus& aRequest)
	{
	iPinPluginAO->Train(aId, aResult, aRequest);
	}

TInt CPinPlugin::Forget(TIdentityId aId)
	{
	return iPinPluginAO->Forget(aId);
	}

TBool CPinPlugin::IsActive() const
	{
	return iActive;
	}
	
TInt CPinPlugin::DefaultData(TIdentityId aId, HBufC8*& aOutputBuf)
	{
	return iPinPluginAO->DefaultData(aId, aOutputBuf);
	}

TInt CPinPlugin::Reset(TIdentityId aIdentityId, const TDesC& aRegistrationData, HBufC8*& aResult)
	{
	TRAPD(err, iPinPluginAO->ResetL(aIdentityId, aRegistrationData, aResult));
	return err;
	}

TPluginId CPinPlugin::Id() const
	{
	return KPinPluginImplementationUid;
	}

void CPinPlugin::ReadResourceL(TInt& aRetryCount, TInt& aPinSize, TInt& aPinMinSize,
							TInt& aPinMaxSize)
	{
	RFs fs;
	TFileName fileName(KPinPluginResourceFile);
	User::LeaveIfError(fs.Connect());
	CleanupClosePushL(fs);
	BaflUtils::NearestLanguageFile(fs,fileName);
	RResourceFile resourceFile;
	resourceFile.OpenL(fs,fileName);
	CleanupClosePushL(resourceFile);
	resourceFile.ConfirmSignatureL(0);
	resourceFile.Offset();
	
	aRetryCount = ResourceValueL(resourceFile, R_IDENTIFY_DIALOG_RETRY_COUNT);
	aPinSize = ResourceValueL(resourceFile, R_PIN_SIZE);
	aPinMinSize = ResourceValueL(resourceFile, R_PIN_MIN_SIZE);
	aPinMaxSize = ResourceValueL(resourceFile, R_PIN_MAX_SIZE);

	HBufC8* res = resourceFile.AllocReadLC(R_PLUGIN_INFO);
	TResourceReader reader;
	reader.SetBuffer(res);
	iPinName = reader.ReadTPtrC().AllocL();
	iPinDescription = reader.ReadTPtrC().AllocL();
	CleanupStack::PopAndDestroy(3, &fs);
	}

TInt CPinPlugin::ResourceValueL(RResourceFile& aResFile, const TInt aResourceID)
	{
	TResourceReader reader;
	HBufC8* res = aResFile.AllocReadLC(aResourceID);
	reader.SetBuffer(res);
	TInt val = reader.ReadInt8();
	CleanupStack::PopAndDestroy(res);
	return val;
	}
	
void CPinPlugin::SetPluginStateL()
	{
	// identifies the pinplugins state by looking for a file 
	// in system drive.
	_LIT(KPinPlugin,"pinplugin_inactive.txt");
	TFileName filename;
	filename.Copy(KPinPlugin); // convert from 8 -> 16 bit descriptor
			
	TDriveUnit sysDrive = RFs::GetSystemDrive();
	TDriveName sysDriveName (sysDrive.Name());
	filename.Insert(0,sysDriveName);
	filename.Insert(2,_L("\\"));
		
	RFs fs;
	User::LeaveIfError(fs.Connect());
	TEntry entry;
	TInt err = fs.Entry(filename, entry);
	if(err == KErrNone)
		{
		iActive = EFalse;
		}
	else if( err == KErrNotFound )
		{
		iActive = ETrue;
		}
	else
		{
		User::LeaveIfError(err);
		}
	}

// Map the interface UIDs to implementation factory functions
const TImplementationProxy ImplementationTable[] = 
	{
	IMPLEMENTATION_PROXY_ENTRY(KPinPluginImplementationUid,	CPinPlugin::NewL)
	};

// Exported proxy function to resolve intstantiation methods for an ECOM plugin dll
EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
	{
	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);
	return ImplementationTable;
	}


const TPtrC& CPinPlugin::Name() const
  {
  return iName;
  }
const TPtrC& CPinPlugin::Description() const
  {
  return iDescription;
  }
TAuthPluginType CPinPlugin::Type() const 
  {
  return iType;
  }

TEntropy CPinPlugin::MinEntropy() const
  {
  return iMinEntropy;
  }

TPercentage CPinPlugin::FalsePositiveRate() const
  {
  return iFalsePositiveRate;
  }

TPercentage CPinPlugin::FalseNegativeRate() const
  {
  return iFalseNegativeRate;
  }