/*

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

* Example code

*

*/

#include "tmsgcommon.h"

#include "tmsgserver.h"

#include <e32cmn.h>

#include <e32debug.h>

inline CShutdown::CShutdown() :CTimer(-1) {CActiveScheduler::Add(this);}

inline void CShutdown::ConstructL() {CTimer::ConstructL();}

inline void CShutdown::Start() {After(KMyShutdownDelay);}

void CShutdown::RunL()

	{

	CActiveScheduler::Stop();

	}

// CMsgServer ****************************************************************

inline UserPromptService::RUpsSession& CMsgServer::Ups() {return iUps;}

const TInt CMsgServer::iRanges[KPolicyRanges] =

	{

	ESendMsg,			// network services requried

	ECancelSendMsg,		// no capability needed to request

	ESeperatorEndAll

	};

const TUint8 CMsgServer::iElementsIndex[KPolicyRanges] = 

	{

	0,								// capability check for networkservices

	EAlwaysPass,					// no check needed to cancel a request

	CPolicyServer::ENotSupported	

	};

static const TInt KMsgServerCustomFailureAction = -1;

const CPolicyServer::TPolicyElement CMsgServer::iPolicyElements[KPolicyElements] =

	{

	{_INIT_SECURITY_POLICY_C1(ECapabilityNetworkServices), KMsgServerCustomFailureAction}

	};

const CPolicyServer::TPolicy CMsgServer::iPolicy =

	{

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

	KPolicyRanges,									 

	iRanges,

	iElementsIndex,

	iPolicyElements,

	};

CMsgServer::CMsgServer()

	: CPolicyServer(EPriorityStandard, iPolicy, ESharableSessions)

	{

	}

CMsgServer::~CMsgServer()

	{

	iUps.Close();

	}

