/*
* 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: 
* authserverserversession.cpp
* CAuthserverSession class implementation
*
*/


/**
 @file 
*/

#include "authserver_impl.h"
#include "log.h"

using namespace AuthServer;

void CAuthServerSession::PanicClient(const RMessagePtr2& aMessage,
									 TAuthServerPanic aPanic)
	{
	aMessage.Panic(KAuthServerShortName, aPanic);
	}

//
// 2nd phase construct for sessions - called by the CServer framework
//
void CAuthServerSession::CreateL()
	{
	iAuthServer =
	  static_cast<CAuthServer*>(const_cast<CServer2*>(CSession2::Server()));
	}
CAuthServerSession* CAuthServerSession::NewL(CAuthServer &aServer)
/**
	Factory function allocates new instance of CAuthServerSession.

	@return					New, initialized instance of CAuthServerSession
							which is owned by the caller.
 */
	{
	CAuthServerSession* self = new(ELeave) CAuthServerSession(aServer);
	CleanupStack::PushL(self);
	self->ConstructL();			// CScsSession implementation
	CleanupStack::Pop(self);
	return self;
	}

CAuthServerSession::CAuthServerSession(CAuthServer &aServer)
/**
	This private constructor prevents direct instantiation.
 */
 :	CScsSession(aServer)
	{
	// empty.
	}


CAuthServerSession::~CAuthServerSession()
	{
	}

//
// Handle a client request.
// Leaving is handled by CAuthServer::ServiceError() which reports
// the error code to the client
//
TBool CAuthServerSession::DoServiceL(TInt aFunction, const RMessage2& aMessage)
/**
	Implement CScsSession by handling the supplied message.

	Note the subsession creation command is automatically sent to
	DoCreateSubsessionL, and not this function.

	@param	aFunction		Function identifier without SCS code.
	@param	aMessage		Standard server-side handle to message.	 Not used.
 */
	{
	TAuthServerMessages func = static_cast<TAuthServerMessages>(aFunction);
	
	switch (func)
		{
    case EAuthenticate:
        iAuthServer->AuthenticateL(aMessage);
        break;
    case ECancel:
		iAuthServer->CancelL(aMessage);
		break;
	case EPlugins:
		iAuthServer->PluginsL(aMessage);
		break;
	case EActivePlugins:
		iAuthServer->ActivePluginsL(aMessage);
		break;
	case EPluginsByType:
		iAuthServer->PluginsByTypeL(aMessage);
		break;
	case EPluginsByTraining:
		iAuthServer->PluginsByTrainingL(aMessage);
		break;
	case EIdentities:
		iAuthServer->IdentitiesL(aMessage);
		break;
	case EIdentityString:
		iAuthServer->IdentityStringL(aMessage);
		break;
	case ESetIdentityString:
		iAuthServer->SetIdentityStringL(aMessage);
		break;
	case ERegisterIdentity:
		iAuthServer->RegisterIdentityL(aMessage);
		break;
	case ERemoveIdentity:
		iAuthServer->RemoveIdentityL(aMessage);
		break;
	case ETrainPlugin:
		iAuthServer->TrainPluginL(aMessage);
		break;
	case EForgetPlugin:
		iAuthServer->ForgetPluginL(aMessage); 
		break;
    case EDeauthenticate:
		iAuthServer->DeauthenticateL(aMessage);
		break;
	case EGetAuthPreferences:
		iAuthServer->PreferredTypePluginL(aMessage);
	    break;
	case ESetAuthPreferences:
		iAuthServer->SetPreferredTypePluginL(aMessage);
		break;
	case EIdentitiesWithString:
		iAuthServer->IdentitiesWithStringL(aMessage);
		break;
	case EListAuthAliases:
		iAuthServer->ListAuthAliasesL(aMessage);
		break;
	case EResolveExpression:
		iAuthServer->ResolveExpressionL(aMessage);
		break;
	case EResetIdentity:
	case EResetIdentityByType:
		iAuthServer->ResetIdentityL(aFunction, aMessage);
		break;
	case EResetIdentityByList:
		iAuthServer->ResetIdentityByListL(aMessage);
		break;
	default:
		PanicClient(aMessage,EPanicInvalidFunction);
		break;
		}
	return EFalse;
	}

//
// Handle an error from CAuthServerSession::ServiceL()
// A bad descriptor error implies a badly programmed client, so panic it;
// otherwise use the default handling (report the error to the client)
//
void CAuthServerSession::ServiceError(const RMessage2& aMessage, TInt aError)
	{
	TBool panicClient = ETrue;
	TAuthServerPanic cliPanicReason = EPanicCorruptDescriptor;	//Init
	
	switch (aError)
		{
	case KErrBadDescriptor:
		cliPanicReason = EPanicCorruptDescriptor;
		break;
	
	case KErrAuthServInvalidInternalizeExpr:
		cliPanicReason = EPanicBadExternalizedAuthExpr;
		break;
	case KErrAuthServNoSuchPlugin:
		cliPanicReason = EPanicNoSuchAuthPlugin;
		break;
	
	default:
		panicClient = EFalse;
		}
	DEBUG_PRINTF3(_L8("Error in CAuthServerSession %d, func %d"), aError, aMessage.Function());

	if (panicClient)
		PanicClient(aMessage, cliPanicReason);
	else
		CScsSession::ServiceError(aMessage, aError);
	}