/*

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

* CAuthServer class definition

*

*/

/**

 @file 

 @released

 @internalComponent

*/

#ifndef AUTHSERVER_H

#define AUTHSERVER_H

#include <e32cmn.h>

#include <ct/rcpointerarray.h>

#include <e32property.h>

#include <f32file.h>

#include <scs/scsserver.h>

#include "authserveripc.h"

#include "authrepository.h"

namespace AuthServer 

{

/**

 *Panic values associated with the AuthServer

 */

enum TAuthServerPanic

	{

	EPanicCorruptDescriptor = 0,

	/// An invalid service request number has been receieved by the

	/// server. This should not be received by those using the RAuthClient or

	/// derived classes.

	EPanicInvalidFunction = 1,

	EPanicAlreadyReceiving = 2,

	/// An internal error indicating the received authentication expression 

	/// is malformed. This should not be received by those using the 

	/// RAuthClient or derived classes.

	EPanicBadExternalizedAuthExpr = 3,

	/// A request has been made that refers to a non-existent plugin.

	EPanicNoSuchAuthPlugin = 4,

	/// In order to create a first identity, the authserver requires that 

	/// at least one plugin supports default data. 

	EPanicNoFirstStartPlugin = 5,

	/// A call has been made to the authserver's training manager while one 

	/// is already in progress.

	EPanicTrainingMgrBusy = 6,

	/// A plugin has reported that it supports default data but has returned

	/// an invalid data buffer.

	EPanicInvalidDefaultData = 7        

	};

const TInt KPolicyRanges= 12;

const TInt KPolicyElements = 7;

const TInt KDefaultShutdownDelay = 3 * 1000 * 1000;	// 3 seconds

class CIdentity;

class CPluginMgr;

class CPluginObserver;

class CTrainingMgr;

class CEvaluator;

class CAuthExpression;

class CAuthTransaction;

struct TLastAuth;

// The description for the default identity.

_LIT(KDefaultUserDescription, "DefaultUser");

/**

 * Helper class to manage details during identity reset operation

 **/

class TPluginResetDetails

	{

public:

	TPluginResetDetails(TPluginId aPluginId, const TDesC& aRegistrationData):

		iPluginId(aPluginId),

		iRegistrationData(aRegistrationData)

		{}

public:

	TPluginId PluginId() const { return iPluginId;};

	const TDesC& RegistrationData() const { return iRegistrationData;};

private:

	TPluginId iPluginId;

	const TDesC& iRegistrationData;

	};

/**

 * Provides authentication and identity management services.

 *

 * A CPolicyServer derived class providing management of identity

 * authentication services. Responsible for managing identities in accordance

 * with the requests made by clients.

 * 

 **/

class CAuthServer : public CScsServer, public MEvaluatorPluginInterface,

    public MEvaluatorClientInterface

