// 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 "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:

// policycheckrequestqueue.cpp

// This file provides the implementation of the inline methods for the

// CPolicyCheckRequestQueue (implemented as a single linked list),

// TQueuedPolicyCheckRequest (the representation of its constituent

// nodes) and TPolicyCheckRequestData_NonRef ( a container for 

// policy check request attributes).

// @internalAll

// @prototype

// 

//

#include <e32base.h>						// Definition for CActiveScheduler::Add()

#include <comms-infras/ss_activities.h>

#include "netupstypes.h"					// defines the request id.

#include "netupsassert.h"

#include "netupspolicycheckrequestqueue.h"

#include "netupssubsession.h"				// Defines NetUpsSubSession

#include <comms-infras/commsdebugutility.h> // defines the comms debug logging utility

namespace NetUps

{

__FLOG_STMT(_LIT8(KNetUpsSubsys, 	"esock");)   

__FLOG_STMT(_LIT8(KNetUpsComponent, "NetUps");) /*esockloader*/

CPolicyCheckRequestData* CPolicyCheckRequestData::NewL(const TPolicyCheckRequestData& aPolicyCheckRequestData)

	{

	CPolicyCheckRequestData*  self = new (ELeave) CPolicyCheckRequestData(aPolicyCheckRequestData);

	CleanupStack::PushL(self);

	self->ConstructL(aPolicyCheckRequestData.iDestinationName, aPolicyCheckRequestData.iAccessPointName);

	CleanupStack::Pop(self);	

	return self;	

	}

CPolicyCheckRequestData::~CPolicyCheckRequestData()

	{

	iDestinationName.Close();

	iAccessPointName.Close();	

	__FLOG_1(_L("CPolicyCheckRequestData %08x:\t ~CQueuedPolicyCheckRequest()"), this);

	__FLOG_CLOSE;	

	}

void CPolicyCheckRequestData::ConstructL(const TDesC& 	aDestinationName,

										 const TDesC& 	aAccessPointName)

	{

	iDestinationName.CreateL(aDestinationName);

	iAccessPointName.CreateL(aAccessPointName);

	__FLOG_OPEN(KNetUpsSubsys, KNetUpsComponent);			

	//__FLOG_7(_L("CPolicyCheckRequestData %08x:\t ConstructL() iProcessId.Id() = %d, iThreadId.Id() = %d, iServiceId = %d, iPlatSecCheckResult = %d, iCommsId = %08x, iPolicyCheckRequestOriginator  = %08x"), this, iProcessId.Id(), iThreadId.Id(), iServiceId, iPlatSecCheckResult, iCommsId, iPolicyCheckRequestOriginator);

	__FLOG_6(_L("CPolicyCheckRequestData %08x:\t ConstructL() iProcessId.Id() = %d, iThreadId.Id() = %d, iServiceId = %d, iPlatSecCheckResult = %d, iPolicyCheckRequestOriginator  = %08x"), this, iProcessId.Id(), iThreadId.Id(), iServiceId, iPlatSecCheckResult, &iPolicyCheckRequestOriginator);

	}

CQueuedPolicyCheckRequest* CQueuedPolicyCheckRequest::NewL(const TPolicyCheckRequestData& aPolicyCheckRequestData, const TRequestId& aRequestId)

	{

	CQueuedPolicyCheckRequest*  self = new (ELeave) CQueuedPolicyCheckRequest(aRequestId);

	CleanupStack::PushL(self);

	self->ConstructL(aPolicyCheckRequestData);

	CleanupStack::Pop(self);	

	return self;

	}

void CQueuedPolicyCheckRequest::ConstructL(const TPolicyCheckRequestData& aPolicyCheckRequestData)

	{

	iPolicyCheckRequestData = CPolicyCheckRequestData::NewL(aPolicyCheckRequestData);

	}

CQueuedPolicyCheckRequest::CQueuedPolicyCheckRequest(const TRequestId& aRequestId)

  : iRequestId(aRequestId)

	{

	}

CQueuedPolicyCheckRequest::~CQueuedPolicyCheckRequest()

	{

	delete iPolicyCheckRequestData;

	}

const TRequestId& CQueuedPolicyCheckRequest::RequestId()

	{

	return iRequestId;	

	}

CPolicyCheckRequestQueue* CPolicyCheckRequestQueue::NewL(CSubSession& aSubsession)

