diff -r 000000000000 -r af10295192d8 networkcontrol/commsuserpromptmgr/interface/src/netups.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/networkcontrol/commsuserpromptmgr/interface/src/netups.cpp Tue Jan 26 15:23:49 2010 +0200 @@ -0,0 +1,213 @@ +// 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 // defines DLL TLS +#include // defines standard error codes +#include // 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(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(const_cast(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(Dll::Tls()); + delete netUpsTls; + Dll::SetTls( static_cast(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 +