	{

public:

	// implement CScsServer.

	virtual CScsSession* DoNewSessionL(const RMessage2& aMessage);

	// implement CScsServer.

	virtual void DoPreHeapMarkOrCheckL();

	// implement CScsServer.

	virtual void DoPostHeapMarkOrCheckL();

	static CAuthServer* NewLC(CActive::TPriority = CActive::EPriorityStandard);

	void AuthenticateL(const RMessage2& aMessage);

	void DeauthenticateL(const RMessage2& aMessage);

	void CancelL(const RMessage2& aMessage);

	void PluginsL(const RMessage2& aMessage);

	void ActivePluginsL(const RMessage2& aMessage);

	void PluginsByTypeL(const RMessage2& aMessage);

	void PluginsByTrainingL(const RMessage2& aMessage);

	void IdentitiesL(const RMessage2& aMessage);

	void SetIdentityStringL(const RMessage2& aMessage);

	void IdentityStringL(const RMessage2& aMessage);

	void RegisterIdentityL(const RMessage2& aMessage);

	void RemoveIdentityL(const RMessage2& aMessage);

	void TrainPluginL(const RMessage2& aMessage);

	void ForgetPluginL(const RMessage2& aMessage);

	void PreferredTypePluginL(const RMessage2& aMessage);

	void SetPreferredTypePluginL(const RMessage2& aMessage);

	void IdentitiesWithStringL(const RMessage2& aMessage);

	void ListAuthAliasesL(const RMessage2& aMessage);

	void ResolveExpressionL(const RMessage2& aMessage);

	void ResetIdentityL(TInt aFunction, const RMessage2& aMessage);

	void ResetIdentityByListL(const RMessage2& aMessage);

	virtual void Evaluate(TPluginId aPluginId,

						  TIdentityId& aIdentityId,

						  CAuthExpressionImpl::TType aType,

						  TRequestStatus& aStatus);

	virtual void Evaluate(TAuthPluginType aPluginType,

						  TIdentityId& aIdentityId,

						  CAuthExpressionImpl::TType aType,

						  TRequestStatus& aStatus);

	virtual void CancelEvaluate(); 

	virtual void EvaluationSucceeded(TIdentityId aIdentityId);

	virtual void EvaluationFailed(TInt aReason);

private:

	CAuthServer(CActive::TPriority aPriority);

	/// 2nd phase construction

	void ConstructL();

	~CAuthServer();

    CIdentity* CachedIdentity(const TTimeIntervalSeconds& timeout);						   

	TBool FilterActivePlugins(const CAuthPluginInterface& aInterface);

	void FirstStartL();

	void CreatePropertiesL();

	void ClearPropertiesL();

	TBool ServerBusy();

	void EvaluationSucceededL(TIdentityId aIdentityId) ;

	void CompleteAuthenticationL(const RMessagePtr2& aMessage, CIdentity* aId);

	typedef TBool (CAuthServer::* TInterfaceFilter)(const CAuthPluginInterface&);

	void FilterPluginsL(

		const RMessage2& aMessage, TInterfaceFilter aFilter);

	void GetDescriptionsFromEComLC(

		TInterfaceFilter aFilter, RCPointerArray<const CPluginDesc>& aDescs);

	TBool FilterAllPlugins(const CAuthPluginInterface&);

	TBool FilterPluginsByType(const CAuthPluginInterface&);

	TBool FilterPluginsByTraining(const CAuthPluginInterface& aInterface);

	void UpdateAuthL(TLastAuth& aAuth, TPluginId aPlugin);

	HBufC* StringOrNullLC(TBool aReturnString, TIdentityId id);

	void EvaluateL(TPluginId aPluginId,

				   TIdentityId& aIdentityId,

				   CAuthExpressionImpl::TType aType,

				   TRequestStatus& aStatus);

	void ProcessAliasStringL(RPointerArray<HBufC>& aAuthAliasList, const TDesC& aAliasStringToProcess , RBuf& aResultantAliasString);

	TBool CheckForAliasInAliasString(RPointerArray<HBufC>& aAuthAliasList, const TDes& aAliasString);

	CTransientKeyInfo* CreateKeyInfoLC(TPluginId aPluginId, const TDesC8& aPluginData, const CProtectionKey& aProtKey);

	TCustomResult CustomSecurityCheckL(const RMessage2& aMsg, 

		TInt& aAction, TSecurityInfo& aMissing);

	void TokenizeStringL( const TDesC& aStringToBeProcessed, RBuf& aResultantString );

	void ResolveAliasL(	const TDesC& aAliasName, 

						RPointerArray<HBufC>& aAliasList, 

						RBuf& aResultantString);

	void FreeMemoryBeforeHeapMark();

	void SetupVariablesAfterHeapMarkEndL();

private:

	RFs iFs;

	/// The persistent authentication database

	CAuthDb2*  iAuthDb2;

	//plugin manager

	CPluginMgr* iPluginMgr;

	// The training manager 

	CTrainingMgr* iTrainingMgr;

	/// the auth expression evaluator

	CEvaluator* iEvaluator;

	/// the last authenticated identity

	CIdentity* iLastIdentity;

	/// the last authentication time

	TTime iLastAuthTime;

	/// holds the information about the authentication taking place

	CAuthTransaction* iAuthTransaction;

	/// used to publish information about the last authentication 

	RProperty iAuthProperty;

	/// used to notify subscribers of changes to the authenticated identity

	RProperty iAuthEventProperty;

	/// The authentication repository

	CAuthRepository* iAuthRepository;

	/// The key size to be used for protection keys

	TInt iKeySize;

	/// The parameters from the IPC Call

	CAuthParams* iParams;

	TAuthTrainingStatus iFilterTraining;

	TAuthPluginType iFilterType;

	CPluginObserver* iPluginObserver;

	// Server Policies

	static const TUint iRangeCount;

	static const TInt iRanges[KPolicyRanges];

	static const TUint8 iElementsIndex[KPolicyRanges];

	static const CPolicyServer::TPolicyElement iPolicyElements[KPolicyElements];

	static const CPolicyServer::TPolicy iPolicy;

	static const TStaticSecurityPolicy iPropertyWritePolicy;

	static const TStaticSecurityPolicy iPropertyReadPolicy;

	};

} //namespace

#endif // AUTHSERVER_H