	{

	CPolicyCheckRequestQueue*  self = new (ELeave) CPolicyCheckRequestQueue(aSubsession);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);	

	return self;

	}

CPolicyCheckRequestQueue::~CPolicyCheckRequestQueue()

	{

	__FLOG_1(_L("CPolicyCheckRequestQueue %08x:\t ~CPolicyCheckRequestQueue()"), this);		

	// If the destructor is being called, the SubSession should be inactive - however, cannot check this

	// as it may have already been deleted.

	// Under normal circumstances, the assumption is that the client code has emptied the queue before

	// deleting the queue. However is this always true ? What happens if the NetUps is deleted with

	// outstanding messages on the queue ?

	__FLOG_2(_L("CPolicyCheckRequestQueue %08x:\t QueueL() iRequestQueue.IsEmpty() = %d"), this, iRequestQueue.IsEmpty());		

	//__ASSERT_DEBUG((iRequestQueue.IsEmpty() != EFalse), User::Panic(KNetUpsPanic, KPanicInvalidLogic));

	while (iRequestQueue.IsEmpty() == EFalse)

		{

		CQueuedPolicyCheckRequest* queuedPolicyCheckRequest = iRequestQueue.First();

		__ASSERT_DEBUG((queuedPolicyCheckRequest != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetupsPolicyCheckRequestQueue));

		iRequestQueue.Remove(*queuedPolicyCheckRequest);

		delete queuedPolicyCheckRequest;

		}

	__FLOG_CLOSE;	

	}

void CPolicyCheckRequestQueue::SendRequestL(const TPolicyCheckRequestData& aPolicyCheckRequestData, const TRequestId& aRequestId)  

	{

	__FLOG_1(_L("CPolicyCheckRequestQueue %08x:\tSendRequestL()"), this);		

	CQueuedPolicyCheckRequest* queuedPolicyCheckRequest = CQueuedPolicyCheckRequest::NewL(aPolicyCheckRequestData, aRequestId);

	iRequestQueue.AddLast(*queuedPolicyCheckRequest);

	PostFirstRequestOnQueueToUpsServer();

	}

void CPolicyCheckRequestQueue::PostFirstRequestOnQueueToUpsServer()  

	{

	__FLOG_1(_L("CPolicyCheckRequestQueue %08x:\tPostFirstRequestOnQueueToUpsServer()"), this);		

	while ((iRequestQueue.IsEmpty() == EFalse) && (iSubSession.IsActive() == EFalse))

		{

		CPolicyCheckRequestData& policyCheckData = GetNextRequest(); 

		__FLOG_3(_L("CPolicyCheckData %08x:\t post next request, policyCheckData = %08x, iSubSession = %08x"), this, &policyCheckData, &iSubSession);		

		TInt err = iSubSession.Authorise(policyCheckData);

		if (err != KErrNone)

			{

			const Messages::TNodeId& commsId = policyCheckData.iCommsId;

			policyCheckData.iPolicyCheckRequestOriginator.ProcessPolicyCheckResponse(KErrCancel, commsId);

			DeleteCurrentEntry();			

			}

		}

	}

void CPolicyCheckRequestQueue::ConstructL()

	{

	__FLOG_OPEN(KNetUpsSubsys, KNetUpsComponent);			

	__FLOG_1(_L("CPolicyCheckRequestQueue %08x:\t ConstructL()"), this);		

	}

TInt CPolicyCheckRequestQueue::CancelRequest(const Messages::TNodeId& aCommsId, const TRequestId& aRequestId)

	{

	__FLOG_2(_L("CPolicyCheckRequestQueue %08x:\tCancelRequest(), requestId = %d"), this, aRequestId);		

	TInt rc = KErrNotFound;

	TSglQueIter<CQueuedPolicyCheckRequest>  requestQueueIterator(iRequestQueue);

	CQueuedPolicyCheckRequest* policyCheckRequest= NULL;

	while ((policyCheckRequest = requestQueueIterator++) != NULL)

		{

		if (policyCheckRequest->RequestId() ==  aRequestId)

			{

			__FLOG_2(_L("CPolicyCheckRequestQueue %08x:\t CancelRequest() policyCheckRequest = %08x"), this, policyCheckRequest);		

			if (iRequestQueue.IsFirst(policyCheckRequest) && iSubSession.IsActive())

				{

				iSubSession.Cancel();

				}

			// notify the client of the cancellation

			policyCheckRequest->PolicyCheckRequestData().iPolicyCheckRequestOriginator.ProcessPolicyCheckResponse(KErrCancel, aCommsId);

			// delete the current entry

			iRequestQueue.Remove(*policyCheckRequest);

			delete policyCheckRequest;

			policyCheckRequest	= NULL;

			PostFirstRequestOnQueueToUpsServer();

			rc = KErrNone;

			break;

			}

		}

	return rc;	

	}