CMsgServer* CMsgServer::NewLC()

	{

	CMsgServer* self = new(ELeave) CMsgServer();

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CMsgServer::ConstructL() 

	{

	// Create the RUpsSession

	// A sub-session is created for each client

	User::LeaveIfError(iUps.Connect());

	StartL(KMsgServerName);

	iShutdown.ConstructL();

	iShutdown.Start();	

	}

CPolicyServer::TCustomResult CMsgServer::CustomFailureActionL(const RMessage2& aMessage, TInt /*aAction*/, const TSecurityInfo& /*aMissing*/)

/** This function is only invoked for requests that allow UPS authorisation. The 

 * message may be rejected later if the user denies the request.

 */

	{

	CSession2* s = aMessage.Session();

	__ASSERT_ALWAYS(s != NULL, User::Invariant());

	CMsgServerSession* session = static_cast<CMsgServerSession*>(s);

	session->SetPlatsecResult(EFalse);	

	return CPolicyServer::EPass;	// The request may be rejected later by the UPS

	}

CSession2* CMsgServer::NewSessionL(const TVersion& aVersion, const RMessage2& /*aMessage*/) const

	{

	TVersion v(KMsgServerVersionMajor, KMsgServerVersionMinor, KMsgServerVersionBuild);

	if (!User::QueryVersionSupported(v,aVersion))

		{

		User::Leave(KErrNotSupported);		

		}

	return new(ELeave) CMsgServerSession();

	}

void CMsgServer::AddSession()

	{

	++iSessionCount;

	iShutdown.Cancel();

	}

void CMsgServer::DropSession()

	{

	if (--iSessionCount==0)	iShutdown.Start();

	}

void PanicClient(const RMessagePtr2& aMessage,TMsgServerPanic aPanic)

	{

	aMessage.Panic(KMsgServerName,aPanic);

	}

// CMsgServerSession *********************************************************

inline CMsgServer& CMsgServerSession::Server()

{return *static_cast<CMsgServer*>(const_cast<CServer2*>(CSession2::Server()));}

CMsgServerSession::CMsgServerSession()

	: iPlatsecResult(ETrue)

	{

	}

CMsgServerSession::~CMsgServerSession()

	{

	delete iProcessor;	

	iAuth.Close();

	Server().DropSession();

	}

void CMsgServerSession::CreateL()

	{

	Server().AddSession();

	iProcessor = CMsgProcessor::NewL(iAuth);

	}

void CMsgServerSession::ServiceL(const RMessage2& aMessage)

	{

	if (! iAuthInitialised)

		{

		RThread client;

		aMessage.ClientL(client);

		CleanupClosePushL(client);

		User::LeaveIfError(iAuth.Initialise(Server().Ups(), client));

		CleanupStack::PopAndDestroy(&client);

		iAuthInitialised = ETrue;

		}	

	iProcessor->ProcessL(aMessage, iPlatsecResult);

	// Reset to 'passed' for next message because SetPlatsecResult is only ever called

	// when a check fails.

	iPlatsecResult = ETrue;	

	}

void CMsgServerSession::SetPlatsecResult(TBool aResult)

	{

	iPlatsecResult = aResult;

	}

// CMsgProcessor *********************************************************((((

CMsgProcessor* CMsgProcessor::NewL(UserPromptService::RUpsSubsession& aAuth)

	{

	CMsgProcessor* self = new(ELeave) CMsgProcessor(aAuth);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CMsgProcessor::CMsgProcessor(UserPromptService::RUpsSubsession& aAuth)

	: CActive(EPriorityStandard), iState(EIdle), iAuth(aAuth)

	{

	CActiveScheduler::Add(this);

	}

void CMsgProcessor::ConstructL()

	{

	User::LeaveIfError(iTimer.CreateLocal());

	}

CMsgProcessor::~CMsgProcessor()

	{	

	Deque();

	Reset();

	iTimer.Close();

	}

TInt CMsgProcessor::RunError(TInt aError)

	{

	if (iState != EIdle) iMessage.Complete(aError);

	Reset();

	return KErrNone;

	}

void CMsgProcessor::Reset() 

/**

 * Resets the processor for the next message.

 */

	{

	iMsgTo.Close();

	iMsgBody.Close();

	iState = EIdle;

	}

void CMsgProcessor::RunL()

	{

	User::LeaveIfError(iStatus.Int());

	switch (iState)

		{

		case EAuthorising:			

			// Check whether the request was authorised before proceeding

			if (iDecision == EUpsDecSessionNo || iDecision == EUpsDecNo)

				{ // The user or UPS denied the client's request so fail with security error.				  

				iMessage.Complete(KErrPermissionDenied);

				Reset();

				}

			else

				{ // Request authorised so carry on as normal

				SendL();	

				}

			break;

		case ESending:						

			// Message send so complete request and return

			iMessage.Complete(KErrNone);

			Reset();

			break;

		default: // invalid state - should never happen

			__ASSERT_ALWAYS(EFalse, User::Invariant()); 

			break;

		}

	}

void CMsgProcessor::DoCancel()

	{

	switch (iState)

		{

		case EIdle:

			break; // nothing to do

		case EAuthorising:

			iAuth.CancelPrompt();			

			break;

		case ESending:

			iTimer.Cancel();

			break;

		default: // invalid state - should never happen

			__ASSERT_ALWAYS(EFalse, User::Invariant());

		}

	if (iState != EIdle) iMessage.Complete(KErrCancel);

	Reset();

	}

void CMsgProcessor::GetParamsL(const RMessage2& aMessage)

/**

 * Reads the parameters for sending a message. This data is also needed for the authorisation prompt

 */

	{

	TInt l = aMessage.GetDesLength(0);

	if (l <= 0) User::Leave(KErrArgument);

	iMsgTo.CreateL(l);

	aMessage.ReadL(0, iMsgTo);

	l = aMessage.GetDesLength(1);

	if (l <= 0) User::Leave(KErrArgument);

	iMsgBody.CreateL(l);

	aMessage.ReadL(1, iMsgBody);

	}

void CMsgProcessor::AuthoriseL(const RMessage2& aMessage, TBool aPlatsecResult)

/**

 * Implementation of the new authorisation state

 * @param	aMessage		The message handle containing the SendMsg parameters

 * @param	aPlatsecResult	Whether the client has the correct capabilities etc

 */

	{

	iState = EAuthorising;

	iPlatsecResult = aPlatsecResult;

	iMessage = aMessage;

	GetParamsL(iMessage);	// message parameters are used to identify the request 

	iAuth.Authorise(iPlatsecResult, TUid::Uid(KServiceId), iMsgTo, iDecision, iStatus);

	SetActive();

	}

void CMsgProcessor::SendL() 

/**

 * Simulatate the sending of a message by displaying the body

 * to the screen and waiting for three seconds.

 * 

 * No changes necessary to support user prompts.

 */

	{

	iState = ESending;

	HBufC* tmp = HBufC::NewMaxLC(iMsgTo.Length() + iMsgBody.Length() + 3);

	tmp->Des().Format(_L("%S: %S"), &iMsgTo, &iMsgBody);

	User::LeaveIfError(User::InfoPrint(*tmp));

	CleanupStack::PopAndDestroy(tmp);

	iTimer.After(iStatus, 3 * 1000 * 1000);

	SetActive();

	}

void CMsgProcessor::ProcessL(const RMessage2& aMessage, TBool aPlatsecResult)

	{

	switch (aMessage.Function())

		{

		case ESendMsg:

			if (iState == EIdle)

				{ // The first state is now authorisation				

				AuthoriseL(aMessage, aPlatsecResult);

				}

			else

				{ // Concurrent requests not supported

				aMessage.Complete(KErrInUse); 

				}

			break;

		case ECancelSendMsg:

			Cancel();

			aMessage.Complete(KErrNone);

			break;

		default:

			User::Leave(KErrNotSupported);

		}

	}

static void RunServerL()

	{

	// normal server startup code

	User::LeaveIfError(RThread::RenameMe(KMsgServerName));

	CActiveScheduler* s=new(ELeave) CActiveScheduler;

	CleanupStack::PushL(s);

	CActiveScheduler::Install(s);	

	CMsgServer::NewLC();

	RProcess::Rendezvous(KErrNone);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(2, s); 

	}

TInt E32Main()

	{

	__UHEAP_MARK;

	CTrapCleanup* cleanup=CTrapCleanup::New();

	TInt r=KErrNoMemory;

	if (cleanup)

		{

		TRAP(r,RunServerL());

		delete cleanup;

		}

	__UHEAP_MARKEND;

	return r;

	}