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

// This file provides the implementation of the methods for NetUps SubSession

// @internalAll

// @prototype

// 

//

#include <e32base.h>		// define Active Scheduler

#include <e32property.h>	// defines properties

#include <ups/upsclient.h>

#include <ups/upstypes.h>

#include "netupsassert.h"

#include "netupskeys.h"

#include "netupsimpl.h"

#include "netupsstatemachine.h"

#include "netupssubsession.h"

#include "netupsprocessentry.h"

#include "netupsthreadentry.h"

#include "netupsthreadmonitor.h"

#include "netupspolicycheckrequestqueue.h"

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

namespace NetUps

{

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

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

CSubSession* CSubSession::NewL(UserPromptService::RUpsSession& aUpsSession, CDatabaseEntry& aDatabaseEntry, CProcessEntry& aProcessEntry, CThreadEntry&	aThreadEntry)

	{

	CSubSession* self = new (ELeave) CSubSession(aDatabaseEntry, aProcessEntry, aThreadEntry);

	CleanupStack::PushL(self);

	self->ConstructL(aUpsSession);

	CleanupStack::Pop(self);

	CActiveScheduler::Add(self);

	return self;	

	}

CSubSession::CSubSession(CDatabaseEntry& aDatabaseEntry, CProcessEntry& aProcessEntry, CThreadEntry&	aThreadEntry)

  : CActive(EPriorityStandard), iDatabaseEntry(aDatabaseEntry), iProcessEntry(aProcessEntry), iThreadEntry(aThreadEntry),

    iDecision(EUpsDecNo), iCommsId(NULL), iPolicyCheckRequestOriginator(NULL), iReadyForDeletion(EFalse)

    {

#ifdef _DEBUG    

	iState = EPCRPIdle;

#endif // _DEBUG

	}

CSubSession::~CSubSession()

	{

	if (IsActive())

		{

		Cancel();	

		}

	iUpsSubSession.Close();	

	iUpsOpaqueData.Close();

#ifdef _DEBUG

	iSimulatedDelay.Close();

#endif // _DEBUG

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

	__FLOG_CLOSE;	

	}

TInt CSubSession::Authorise(const CPolicyCheckRequestData& aPolicyCheckRequestData)

	{

	__FLOG_6(_L("CSubSession %08x:\tAuthoriseL() processId = %d, threadId = %d, serviceId = %d, platsec result = %d, Originator  = %08x"),

		this, aPolicyCheckRequestData.iProcessId.Id(), aPolicyCheckRequestData.iThreadId.Id(), (TInt32) aPolicyCheckRequestData.iServiceId, aPolicyCheckRequestData.iPlatSecCheckResult, &aPolicyCheckRequestData.iPolicyCheckRequestOriginator);

	TInt rc = KErrNone;

	_LIT(KAp,		  "AccessPoint = \"");	

	_LIT(KTerminator, "\"");

	TInt length = aPolicyCheckRequestData.iDestinationName.Length() + 

				  aPolicyCheckRequestData.iAccessPointName.Length();

	if (length > EMaxUnformattedLength)

		{

		__FLOG_4(_L("CSubSession %08x:\t AuthoriseL() = %d, iDestinationName.Length() = %d, iAccessPointName.Length() = %d, length = %d"), CActive::IsActive(), aPolicyCheckRequestData.iDestinationName.Length(), aPolicyCheckRequestData.iAccessPointName.Length(), length);

		rc = KErrOverflow;

		}

	else

		{

		iPolicyCheckRequestOriginator 	= &const_cast<MPolicyCheckRequestOriginator&>(aPolicyCheckRequestData.iPolicyCheckRequestOriginator);

		iCommsId 						= &aPolicyCheckRequestData.iCommsId;	

		ASSERT(iUpsOpaqueData.Length() == 0);

		iUpsOpaqueData.Append(KAp);

		iUpsOpaqueData.Append(aPolicyCheckRequestData.iAccessPointName);

		iUpsOpaqueData.Append(KTerminator);			

		iUpsSubSession.Authorise(aPolicyCheckRequestData.iPlatSecCheckResult,  

				 TUid::Uid(aPolicyCheckRequestData.iServiceId),

				 aPolicyCheckRequestData.iDestinationName,

				 iUpsOpaqueData, 

				 iDecision, 

				 iStatus);

#ifdef _DEBUG

		iState =  EPCRPSimulateDelay;

#endif // _DEBUG

		SetActive();		

		}

	return rc;

	}

void CSubSession::RunL()