void CPolicyCheckRequestQueue::CancelAllRequests(TInt aError)

	{

	__FLOG_2(_L("CPolicyCheckRequestQueue %08x:\tCancelAllRequests(), aError = %d"), this, aError);		

	if (iSubSession.IsActive() != EFalse)

		{

		iSubSession.Cancel();		

		}

	while (iRequestQueue.IsEmpty() == EFalse)

		{

		CPolicyCheckRequestData& policyCheckData = GetNextRequest(); 

		__FLOG_1(_L("Cancel next request, policyCheckData = %08x"), &policyCheckData);		

		policyCheckData.iPolicyCheckRequestOriginator.ProcessPolicyCheckResponse(aError, policyCheckData.iCommsId);

		DeleteCurrentEntry();			

		}

	}

void CPolicyCheckRequestQueue::DeleteCurrentEntry()

	{

	__FLOG_1(_L("CPolicyCheckRequestQueue %08x:\tDeleteCurrentEntry()"), this);		

	CQueuedPolicyCheckRequest* queuedPolicyCheckRequest = iRequestQueue.First();

	__ASSERT_DEBUG((queuedPolicyCheckRequest != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetupsPolicyCheckRequestQueue1));

	iRequestQueue.Remove(*queuedPolicyCheckRequest);

	delete queuedPolicyCheckRequest;	

	}

TBool CPolicyCheckRequestQueue::IsEmpty() const

	{

	return iRequestQueue.IsEmpty();

	}

TBool CPolicyCheckRequestQueue::OutStandingRequestToProcess()

	{

	TBool rc = EFalse;

	if ((iRequestQueue.IsEmpty() == EFalse) && (iRequestQueue.First() != iRequestQueue.Last())) 

		{

		rc = ETrue;

		}

	return rc;	

	}

CPolicyCheckRequestData& CPolicyCheckRequestQueue::GetOutStandingRequestToProcess()

	{

	__ASSERT_DEBUG( ((iRequestQueue.IsEmpty() == EFalse) && (iRequestQueue.First() != iRequestQueue.Last())),

	 User::Panic(KNetUpsPanic, KPanicInvalidLogic)); 

	return (iRequestQueue.Last())->PolicyCheckRequestData();

	}

void CPolicyCheckRequestQueue::DeleteOutStandingRequest()

	{

	__ASSERT_DEBUG( ((iRequestQueue.IsEmpty() == EFalse) && (iRequestQueue.First() != iRequestQueue.Last())),

	 User::Panic(KNetUpsPanic, KPanicInvalidLogic)); 

	CQueuedPolicyCheckRequest* queuedPolicyCheckRequest = iRequestQueue.Last();

	iRequestQueue.Remove(*queuedPolicyCheckRequest);

	delete queuedPolicyCheckRequest;

	}

CPolicyCheckRequestData& CPolicyCheckRequestQueue::GetNextRequest()

	{

	__FLOG_1(_L("CPolicyCheckRequestQueue %08x:\tGetNextRequest(), iSubSession = %08x"), this);		

	CQueuedPolicyCheckRequest* queuedPolicyCheckRequest = iRequestQueue.First();  

	__ASSERT_DEBUG((queuedPolicyCheckRequest != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetupsPolicyCheckRequestQueue2));

	return queuedPolicyCheckRequest->PolicyCheckRequestData();

	}

CPolicyCheckRequestQueue::CPolicyCheckRequestQueue(CSubSession& aSubSession) : iSubSession(aSubSession)		

	{

	__FLOG_1(_L("CPolicyCheckRequestQueue %08x:\tCPolicyCheckRequestQueue(), iSubSession = %08x"), this);		

	iRequestQueue.SetOffset(_FOFF(CQueuedPolicyCheckRequest,iLink));			

	}	

} // end of namespace netups