// 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 for CNetUps's methods

// @internalAll

// @released

// 

//

#include <e32std.h> 			// defines DLL TLS

#include <e32err.h> 			// defines standard error codes

#include <e32const.h>			// defines KMaxTInt32

#include "netupsassert.h" 		// defines NetUps Asserts

#include "netupsserviceid.h"	// defines the supported service ids.

#include "netups.h"				// defines public NetUps interface

#include "netupsimpl.h"			// defines the NetUps implementation

#include "netupstls.h"			// defines structure used to store Netups components in TLS

using namespace Messages;

namespace NetUps

{

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

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

EXPORT_C CNetUps* CNetUps::NewL(TInt32 aServiceId)

/** Creates an instance of the Net UPS. 

@return A pointer to an instance of the Net UPS if successful, otherwise leaves with a system error code.

 */ 

	{

	CNetUps* self = new (ELeave) CNetUps(aServiceId);

#ifdef NETUPS_TEST_HARNESS

	__UHEAP_MARK;

#endif

	CleanupStack::PushL(self);

	self->ConstructL(aServiceId);

	CleanupStack::Pop(self);

	return self;

	}

void CNetUps::ConstructL(TInt32 aServiceId)

	{

	if (aServiceId != EIpServiceId)

		{

		__FLOG_STATIC1(KNetUpsSubsys, KNetUpsComponent, _L("CNetUps::ConstructL aServiceId = %d"), aServiceId);

		User::Leave(KErrNotSupported);

		}

	CNetUpsTls* netUpsTls = static_cast<CNetUpsTls*>(Dll::Tls());

	__FLOG_OPEN(KNetUpsSubsys, KNetUpsComponent);

	__FLOG_2(_L("CNetUps %08x:\tConstructL(), aServiceId = %d"), this, aServiceId);		

	if (netUpsTls == NULL)

		{

		netUpsTls = CNetUpsTls::NewL(aServiceId);

		CleanupStack::PushL(netUpsTls);

		Dll::SetTls( static_cast<TAny*>(const_cast<CNetUpsTls*>(netUpsTls)) );

		CleanupStack::Pop(netUpsTls);

		}

	iNetUps = netUpsTls->GetNetUpsImpl();

	if (iNetUps->RefCount() == KMaxTInt32)

		{

		User::Leave(KErrOverflow);

		}

	else

		{

		iNetUps->IncrementRefCount();				

		}	

	}

CNetUps::CNetUps(TInt32 aServiceId) : iServiceId(aServiceId)

	{

	}

CNetUps::~CNetUps()

/** Deletes this instance of the Net UPS. 

 */

	{

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

	if (iNetUps) // OOM tests require this, investigate.

		{

		iNetUps->DecrementRefCount();

		if (iNetUps->RefCount() <= 0)

			{

			CNetUpsTls* netUpsTls = static_cast<CNetUpsTls*>(Dll::Tls());

			delete netUpsTls;

			Dll::SetTls( static_cast<TAny*>(NULL) );

			}			

		}

	__FLOG_CLOSE;	

#ifdef NETUPS_TEST_HARNESS

	__UHEAP_MARKEND;	

#endif

	}	

EXPORT_C TBool CNetUps::UpsDisabled(TInt32 aServiceId)

/** Determines whether the NetUps Component is disabled or enabled for a given Service ID.

@param aServiceId The service ID which specialises this query.

*/

	{

	__FLOG_STATIC1(KNetUpsSubsys, KNetUpsComponent, _L("CNetUps::UpsDisabled(), aServiceId = %d"), aServiceId);		

	TBool rc = ETrue;

	if (aServiceId != EIpServiceId)

		{

		__FLOG_STATIC0(KNetUpsSubsys, KNetUpsComponent, _L("CNetUps::UpsDisabled() Service id not supported"));

		rc = EFalse;

		}

	else

		{

		CNetUps* netUps = NULL;

		TRAPD(err, netUps = CNetUps::NewL(aServiceId);)

		if (err == KErrNone)

			{

			// coverity[leave_without_push]

			delete netUps;

			rc = EFalse;		

			}				

		}

	return rc;

	}

EXPORT_C void CNetUps::ProcessPolicyCheckRequestL(TPolicyCheckRequestData& aPolicyCheckRequestData, TRequestId& aRequestId)

/** Processes an asynchronous UPS policy check request; when the request completes the CNetUps calls

MPolicyCheckRequestOriginator::ProcessPolicyCheckResponse to notify the originator of the response.

@param aPolicyCheckRequestData A structure which encapsulates the attributes associated with a policy check request.

@param aRequestId			   The NetUps updates this variable with an identifier which uniquely identifies this policy check request.

 */

	{

	__FLOG_7(_L("CNetUps %08x:\tProcessPolicyCheckRequestL(): process id = %d, thread id = %d, service id = %d, platsec result = %d, commsId = %08x, originator  = %08x"),

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

	aPolicyCheckRequestData.SetServiceId(iServiceId);

	iNetUps->ProcessPolicyCheckRequestL(aPolicyCheckRequestData, aRequestId);				

	}

EXPORT_C TInt CNetUps::CancelRequest(const TNodeId& aCallersNodeId, const TRequestId& aRequestId)

/** Cancels an outstanding asynchronous UPS Policy Check Request.

 * 

@param aCallersNodeId   A structure which uniquely identifies the node which posted the original request.

@param aRequestId This variable uniquelyidentifies the policy check request which is to be cancelled.

 */

	{

	__FLOG_3(_L("CNetUps %08x:\tCancelRequest(), aCallersNodeId = %08x, iServiceId = %d"), this, &aCallersNodeId, iServiceId);		

	return iNetUps->CancelRequest(iServiceId, aCallersNodeId, aRequestId);

	}

EXPORT_C void CNetUps::IncrementConnectionCountL(const TNodeId& aCallersNodeId)

/** Increments the connection count associated with a particular thread.

Typically the connection count is incremented by the NetUps as soon as the request is authorised to

avoid race conditions which may result in an inaccurate connection count.

@param aCallersNodeId      The CommsId associated with the caller of this method.    	   

 */

	{

	__FLOG_3(_L("CNetUps %08x:\tIncrementConnectionCountL(), aCallersNodeId = %08x, iServiceId = %d"), this, &aCallersNodeId, iServiceId);		

	iNetUps->IncrementConnectionCountL(iServiceId, aCallersNodeId);

	}

EXPORT_C void CNetUps::DecrementConnectionCountL(const TNodeId& aCallersNodeId)

/** Decrements the connection count associated with a particular thread.

This method should always be called when a connection is deleted.

@param aCallersNodeId      The CommsId associated with the caller of this method.    	   

 */

	{

	__FLOG_3(_L("CNetUps %08x:\tDecrementConnectionCountL(), aCallersNodeId = %08x, iServiceId = %d"), this, &aCallersNodeId, iServiceId);		

	iNetUps->DecrementConnectionCountL(iServiceId, aCallersNodeId);

	}

EXPORT_C void CNetUps::DecrementConnectionCountL(const Messages::TNodeId&  aCallersNodeId, TProcessId& aProcessId, TThreadId& aThreadId)

	{

	__FLOG_5(_L("CNetUps %08x:\tDecrementConnectionCount1L(), aCallersNodeId = %08x, iServiceId = %d, process id = %d, thread id = %d,"), this, &aCallersNodeId, iServiceId, aProcessId.Id(), aThreadId.Id());		

	iNetUps->DecrementConnectionCountL(iServiceId, aCallersNodeId, aProcessId, aThreadId);

	}

} // end of namespace