/*

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

*

*/

#include "tocspserver.h"

#include "tocspclientserver.h"

using Swi::Test::COcspServer;

using Swi::Test::COcspStateMachine;

using Swi::Test::COcspSession;

using Swi::Test::COcspServerShutdown;

static void PanicClient(const RMessagePtr2& aMessage, 

						Swi::Test::TOcspServerPanic aPanic)

	{

	aMessage.Panic(Swi::Test::KOcspServerName, aPanic);

	}

/////

///// TOCSP Server

/////

/*static*/ COcspServer* COcspServer::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void COcspServer::AddSession()

	{

	++iSessionCount;

	iShutdown->Cancel();

	}

void COcspServer::DropSession()

	{

	if (--iSessionCount==0)

		{

		iShutdown->Start();

		}

	}

COcspServer::~COcspServer()

	{

	delete iShutdown;

	}

COcspServer::COcspServer() : CServer2(EPriorityNormal, ESharableSessions)

	{

	}

void COcspServer::ConstructL()

	{

	StartL(Swi::Test::KOcspServerName);

//	iConsole = Console::NewL(_L("SWI Console Server Test"), TSize(KDefaultConsWidth, KDefaultConsHeight));

	iShutdown = COcspServerShutdown::NewL();

	// Ensure that the server still exits even if the 1st client fails to

	// connect

	iShutdown->Start();

	}

CSession2* COcspServer::NewSessionL(const TVersion& /*aVersion*/, 

									   const RMessage2& /*aMessage*/) const

	{

	return new(ELeave) COcspSession();

	}

void COcspSession::CreateL()

	{

	Server().AddSession();

	}

COcspSession::COcspSession(/*CConsoleBase& aConsole*/) : CSession2() //, iConsole(aConsole)

	{

	}

COcspSession::~COcspSession()

	{

	Server().DropSession();

	}

COcspServer& COcspSession::Server()

	{

	return *static_cast<COcspServer*>(

		const_cast<CServer2*>(CSession2::Server()));

	}

/////

///// COcspSession		

/////

void COcspSession::ServiceL(const RMessage2& aMessage)

	{

	switch (aMessage.Function())

		{

		case ECheck:

			{

			if (iStateMachine)

				{

				delete iStateMachine;

				}

			iStateMachine = COcspStateMachine::NewL(aMessage);

			iStateMachine->DoCheck();

			}

			break;

		default:

			{

			PanicClient(aMessage, Swi::Test::EPanicOcspServerIllegalFunction);

			break;

			}

		}

	}

void COcspSession::ServiceError(const RMessage2& aMessage, TInt aError)

	{

	if (aError==KErrBadDescriptor)

		{

		PanicClient(aMessage, Swi::Test::EPanicOcspServerBadDescriptor);

		}

	CSession2::ServiceError(aMessage, aError);

	}

/////

///// CInstallServerShutdown

/////

inline COcspServerShutdown::COcspServerShutdown() : CTimer(-1)

	{

	CActiveScheduler::Add(this);

	}

inline void COcspServerShutdown::ConstructL()

	{

	CTimer::ConstructL();

	}

inline void COcspServerShutdown::Start()

	{

	After(KShutdownDelay);

	}

/*static*/ COcspServerShutdown* COcspServerShutdown::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

// Initiate server exit when the timer expires

void COcspServerShutdown::RunL()

	{

	CActiveScheduler::Stop();

	}

////

//// State Machine

////

/*static*/ COcspStateMachine* COcspStateMachine::NewL(const RMessage2& aMessage)

	{

	COcspStateMachine* self = new (ELeave) COcspStateMachine(aMessage);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

COcspStateMachine::COcspStateMachine(const RMessage2& aMessage) : CActive(EPriorityNormal), iClientMessage(aMessage)

	{

	CActiveScheduler::Add(this);

	}

COcspStateMachine::~COcspStateMachine()

	{

	if (iSecurityManager)

		{

		delete iSecurityManager;

		}

	iOcspOutcomes.ResetAndDestroy();

	iCerts.ResetAndDestroy();

	if (iOcspUri) 

		{

		delete iOcspUri;

		}

	}

void COcspStateMachine::ConstructL()

	{	

	}

void COcspStateMachine::DoCheck()

	{

	iSecurityManager = CSecurityManager::NewL();

	iState = EDone;	

	iIap = 0;

	iSecurityManager->PerformOcspL(*iOcspUri, 

								   iIap,

							   	   iRevocationMessage, 

							   	   iOcspOutcomes, 

							   	   iCerts,

							   	   iStatus);

	SetActive();

	}

void COcspStateMachine::RunL()

	{

	if (iStatus.Int() != KErrNone)

		{

		User::Leave(iStatus.Int()); // Hop into RunError()

		}

	switch (iState)

		{

		case EDone:

			{

			iClientMessage.Complete(static_cast<TInt>(*iRevocationMessage));

			}

			break;

		default:

			{

			User::Panic(_L("Test OCSP Server"), 1);

			}

		}

	}

void COcspStateMachine::DoCancel()

	{

	}

TInt COcspStateMachine::RunError(TInt aError)

	{

	iClientMessage.Complete(aError);

	return KErrNone;

	}