1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 * CAuthServer implementation

    16 *

    17 */

    18 

    19 

    20 /**

    21  @file 

    22 */

    23 

    24 #include <s32mem.h>

    25 #include <s32file.h>

    26 #include <ecom/ecom.h>

    27 #include <pbedata.h>

    28 #include <scs/cleanuputils.h>

    29 #include "authserver_impl.h"

    30 #include "authtransaction.h"

    31 #include "authserver/aspubsubdefs.h"

    32 #include "authserverutil.h"

    33 

    34 using namespace AuthServer;

    35 

    36 const TUint CAuthServer::iRangeCount = KPolicyRanges;

    37 

    38 const TInt CAuthServer::iRanges[KPolicyRanges] = 

    39 	{

    40 	0,

    41 	CScsServer::EBaseSession,

    42 	CScsServer::EBaseSession |ERequireNoCapabilities, 		   // accessible by all clients.

    43 	CScsServer::EBaseSession |ERequireReadUserData,		   	   // accessible by ReadUserData clients only.

    44 	CScsServer::EBaseSession |ERequireWriteUserData,	   	   // accessible by WriteUserData clients only.

    45 	CScsServer::EBaseSession |ERequireReadDeviceData, 	       // accessible by ReadDeviceData clients only.

    46 	CScsServer::EBaseSession |ERequireWriteDeviceData,         // accessible by WriteDeviceData clients only.

    47 	CScsServer::EBaseSession |ERequireTrustedUi,               // accessible by TrustedUi clients only.

    48 	CScsServer::EBaseSession |ERequireReadDeviceAndUserData,   // accessible by clients with both

    49 																// ReadUserData and ReadDeviceData.

    50 	CScsServer::EBaseSession |ERequireCustomCheck,		       // Require custom check.

    51 	CScsServer::EBaseSession |ELastService,

    52 	CScsServer::EBaseMustAllow     			                   // SCS Internal.

    53 	};

    54 

    55 const TUint8 CAuthServer::iElementsIndex[iRangeCount] = 

    56 	{

    57 	CPolicyServer::ENotSupported,

    58 	CPolicyServer::EAlwaysPass,

    59 	0,  // all clients can have access 

    60 	1,  // ReadUserData clients only

    61 	2,  // WriteUserData clients only

    62 	3,	// ReadDeviceData

    63 	4,  // WriteDeviceData

    64 	5,  // trusted ui

    65 	6,  // ReadUserData and ReadDeviceData

    66 	CPolicyServer::ECustomCheck,	// custom check

    67 	CPolicyServer::EAlwaysPass, 

    68 	CPolicyServer::EAlwaysPass, 

    69 	};

    70 

    71 const CPolicyServer::TPolicyElement CAuthServer::iPolicyElements[] = 

    72 	{

    73 	{_INIT_SECURITY_POLICY_C1(ECapability_None), CPolicyServer::EFailClient},

    74 	{_INIT_SECURITY_POLICY_C1(ECapabilityReadUserData), CPolicyServer::EFailClient},

    75 	{_INIT_SECURITY_POLICY_C1(ECapabilityWriteUserData), CPolicyServer::EFailClient},

    76 	{_INIT_SECURITY_POLICY_C1(ECapabilityReadDeviceData), CPolicyServer::EFailClient}, 

    77 	{_INIT_SECURITY_POLICY_C1(ECapabilityWriteDeviceData), CPolicyServer::EFailClient},

    78 	{_INIT_SECURITY_POLICY_C1(ECapabilityTrustedUI), CPolicyServer::EFailClient},

    79 	{_INIT_SECURITY_POLICY_C2(ECapabilityReadDeviceData, ECapabilityReadUserData), CPolicyServer::EFailClient},

    80 	};

    81 

    82 const CPolicyServer::TPolicy CAuthServer::iPolicy =

    83 	{

    84 		CPolicyServer::EAlwaysPass, // so that any client can connect	

    85 		iRangeCount,                                   

    86 		iRanges,

    87 		iElementsIndex,

    88 		iPolicyElements,

    89 	};

    90 

    91 _LIT_SECURITY_POLICY_S0(CAuthServer::iPropertyWritePolicy, KAuthServerSecureId.iUid);

    92 _LIT_SECURITY_POLICY_PASS(CAuthServer::iPropertyReadPolicy);

    93 

    94 

    95 inline CAuthServer::CAuthServer(CActive::TPriority aPriority)

    96 	:CScsServer(TVersion(1,0,0), iPolicy, aPriority)

    97 	{}

    98 	

    99 CAuthServer* CAuthServer::NewLC(CActive::TPriority aPriority)

   100 	{

   101 	CAuthServer* self = new(ELeave) CAuthServer(aPriority);

   102 	CleanupStack::PushL(self);

   103 	self->ConstructL();

   104 	return self;

   105 	}

   106 

   107 void CAuthServer::ConstructL()

   108     {

   109     // Delay starting of shutdown timer till we finish construction since

   110     // loading of ECOM plugins takes a while

   111     CScsServer::ConstructL(0);

   112     TInt r;

   113     StartL(KAuthServerName);

   114 	r = iFs.Connect();

   115     User::LeaveIfError(r);

   116     r = iFs.CreatePrivatePath(RFs::GetSystemDrive());

   117     User::LeaveIfError(r);

   118 

   119     // Retrieve the key size to be used for protection keys

   120 	CPBEncryptElement* pbee = CPBEncryptElement::NewLC(_L(""));

   121     iKeySize = pbee->EncryptionData().AuthData().Key().Size();

   122     CleanupStack::PopAndDestroy(pbee);

   123     iAuthRepository = CAuthRepository::NewL();

   124 	iAuthDb2 = CAuthDb2::NewL(iFs);

   125 	iPluginMgr  = CPluginMgr::NewL();

   126     iPluginObserver = CPluginObserver::NewL(*iPluginMgr);

   127     iEvaluator = CEvaluator::NewL(this,this);

   128     iTrainingMgr = new (ELeave) CTrainingMgr(*iPluginMgr, *iAuthDb2, *iAuthRepository);

   129 	TUid clientSid = {0};

   130 	iParams = CAuthParams::NewL(0,

   131 								EFalse,

   132 								clientSid,

   133 								EFalse,

   134 								KNullDesC());

   135     CreatePropertiesL();

   136 	FirstStartL();

   137 

   138 	// Construction complete, now start the shutdown timer

   139 	CScsServer::EnableShutdownTimerL(AuthServer::KDefaultShutdownDelay);

   140     }

   141     

   142     

   143 CPolicyServer::TCustomResult CAuthServer::CustomSecurityCheckL(const RMessage2& aMessage, 

   144 	TInt& /*aAction*/, TSecurityInfo& aMissing)

   145 	{

   146 	TInt KAuthParams = 1; 

   147 	TInt paramsLen = aMessage.GetDesLength(KAuthParams);

   148 	

   149 	if(paramsLen != KErrBadDescriptor)

   150 		{

   151 		//Create a buffer.

   152 		HBufC8* buffer = HBufC8::NewLC(paramsLen);

   153 		TPtr8 bufDes(buffer->Des());

   154 		aMessage.ReadL(EIpcArgument1, bufDes);

   155 			

   156 		//Internalize the params object.

   157 		RDesReadStream readStream(*buffer);

   158 		CleanupClosePushL(readStream);

   159 		iParams->InternalizeL(readStream);

   160 		CleanupStack::PopAndDestroy(2, buffer);

   161 		}

   162 

   163 	TBool clientKey = iParams->iClientKey;

   164 	TBool withString = iParams->iWithString;

   165 	TInt clientSid = iParams->iClientSid.iUid;

   166 		

   167 	if((!clientKey || withString || ((clientSid != aMessage.SecureId()) && clientSid != 0 )) && !(aMessage.HasCapability(ECapabilityReadUserData)))

   168 		{

   169 		// Missing ReadUserData capability.

   170 		aMissing.iCaps.Set(ECapabilityReadUserData);

   171 		return CPolicyServer::EFail;

   172 		}	

   173 		

   174 	else

   175 		{

   176 		return CPolicyServer::EPass;	

   177 		}

   178 	}

   179 	

   180 /**

   181  * Creates and initialises the two AuthServer properties -

   182  * KUidAuthServerLastAuth and KUidAuthServerAuthChangeEvent.

   183  *

   184  **/

   185 void CAuthServer::CreatePropertiesL()

   186 	{

   187 	// KUidAuthServerLastAuth

   188 	TInt err1 = iAuthProperty.Define(KUidAuthServerLastAuth, RProperty::EText,

   189 									iPropertyReadPolicy, iPropertyWritePolicy,

   190 									sizeof(TLastAuth));

   191 

   192 	User::LeaveIfError(iAuthProperty.Attach(KAuthServerSecureId,

   193 											KUidAuthServerLastAuth));

   194 

   195 	

   196 	// KUidAuthServerAuthChangeEvent

   197 	TInt err2 = iAuthEventProperty.Define(KUidAuthServerAuthChangeEvent,

   198 									RProperty::EInt,

   199 									iPropertyReadPolicy,

   200 									iPropertyWritePolicy);

   201 	

   202 	User::LeaveIfError(iAuthEventProperty.Attach(KAuthServerSecureId,

   203 												 KUidAuthServerAuthChangeEvent));

   204 

   205 	if (err1 == KErrNone || err2 == KErrNone )

   206 		{

   207 		ClearPropertiesL();

   208 		}

   209 	}

   210 

   211 void CAuthServer::ClearPropertiesL()

   212 	{

   213 	TLastAuth lastAuth;

   214 	TPckg<TLastAuth> authPckg(lastAuth);

   215 	User::LeaveIfError(iAuthProperty.Set(authPckg));

   216 	User::LeaveIfError(iAuthEventProperty.Set(KUnknownIdentity));

   217 	}

   218 

   219 

   220 /**

   221  * Checks the number of identities in the database and iff zero asks the

   222  * training mgr to register the first identity.

   223  *

   224  * @leave KErrAuthServerCanNotCreateFirstId if the first identity cannot

   225  * be created

   226  **/

   227 void CAuthServer::FirstStartL()

   228 	{

   229 	TInt numIds = iAuthDb2->NumIdentitiesL();

   230 	if (numIds == 0)

   231 		{

   232 		TIdentityId id = 0;

   233 		TPckg<TIdentityId> idPkg(id);

   234 		TRandom::RandomL(idPkg);

   235 		

   236 		CProtectionKey* key = CProtectionKey::NewL(iKeySize);

   237 		if (!iTrainingMgr->RegisterFirstIdentityL(id, *key))

   238 			{

   239 			User::Panic(KAuthServerShortName, EPanicNoFirstStartPlugin);

   240 			}

   241 		}

   242 	}

   243 

   244 CAuthServer::~CAuthServer()

   245 	{

   246 	delete iAuthRepository;

   247 	delete iAuthTransaction;

   248 	

   249 	delete iTrainingMgr;

   250 	delete iLastIdentity;

   251 	delete iEvaluator;

   252 	delete iPluginMgr;

   253 	delete iPluginObserver;	

   254 	delete iParams;

   255 	if (iAuthDb2 != 0)

   256 		{

   257 		iAuthDb2->CompactIfRequired();

   258 		delete iAuthDb2;

   259 		}

   260 	

   261 	iFs.Close();

   262 	REComSession::FinalClose();

   263 	}

   264 

   265 		

   266 /**

   267  *  Creates a new session

   268  * @param aClientVersion the version of the connecting client

   269  * @param aMessage the connect message

   270  */

   271 CScsSession* CAuthServer::DoNewSessionL(const RMessage2& /*aMessage*/)

   272 	{

   273 	return CAuthServerSession::NewL(*this);

   274 	}

   275 

   276 

   277 /**

   278  * Returns the last identity to be authenticated within the period 

   279  * currTime to currTime-timeout.  

   280  * 

   281  * @param currTime the current universal time

   282  * 

   283  * @param timeout the number of seconds within which the last

   284  * authentication should have been made

   285  *

   286  * @return 0 if there has been no previous authentications either in the

   287  * server lifetime or within the timeout period. 

   288  *

   289  * @return a pointer to the cached identity object

   290  **/

   291 CIdentity* CAuthServer::CachedIdentity( const TTimeIntervalSeconds& aTimeOut)

   292     {

   293     // process request

   294     TTime currentTime;

   295 	if(currentTime.UniversalTimeSecure() == KErrNoSecureTime)

   296 		{

   297 		// Fall back to nonsecure time. 

   298 		currentTime.UniversalTime();

   299 		}

   300     

   301     CIdentity* id = 0;

   302   

   303     TTimeIntervalSeconds timeSinceLast;

   304     currentTime.SecondsFrom(iLastAuthTime, timeSinceLast);    

   305    

   306     if (timeSinceLast.Int() >= 0 && timeSinceLast < aTimeOut)

   307 		{

   308 		id = iLastIdentity;

   309 		}

   310     

   311     return id;

   312     }

   313     

   314 

   315 

   316 /**

   317  *

   318  * @param aMessage the message to process

   319  **/

   320 void CAuthServer::DeauthenticateL(const RMessage2& aMessage)

   321 	{

   322 	if (ServerBusy())

   323 		{

   324 		aMessage.Complete(KErrServerBusy);

   325 		return;

   326 		}

   327 

   328 	delete iLastIdentity;

   329 	iLastIdentity = 0;

   330 	iLastAuthTime = 0L;

   331 

   332 	ClearPropertiesL();	

   333 	aMessage.Complete(KErrNone);

   334 	}

   335 

   336 HBufC* CAuthServer::StringOrNullLC(TBool aReturnString, TIdentityId aId)

   337     {

   338 	HBufC* str = 0;

   339 	if (aReturnString)

   340 		{

   341 		TRAPD(err, str = iAuthDb2->DescriptionL(aId));  

   342 		if (!err)

   343 			{

   344 			CleanupStack::PushL(str);

   345 			}

   346 		

   347 		}

   348 	if (str == 0)

   349 		{

   350 		str = HBufC::NewLC(0);  

   351 		}

   352 	return str;

   353     }

   354 

   355 void CAuthServer::AuthenticateL(const RMessage2& aMessage)

   356     {

   357 	if (ServerBusy())

   358 		{

   359 		aMessage.Complete(KErrServerBusy);

   360 		return;

   361 		}

   362 		

   363 	TInt KAuthParams = 1; 

   364 	TInt paramsLen = aMessage.GetDesLength(KAuthParams);

   365 	

   366 	if(paramsLen != KErrBadDescriptor)

   367 		{

   368 		//Create a buffer.

   369 		HBufC8* buffer = HBufC8::NewLC(paramsLen);

   370 		TPtr8 bufDes(buffer->Des());

   371 			

   372 		aMessage.ReadL(EIpcArgument1, bufDes);

   373 		

   374 		//Internalize the params object.

   375 		RDesReadStream readStream(*buffer);

   376 		CleanupClosePushL(readStream);

   377 		iParams->InternalizeL(readStream);

   378 		CleanupStack::PopAndDestroy(2, buffer);	

   379 		}

   380     

   381 	CIdentity* id = CachedIdentity(iParams->iTimeout);

   382   

   383 	if (id == 0) // no valid cache available

   384 		{

   385 		const TInt KAuthExprParam = 0;

   386 	

   387 		// reconstruct the authentication expression

   388 		TInt extLen = aMessage.GetDesLengthL(KAuthExprParam);

   389 		HBufC8* extSrv = HBufC8::NewLC(extLen);

   390 		TPtr8 desSrv8 = extSrv->Des();

   391 		aMessage.ReadL(KAuthExprParam, desSrv8);

   392 		

   393 		RDesReadStream drs(desSrv8);

   394 		CAuthExpression* authExpr = CAuthExpressionImpl::NewL(drs);

   395 		// don't need the stream any more, so free it

   396 		CleanupStack::PopAndDestroy(extSrv);

   397 		CleanupStack::PushL(authExpr);

   398 

   399 		const CAuthExpressionImpl* expr = static_cast<const CAuthExpressionImpl*>(authExpr);

   400 		

   401 		iAuthTransaction = CAuthTransaction::NewL(aMessage,

   402 												  iParams->iClientKey,

   403 												  iParams->iClientSid.iUid,

   404 												  iParams->iWithString,

   405 												  *iParams->iClientMessage,

   406 												  expr);

   407 		CleanupStack::Pop(authExpr);

   408 		

   409 		iEvaluator->Evaluate(expr);

   410 		

   411 		return;

   412         }

   413         

   414 	else if (iParams->iClientKey && (id->Id() != KUnknownIdentity))

   415 		{

   416 		

   417 		HBufC* str = StringOrNullLC(iParams->iWithString, id->Id());

   418 		CIdentity* id2 = 0;

   419 		

   420 		TInt clientId = aMessage.SecureId();

   421 		

   422 		if(iParams->iClientSid.iUid != 0)

   423 			{

   424 			clientId = iParams->iClientSid.iUid;

   425 			}

   426 		

   427 		id2 = CIdentity::NewL(id->Id(), id->Key().ClientKeyL(clientId), str);

   428 			

   429 		CleanupStack::Pop(str);

   430 		CleanupStack::PushL(id2);

   431 		// id pointer already stored as iLastIdentity

   432 		id = id2; 

   433 		}

   434   

   435 	CompleteAuthenticationL(aMessage, id);

   436   

   437 	if (id != iLastIdentity) 

   438 		{

   439 		// only clean up the allocated id if it has not been transferred to us.

   440 		CleanupStack::PopAndDestroy(id);  

   441 		}

   442    

   443 	}

   444 

   445 // -------- plugin lists --------

   446 

   447 

   448 /**

   449 	Build an array containing descriptions for the

   450 	plugins available on the system and send it to

   451 	the client.

   452 	

   453 	@param	aMessage		Message describing client

   454 							request.

   455 	@param	aFilter			Function which decides whether

   456 							or not to include a plugin in the

   457 							list.

   458  */

   459 void CAuthServer::FilterPluginsL(

   460 	const RMessage2& aMessage, CAuthServer::TInterfaceFilter aFilter)

   461 

   462 	{

   463 	RCPointerArray<const CPluginDesc> descs;

   464 	GetDescriptionsFromEComLC(aFilter, descs);

   465 	AuthServerUtil::SendDataPointerArrayL(aMessage, descs, 0);

   466 	CleanupStack::PopAndDestroy(&descs);

   467 	}

   468 

   469 

   470 /**

   471 	Populate the supplied array with plugin descriptions generated

   472 	from the available ECOM plugins.

   473 	

   474 	@param	aFilter			Predicate function decides whether or not

   475 							to include each plugin in the list.

   476 	@param	aDescs			Array to populate.  When this function is

   477 							called, any existing entries are removed.

   478 							If this function leaves then any entries are

   479 							removed from the array.  On success, the

   480 							array is on the cleanup stack.

   481  */

   482 void CAuthServer::GetDescriptionsFromEComLC(

   483 	CAuthServer::TInterfaceFilter aFilter,

   484 	RCPointerArray<const CPluginDesc>& aDescs)

   485 	{

   486 	aDescs.Reset();

   487 	CleanupClosePushL(aDescs);

   488 	

   489 	// ownership of the data pointed by this array is with 

   490 	// the plugin manager. 

   491 	const RPointerArray<CImplementationInformation>& implInfo = iPluginMgr->ImplementationsL();

   492 	TInt implCount = implInfo.Count();

   493 	

   494 	for (TInt i = 0; i < implCount; ++i)

   495 		{

   496 		// avoid RVCT warning C2874W: pi may be used before being set

   497 		CAuthPluginInterface* pi = 0;

   498 		

   499 		TRAPD(r, pi = iPluginMgr->ImplementationL(i));

   500 		

   501 		// skip plugins which are not available

   502 		if (KErrNone != r)

   503 			continue;

   504 		

   505 		if (! (this->*aFilter)(*pi))

   506 			{

   507 			continue;

   508 			}

   509 		

   510 		// get training status from db

   511 		TAuthTrainingStatus ts = iAuthDb2->PluginStatusL(pi->Id());

   512 		

   513 		CPluginDesc* pd = CPluginDesc::NewL(

   514 			pi->Id(), pi->Name(), pi->Type(),

   515 			ts, pi->MinEntropy(),

   516 			pi->FalsePositiveRate(), pi->FalseNegativeRate() );

   517 				

   518 		CleanupStack::PushL(pd);

   519 		aDescs.AppendL(pd);

   520 		CleanupStack::Pop(pd);

   521 		}

   522 	

   523 	}

   524 

   525 

   526 

   527 /**

   528 	Build an array containing plugin descriptions for

   529 	each plugin which is available on the system, and

   530 	copy this into the client's space.

   531 	

   532 	@param	aMessage		Client message.  This contains

   533 							the client-side buffer.

   534  */

   535 void CAuthServer::PluginsL(const RMessage2& aMessage)

   536 	{

   537 	FilterPluginsL(aMessage, &CAuthServer::FilterAllPlugins);

   538 	}

   539 

   540 

   541 /**

   542 	Predicate function used by PluginsL.. This accepts all plugins.

   543 	

   544 	@return					Always ETrue.

   545 	@see PluginsL

   546  */

   547 TBool CAuthServer::FilterAllPlugins(const CAuthPluginInterface&)

   548 	{

   549 	return ETrue;

   550 	}

   551 

   552 

   553 /**

   554  *

   555  * @param aMessage the message to process

   556  **/

   557 void CAuthServer::ActivePluginsL(const RMessage2& aMessage)

   558 	{

   559 	FilterPluginsL(aMessage, &CAuthServer::FilterActivePlugins);

   560 	}

   561 

   562 

   563 /**

   564  * Indicates a plugin is active. 

   565  *

   566  * @param aInterface the auth plugin interface to check

   567  * @return true if aInterface.IsActive()

   568  **/

   569 TBool CAuthServer::FilterActivePlugins(const CAuthPluginInterface& aInterface)

   570 	{

   571 	return aInterface.IsActive();

   572 	}

   573 

   574 

   575 /**

   576 	Build an array which containing plugin descriptions

   577 	for each plugin which is available and has the type

   578 	supplied by the client.

   579 	

   580 	@param	aMessage		Client message.  This contains

   581 							the plugin type and points to the

   582 							client-side buffer.

   583  */

   584 void CAuthServer::PluginsByTypeL(const RMessage2& aMessage)

   585 	{

   586 	iFilterType = static_cast<TAuthPluginType>(aMessage.Int1());

   587 	FilterPluginsL(aMessage, &CAuthServer::FilterPluginsByType);

   588 	}

   589 

   590 

   591 /**

   592 	Predicate which checks whether the supplied description should

   593 	be included in the result list.

   594 	

   595 	The type to filter on is stored as a member variable.

   596 	

   597 	@param	aInterface		Interface to check.

   598 	@return					Zero if interface's type does not match

   599 							filter type, non-zero otherwise.

   600 	@see PluginsByTypeL

   601  */

   602 TBool CAuthServer::FilterPluginsByType(const CAuthPluginInterface& aInterface)

   603 	{

   604 	return (aInterface.Type() == iFilterType);

   605 	}

   606 

   607 

   608 /**

   609 	Build an array which contains plugin descriptions

   610 	for each plugin which has the supplied training status,

   611 	and write that array into the caller's space.

   612 	

   613 	@param	aMessage		Client message contains the status

   614 							to filter on.

   615  */

   616 void CAuthServer::PluginsByTrainingL(const RMessage2& aMessage)

   617 	{

   618 	iFilterTraining = static_cast<TAuthTrainingStatus>(aMessage.Int1());

   619 	FilterPluginsL(aMessage, &CAuthServer::FilterPluginsByTraining);

   620 	}

   621 

   622 

   623 /**

   624 	Predicate checks if the supplied interface describes

   625 	a plugin with the required training status.

   626 	

   627 	@param	aInterface		Interface to check.

   628 	@return					Zero if interface's training status

   629 							does not match the filter status;

   630 							non-zero otherwise.

   631 	@see PluginsByTrainingL

   632  */

   633 TBool

   634 CAuthServer::FilterPluginsByTraining(const CAuthPluginInterface& aInterface)

   635 	{

   636 	// training status is stored in the db, not in the ECOM interface.

   637 	// If this function returns non-zero, the same request will be made

   638 	// on the DB to get the status again to construct the description.

   639 	// This is suboptimal, and could be improved by special-casing the

   640 	// training filter if required.

   641 

   642 	TAuthTrainingStatus ts = EAuthUntrained;

   643 	TRAPD(err, ( ts = iAuthDb2->PluginStatusL(aInterface.Id())));

   644 	return err == KErrNone ? ts == iFilterTraining : EFalse;

   645 	}

   646 

   647 

   648 /**

   649 	Populate a client-side array with the set of identities.

   650 	

   651 	@param	aMessage		Client message which points to the

   652 							user-side array.

   653  */

   654 void CAuthServer::IdentitiesL(const RMessage2& aMessage)

   655 	{

   656     RArray<TIdentityId> ids;

   657     iAuthDb2->IdentitiesL(ids);

   658     CleanupClosePushL(ids);

   659     AuthServerUtil::SendDataArrayL(aMessage, ids, 0);

   660     CleanupStack::PopAndDestroy(&ids);

   661 	}

   662 /**

   663 	Retrieve the preferred plugin for the specified type

   664 	

   665 	@param	aMessage		Client message

   666  */

   667 void CAuthServer::PreferredTypePluginL(const RMessage2& aMessage)

   668 	{

   669     TPluginId id =

   670 	  iAuthDb2->PreferredPluginL(static_cast<TAuthPluginType>(aMessage.Int0()));

   671 	

   672 	TPckg<TPluginId> idPckg(id);

   673 	aMessage.WriteL(1, idPckg);

   674 	aMessage.Complete(KErrNone);

   675 	}

   676 

   677 /**

   678 	Set the preferred plugin for the specified type

   679 	

   680 	@param	aMessage		Client message

   681  */

   682 void CAuthServer::SetPreferredTypePluginL(const RMessage2& aMessage)

   683 	{

   684 	TInt            err        = KErrArgument;

   685 	TAuthPluginType pluginType = static_cast<TAuthPluginType>(aMessage.Int0());

   686 	TPluginId       pluginId   = aMessage.Int1();

   687 	

   688 	if (iPluginMgr->PluginL(pluginId)->Type() == pluginType)

   689 		{

   690 		iAuthDb2->SetPreferredPluginL(pluginType,pluginId);

   691 		err = KErrNone;

   692 		}

   693 	aMessage.Complete(err);

   694 	}

   695 

   696 /**

   697 	Retrieve description for a supplied identity.

   698 	

   699 	@param	aMessage		Client message which contains the

   700 							identity and points to a client-side

   701 							buffer, to which the description will

   702 							be copied.

   703  */

   704 void CAuthServer::IdentityStringL(const RMessage2& aMessage)

   705 	{

   706 	HBufC* desc = iAuthDb2->DescriptionL(aMessage.Int1());

   707 	CleanupStack::PushL(desc);

   708 	aMessage.WriteL(EIpcArgument0, *desc);	

   709 	CleanupStack::PopAndDestroy(desc);

   710 	aMessage.Complete(KErrNone);	

   711 	}

   712 

   713 /**

   714 	Retrieve description & id for all identities.

   715 	

   716 	@param	aMessage		Client message which contains the

   717 							identity and points to a client-side

   718 							buffer, to which the description will

   719 							be copied.

   720  */

   721 void CAuthServer::IdentitiesWithStringL(const RMessage2& aMessage)

   722 	{

   723 	RIdAndStringArray result;

   724 

   725 	iAuthDb2->IdentitiesWithDescriptionL(result);

   726 	CleanupClosePushL(result);

   727 

   728 	AuthServerUtil::SendDataPointerArrayL(aMessage,result,0);

   729 	CleanupStack::PopAndDestroy(&result);

   730 	}

   731 

   732 /**

   733  *

   734  * @param aMessage the message to process

   735  **/

   736 void CAuthServer::SetIdentityStringL(const RMessage2& aMessage)

   737 	{

   738 	HBufC* str = HBufC::NewLC(aMessage.GetDesLengthL(1));

   739 	TPtr strDes = str->Des();

   740 	TInt err = aMessage.Read(1, strDes);

   741 

   742 	if (err == KErrNone)

   743 	  {

   744 	  iAuthDb2->SetDescriptionL(aMessage.Int0(), *str);

   745 	  }	

   746 	CleanupStack::PopAndDestroy(str);

   747 	aMessage.Complete(err);

   748 	}

   749 

   750 

   751  

   752 /**

   753 	Copies the authentication alias list obtained using 

   754 	ListAliasL() method to a client-side buffer .

   755 	

   756 	@param	aMessage		Client message which points to a client-side

   757 							buffer, to which the authentication strength 

   758 							list will be copied.

   759  */

   760  

   761 void CAuthServer::ListAuthAliasesL(const RMessage2& aMessage)

   762 	{

   763 	RPointerArray<HBufC> aliasList;

   764 	CleanupResetAndDestroyPushL(aliasList);

   765 	

   766 	//get the list of available authentication strengths from the cenrep file.

   767 	iAuthRepository->ListAliasL(aliasList);

   768 

   769 	AuthServerUtil::SendDataPointerArrayL(aMessage, aliasList, EIpcArgument0);

   770 	CleanupStack::PopAndDestroy(&aliasList);

   771 	}

   772 	

   773 /**

   774 	Resolves any alias occurrence in the expression to its corresponding

   775 	value. 

   776 	

   777 	@param	aMessage	Client message which contains the free form

   778 						authentication expression and points to a 

   779 						client-side buffer, to which the string will 

   780 						be copied.

   781 	

   782  */

   783 void CAuthServer::ResolveExpressionL(const RMessage2& aMessage)

   784 	{

   785 	

   786 	// the auth strength passed by the client. 

   787 	TInt length = aMessage.GetDesLength(EIpcArgument1);

   788 	HBufC* clientExpression = HBufC::NewLC(length);

   789 	TPtr clientExprPtr(clientExpression->Des());

   790 

   791 	aMessage.ReadL(EIpcArgument1, clientExprPtr);

   792 	

   793 	RBuf resultantString;

   794 	CleanupClosePushL(resultantString);

   795 	

   796 	resultantString.CreateL(KDefaultBufferSize/2);

   797 		

   798 	// get the alias list

   799 	RPointerArray<HBufC> aliasList;

   800 	CleanupResetAndDestroyPushL(aliasList);

   801 	

   802 	//get the list of available authentication strength from the cenrep file.

   803 	iAuthRepository->ListAliasL(aliasList);

   804 		

   805 		

   806 	// parse the client side expression to see whether there

   807 	// are any alias, if present process them accordingly.

   808 	TLex input(clientExprPtr);

   809 	

   810 	// append the open bracket first so that the entire expression is within brackets.

   811 	resultantString.Append(KOpenBracket);

   812 	

   813 	for(TPtrC token = input.NextToken(); token.Size() > 0; token.Set(input.NextToken()))

   814 		{

   815 		

   816 		if(	token.CompareF(KOpenBracket) == 0 ||

   817 			token.CompareF(KCloseBracket) == 0 ||

   818 			token.CompareF(KAuthOpAnd) == 0 ||

   819 			token.CompareF(KAuthOpOr) == 0

   820 			)

   821 			{

   822 			int reqdBufferLength = resultantString.Length() + token.Length();			

   823 			

   824 			if(resultantString.MaxLength() < reqdBufferLength)

   825 				{

   826 				if(resultantString.MaxLength() == 0)

   827 					{

   828 					resultantString.Close();

   829 					}

   830 				resultantString.ReAllocL(reqdBufferLength);

   831 				}

   832 						

   833 			resultantString.Append(token);

   834 			}

   835 		else if(token.CompareF(KAuthBiometric) == 0 ||

   836 				token.CompareF(KAuthDefault) == 0 ||

   837 				token.CompareF(KAuthKnowledge) == 0 ||

   838 				token.CompareF(KAuthToken) == 0 ||

   839 				token.CompareF(KAuthPerformance) == 0	)

   840 			{

   841 			RBuf tokenType;

   842 			CleanupClosePushL(tokenType);

   843 			TokenizeStringL(token, tokenType);

   844 			int reqdBufferLength = resultantString.Length() + tokenType.Length();

   845 			if(resultantString.MaxLength() < reqdBufferLength)

   846 				{

   847 				if(resultantString.MaxLength() == 0)

   848 					{

   849 					resultantString.Close();

   850 					}

   851 				resultantString.ReAllocL(reqdBufferLength);

   852 				}

   853 			

   854 			resultantString.Append(tokenType);

   855 			CleanupStack::PopAndDestroy(&tokenType);

   856 			}

   857 		else

   858 			{

   859 			// should not be a number

   860 			TInt32 val = 0;

   861 			TLex value(token);

   862 			if(value.Val(val) == KErrNone)

   863 				{

   864 				RBuf tokenPluginId;

   865 				CleanupClosePushL(tokenPluginId);

   866 				TokenizeStringL(token, tokenPluginId);

   867 				int reqdBufferLength = resultantString.Length() + tokenPluginId.Length();

   868 				if(resultantString.MaxLength() < reqdBufferLength)

   869 					{

   870 					if(resultantString.MaxLength() == 0)

   871 						{

   872 						resultantString.Close();

   873 						}

   874 					resultantString.ReAllocL(reqdBufferLength);

   875 					}

   876 				resultantString.Append(tokenPluginId);

   877 				CleanupStack::PopAndDestroy(&tokenPluginId);

   878 				continue;

   879 				}

   880 			

   881 			RBuf aliasString;

   882 			CleanupClosePushL(aliasString);

   883 				

   884 			// this is a alias value which should be processed

   885 			ResolveAliasL(token, aliasList, aliasString);

   886 			int reqdBufferLength = resultantString.Length() + aliasString.Length();

   887 			if(resultantString.MaxLength() < reqdBufferLength)

   888 				{

   889 				if(resultantString.MaxLength() == 0)

   890 					{

   891 					resultantString.Close();

   892 					}

   893 				resultantString.ReAllocL(reqdBufferLength);

   894 				}

   895 			resultantString.Append(aliasString);

   896 			CleanupStack::PopAndDestroy(&aliasString);

   897 			}

   898 		}

   899 	

   900 	int reqdBufferLength = resultantString.Length() + KCloseBracket().Length();

   901 	

   902 	if(resultantString.MaxLength() < reqdBufferLength)

   903 		{

   904 		if(resultantString.MaxLength() == 0)

   905 			{

   906 			resultantString.Close();

   907 			}

   908 		resultantString.ReAllocL(reqdBufferLength);

   909 		}

   910 										

   911 	// append the close bracket in the end so that the entire expression is within brackets.

   912 	resultantString.Append(KCloseBracket);

   913 					

   914 	//see if we have enough space on the client.

   915 	length = resultantString.Length();

   916 	if(aMessage.GetDesMaxLengthL(EIpcArgument0) < length)

   917 		{

   918 		TPckg<TInt> lenPckg(length);

   919 		aMessage.WriteL(EIpcArgument0, lenPckg);

   920 		aMessage.Complete(KErrOverflow);

   921 		}

   922 	

   923 	aMessage.WriteL(EIpcArgument0, resultantString);	

   924 	CleanupStack::PopAndDestroy(3, clientExpression);	//aliasList, resultantString.

   925 	aMessage.Complete(KErrNone);

   926 	}

   927 

   928 /**

   929 	Inserts space in between operators and inserts brackets for as 

   930 	expression

   931 	

   932 	@param	aStringToBeProcessed	string to be tokenized.

   933 	@param  aResultantString		would contain the final tokenized

   934 									string

   935  */

   936 

   937 void CAuthServer::TokenizeStringL( const TDesC& aStringToBeProcessed, RBuf& aResultantString )

   938 	{

   939 	TInt newLength = aStringToBeProcessed.Length() + 2;

   940 	HBufC* resultantBuffer = HBufC::NewLC(newLength);

   941 	TPtr resultantBufPtr(resultantBuffer->Des());

   942 	resultantBufPtr.Append(KOpenBracket);

   943 	resultantBufPtr.Append(aStringToBeProcessed);

   944 	TInt index = resultantBufPtr.Length();

   945 	resultantBufPtr.Append(KCloseBracket);

   946 	

   947 	CAuthExpressionImpl::InsertSpaceBetweenOperatorsL(*resultantBuffer, aResultantString);

   948 	CleanupStack::PopAndDestroy(resultantBuffer);

   949 	

   950 	}

   951 

   952 /**

   953 	Retrieves the alias string corresponding to the 

   954 	supplied authentication strength.

   955 	

   956 	@param	aMessage	Client message which contains the

   957 						authentication strength and points to a 

   958 						client-side buffer, to which the alais

   959 						string will be copied.

   960 	

   961  */

   962  	

   963 void CAuthServer::ResolveAliasL(const TDesC& aAliasName, 

   964 								RPointerArray<HBufC>& aAliasList, 

   965 								RBuf& aResultantString)

   966 	{

   967 	HBufC* aliasString = HBufC::NewLC(KDefaultBufferSize/2);

   968 	TPtr aliasStringPtr(aliasString->Des());

   969 	

   970 	TBool aliasFound = EFalse;

   971 		

   972 	// find a match for the client supplied alias from the aliasList.

   973 	for(TInt i = 0; i < aAliasList.Count(); ++i)

   974 		{

   975 		if(aAliasName.CompareF(*aAliasList[i]) != 0)

   976 			{

   977 			continue;

   978 			}

   979 		

   980 		aliasFound = ETrue;

   981 		// retrieve the alias string corresponding to a given authentication strength.

   982 		iAuthRepository->GetAliasDefinitionL(i, aliasStringPtr);

   983 		if(aliasStringPtr.Length() == 0)

   984 			{

   985 			User::Leave(KErrAuthStrengthAliasNotDefined);

   986 			}

   987 			

   988 		// enclose the alias string within brackets.This would facilitate easy evaluation 

   989 		// of the alias string expression.

   990 		TInt newLength = aliasStringPtr.Length() + 2;

   991 		if(newLength > aliasStringPtr.MaxLength())

   992 			{

   993 			aliasString->ReAllocL(newLength);

   994 			}

   995 			

   996 		aliasStringPtr.Insert(0, KOpenBracket);

   997 		TInt index = aliasStringPtr.Length();

   998 		aliasStringPtr.Insert(index, KCloseBracket);

   999 		

  1000 		// tokenize aliasString, to facilitate parsing using TLex.

  1001 		CAuthExpressionImpl::InsertSpaceBetweenOperatorsL(*aliasString, aResultantString);

  1002 				

  1003 		if(aResultantString.Length() > aliasStringPtr.MaxLength())

  1004 			{

  1005 			aliasString = aliasString->ReAllocL(aResultantString.Length());

  1006 			}

  1007 		

  1008 		aliasStringPtr.Copy(aResultantString);

  1009 		aResultantString.Close();

  1010 		

  1011 		// aliasString contains an alias, so process it until we end up 

  1012 		// with an expression containing plugin Id or plugin Type or a combination of both.		

  1013 		ProcessAliasStringL(aAliasList, *aliasString, aResultantString);

  1014 				

  1015 		// ensure that the aliasString processing doesn't end in an infinite loop.

  1016 		// In case it does , leave with KErrAuthServInvalidAliasStringExpression.

  1017 		// For instance : fast = (medium & weak), medium = fast i.e 

  1018 		// medium = (medium & weak).

  1019 				

  1020 		if(aResultantString.FindC(aAliasName) != KErrNotFound)

  1021 			{

  1022 			User::Leave(KErrAuthServInvalidAliasStringExpression);

  1023 			}

  1024 							

  1025 		TBool found = CheckForAliasInAliasString(aAliasList, aResultantString);

  1026 		// 'resultantAliasString' may inturn contain an alias.So loop through the ProcessAliasStringL,

  1027 		// until  we end up with an alias string containing only plugin Id,plugin Type or a combination of both.

  1028 		while(found)

  1029 			{

  1030 			for(TInt j = 0; j < aAliasList.Count(); ++j)

  1031 				{

  1032 				if(aResultantString.FindC(*aAliasList[j]) != KErrNotFound)

  1033 					{

  1034 					if(aResultantString.Length() > aliasStringPtr.MaxLength())

  1035 						{

  1036 						aliasString->ReAllocL(aResultantString.Length());

  1037 						}

  1038 							

  1039 					aliasStringPtr.Copy(aResultantString);

  1040 					aResultantString.Close();

  1041 										

  1042 					CAuthExpressionImpl::InsertSpaceBetweenOperatorsL(*aliasString, aResultantString);

  1043 					if(aResultantString.Length() > aliasStringPtr.MaxLength())

  1044 						{

  1045 						aliasString->ReAllocL(aResultantString.Length());

  1046 						}

  1047 						

  1048 					aliasStringPtr.Copy(aResultantString);

  1049 					aResultantString.Close();

  1050 								

  1051 				 	ProcessAliasStringL(aAliasList, *aliasString, aResultantString);

  1052 					// ensure that the aliasString processing doesn't end in an infinite loop.

  1053 					// In case it does , leave with KErrArgument.

  1054 					// For instance : fast = (medium & weak), medium = fast i.e 

  1055 					// medium = (medium & weak).

  1056 					if(aResultantString.FindC(aAliasName) != KErrNotFound)

  1057 						{

  1058 						User::Leave(KErrAuthServInvalidAliasStringExpression);

  1059 						}

  1060 					break;

  1061 					}

  1062 				}

  1063 					

  1064 				// check if 'resultantExpr' still contains an alias.

  1065 			found = CheckForAliasInAliasString(aAliasList, aResultantString);				

  1066 			

  1067 			}

  1068 				

  1069 		break;

  1070 		}

  1071 	

  1072 	CleanupStack::PopAndDestroy(aliasString);

  1073 	

  1074 	//if the client supplied alias is not in the alias list, leave.

  1075 	if(!aliasFound)

  1076 		{

  1077 		User::Leave(KErrUnknownAuthStrengthAlias);

  1078 		}

  1079 

  1080 	}

  1081 

  1082 // Resets the training data for the supplied identity.

  1083 //	

  1084 // @param aMessage Client message which contains the details of 

  1085 //					identity and plugins for doing the reset

  1086 void CAuthServer::ResetIdentityL(TInt aFunction, const RMessage2& aMessage)

  1087 	{

  1088 	// Check if either an authentication or a training is going on

  1089 	if (ServerBusy())

  1090 		{

  1091 		aMessage.Complete(KErrServerBusy);

  1092 		return;

  1093 		}

  1094 

  1095 	// For reset by type only EAuthKnowledge type is supported

  1096 	if (aFunction == EResetIdentityByType)

  1097 		{

  1098 		TAuthPluginType pluginType = static_cast<TAuthPluginType>(aMessage.Int1());

  1099 		if (pluginType != EAuthKnowledge)

  1100 			{

  1101 			aMessage.Complete(KErrAuthServResetMayLoseIdentity);

  1102 			return;

  1103 			}

  1104 		}

  1105 

  1106 	// Get the list of trained plugins for this identity

  1107 	TIdentityId identityId = static_cast<TIdentityId>(aMessage.Int0());

  1108 	RArray<TPluginId> trainedPluginIdList;

  1109 	CleanupClosePushL(trainedPluginIdList);

  1110 	iAuthDb2->TrainedPluginsListL(identityId, trainedPluginIdList);

  1111 

  1112 	// Ensure at least one plugin knows identity

  1113 	TInt numTrained = trainedPluginIdList.Count();

  1114 	if (numTrained < 1)

  1115 		{

  1116 		CleanupStack::PopAndDestroy(&trainedPluginIdList);

  1117 		aMessage.Complete(KErrAuthServIdentityNotFound);

  1118 		return;

  1119 		}

  1120 

  1121 	// Try and ensure that after reset at least one plugin has an identity trained

  1122 	// Since all the trained plugins for the identity are being reset make sure

  1123 	// at least one of them is of the knowledge type to be reasonably sure it registers 

  1124 	// the new identity data

  1125 	TBool knowledgePluginFound = EFalse;

  1126 	for (TInt index = 0; index < numTrained; ++index)

  1127 		{

  1128 		TPluginId pluginId = trainedPluginIdList[index];

  1129 		CAuthPluginInterface* plugin = iPluginMgr->PluginL(pluginId);

  1130 		if (plugin->Type() == EAuthKnowledge)

  1131 			{

  1132 			knowledgePluginFound = ETrue;

  1133 			break;

  1134 			}

  1135 		}