	{

	__FLOG_3(_L("CSubSession %08x:\tRunL(): IsActive() = %d, iStatus.Int() = %d"), this, CActive::IsActive(), iStatus.Int());	

#ifdef _DEBUG

	switch (iState)

		{

		case EPCRPSimulateRequest:

#endif

			{

			__FLOG_5(_L("CSubSession %08x:\tRunL() iDecision = %d, iCommsId = %08x, iPolicyCheckRequestOriginator = %08x, iReadyForDeletion = %d"), this, iDecision, iCommsId, iPolicyCheckRequestOriginator, iReadyForDeletion);	

			__ASSERT_DEBUG((iPolicyCheckRequestOriginator != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsSubSession));

			__ASSERT_DEBUG((iCommsId 					  != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsSubSession1));

			TNetUpsDecision netUpsDecision = static_cast<TNetUpsDecision>(iDecision);

			TCommsIdKey commsIdKey(iDatabaseEntry, iProcessEntry, iThreadEntry, *iCommsId);

#ifdef _DEBUG

			// Logic to put the NetUps into its error paths; don't include in production build

			ModifyIStatusValue(netUpsDecision);

#endif

			if (iStatus == KErrNone)

				{

				iProcessEntry.UpsStateMachine().HandleUPSRequestCompletionL(commsIdKey, *iPolicyCheckRequestOriginator, netUpsDecision); 	

				// if HandleUPSRequestCompletionL() leaves, then the error is managed in CSubSession::RunError(TInt aError) below

				}

			else	

				{

				// no state change has occured, at the most a threadEntry, processEntry, and databaseEntry have been created which

				// can be just left for the moment - could consider removing them later.

				iProcessEntry.UpsStateMachine().HandleUPSErrorOnCompletionL(commsIdKey, *iPolicyCheckRequestOriginator, iStatus.Int()); 	

				}

			// Reset the temporary variables

			ResetAuthorisationRequestParameters();

			DeleteCurrentRequestFromQueue();

			if (SubSessionReadyForDeletion() == EFalse)

				{

				PostNextRequestFromQueue();

				}

			else

				{

				delete this;

				}		

#ifdef _DEBUG

			break;	

#endif

			}

#ifdef _DEBUG

		case EPCRPSimulateDelay:

			{

			iSimulatedDelay.After(iStatus,EDelay);

			iState = EPCRPSimulateRequest;

			SetActive();	

			break;				

			}

		default:

			User::Panic(KNetUpsPanic, KPanicInvalidLogic);

			break;

		}

#endif // _DEBUG

	}

void CSubSession::DoCancel()

	{

	__FLOG_1(_L("CSubSession %08x:\tDoCancel()"), this);	

	iUpsSubSession.CancelPrompt();

#ifdef _DEBUG

	iSimulatedDelay.Cancel();

#endif

	if (iCommsId)

		{

		iThreadEntry.RemoveCommsId(*iCommsId);		

		} 

	ResetAuthorisationRequestParameters();

#ifdef _DEBUG

	User::After(ECancelDelay);

#endif	

	}

void CSubSession::DeleteCurrentRequestFromQueue()

	{

	// Determine whether the last entry on the queue should be flushed.

	// The logic here needs to be reviewed as there are various cases

	// when the thread entry exists and when it does not. The up shot is

	// that is is probably better to remove the entry of the queueu during

	// the HandleUpsRequestCompletion, to keep the logic all in the one place.

	// However, for now:			

	CNetUpsImpl::TSessionMode 	sessionMode  = CNetUpsImpl::MapInternalStateToSessionMode(iProcessEntry.NetUpsState());

	CNetUpsImpl::TLifeTimeMode 	lifeTimeMode = iProcessEntry.UpsStateMachine().NetUpsImpl().LifeTimeMode();

	switch(sessionMode)

		{			

		case CNetUpsImpl::ENonSessionMode:

			// finished with current entry, delete it.

			iThreadEntry.RequestQueue().DeleteCurrentEntry();

			break;

		case CNetUpsImpl::ESessionMode:

			switch(lifeTimeMode)

				{

				case CNetUpsImpl::EProcessLifeTimeMode:

					// thread entry gone, queue already deleted.

					break;

				case CNetUpsImpl::ENetworkLifeTimeMode:

					// thread entry remains, delete last queue entry

					iThreadEntry.RequestQueue().DeleteCurrentEntry();

					break;

				default:

					User::Panic(KNetUpsPanic, KPanicInvalidLogic);

					break;

				}

			break;

		default:

			User::Panic(KNetUpsPanic, KPanicInvalidLogic);

			break;

		}			

	}

void CSubSession::PostNextRequestFromQueue()

