/*

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

 	}