	{

#ifdef _DEBUG

	iState = EPCRPIdle;

#endif

	// determine there is an opportunity for the next entry to be forwarded to the UPS server.			

	while ((iThreadEntry.RequestQueue().IsEmpty() == EFalse) && (IsActive() == EFalse))

		{

		CPolicyCheckRequestData&  policyCheckRequestData = iThreadEntry.RequestQueue().GetNextRequest();

		__FLOG_2(_L("CSubSession: %08x:\t RunL(), post next request, policyCheckRequest = %08x"), this, &policyCheckRequestData);		

		TInt err = Authorise(policyCheckRequestData);

		if (err != KErrNone)

			{

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

			policyCheckRequestData.iPolicyCheckRequestOriginator.ProcessPolicyCheckResponse(KErrCancel, commsId);

			iThreadEntry.RequestQueue().DeleteCurrentEntry();

#ifdef _DEBUG

			iState = EPCRPIdle;

#endif

			}

		}	

	}

void CSubSession::ConstructL(UserPromptService::RUpsSession& aUpsSession)

	{

	// 	Interesting opportunity to log the process and thread ids

	//	RProcess process;

	// 	TSecureId secureId = process.SecureId();

	__FLOG_OPEN(KNetUpsSubsys, KNetUpsComponent);

	__FLOG_1(_L("CSubSession %08x:\tConstructL()"), this);	

	RThread thread;

	TInt ret = thread.Open(iThreadEntry.ThreadId());

	if (ret != KErrNone)

		{

		__FLOG_2(_L("CSubSession %08x:\tError %d opening thread %d\n"), ret, iThreadEntry.ThreadId().Id());

		User::Leave(ret);

		}

	(void) User::LeaveIfError(iUpsSubSession.Initialise(aUpsSession, thread));

	thread.Close();

	iUpsOpaqueData.CreateL(EMaxFormattedLength);

	#ifdef _DEBUG

	(void) User::LeaveIfError(iSimulatedDelay.CreateLocal()); // Add temporary delay for Nadeem

#endif

	}

void CSubSession::SetReadyForDeletion()

	{

	__FLOG_1(_L("CSubSession %08x:\tSetReadyForDeletion()"), this);	

	iReadyForDeletion = ETrue;

	}

TBool CSubSession::SubSessionReadyForDeletion()

	{

	return iReadyForDeletion;

	}

void CSubSession::ResetAuthorisationRequestParameters()

	{

	iUpsOpaqueData.Zero();	

	iPolicyCheckRequestOriginator 	= NULL;	

	iCommsId 						= NULL;	

	}

TInt CSubSession::RunError(TInt aError)

	{

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

	(void) aError;

	// Handles Leaves from CSubSession::RunL.

	// We don't allocate any memory in the RunL, so this method should never be called.

	return KErrNone;	

	}

#ifdef _DEBUG

void CSubSession::ModifyIStatusValue(TNetUpsDecision aNetUpsDecision)

	{

	TInt rc = RProperty::Get(KUidNetUpsTestNotifCategory, KNetUpsSubSessionError, iTestErrorCode);

	if (  	(rc == KErrNone) &&

			(iTestErrorCode != KErrNone) && 

		  ( ((aNetUpsDecision == EYes)  && 

		    (iProcessEntry.NetUpsState() == EProcLife_NonSession) || (iProcessEntry.NetUpsState() == ENetLife_NonSession))

		     ||

			 ((aNetUpsDecision == ESessionYes) &&

		     ((iProcessEntry.NetUpsState() == EProcLife_Transit_SessionYes ) || (iProcessEntry.NetUpsState() == EProcLife_Transit_SessionNo ) ||

		      (iProcessEntry.NetUpsState() == ENetLife_SessionNo_Transit_WithoutConnections  ) || (iProcessEntry.NetUpsState() == ENetLife_SessionNo_Transit_WithConnections  ) ||

		      (iProcessEntry.NetUpsState() == ENetLife_Transit_SessionYes  )) )

		      ) )

		{

		iStatus = iTestErrorCode;

		}	

	}

#endif

} // end of namespace