diff -r 000000000000 -r af10295192d8 networkcontrol/commsuserpromptmgr/interface/src/netupsimpl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/networkcontrol/commsuserpromptmgr/interface/src/netupsimpl.cpp Tue Jan 26 15:23:49 2010 +0200 @@ -0,0 +1,644 @@ +// 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 CNetUpsImpl +// @internalAll +// @prototype +// +// + +#include // defines User +#include // defines RPointerArray +#include // defines ASSERT +#include // defines cleanup stack + +#include "netupsassert.h" // defines Net Ups Asserts + +#include "netupsimpl.h" + +#include "netupsdatabaseentry.h" // defines the generic NET UPS database +#include "netupsthreadentry.h" // defines the NET UPS database thread entry +#include "netupssubsession.h" // defines the NET UPS Subsession +#include "netupsstatemachine.h" // defines generic NET UPS state machine +#include "netupsstatedef.h" // defines internal UPS States +#include "netupspolicycheckrequestqueue.h" // defines the policy check request queue +#include "netupskeys.h" // defines the keys which access an entry in the Net UPS database + +#include // defines the comms debug logging utility + +using namespace UserPromptService; +using namespace ESock; + +namespace NetUps +{ +__FLOG_STMT(_LIT8(KNetUpsSubsys, "esock");) +__FLOG_STMT(_LIT8(KNetUpsComponent, "NetUps");) /*esockloader*/ + +CNetUpsImpl* CNetUpsImpl::NewL() + { + CNetUpsImpl* self = new (ELeave) CNetUpsImpl; + + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + + return self; + } + +CNetUpsImpl::CNetUpsImpl() : iLifeTimeMode(EProcessLifeTimeMode), iRefCount(0) //, iRequestId(0) + { + } + +void CNetUpsImpl::ConstructL() + { + TInt rc = iUpsSession.Connect(); + (void) User::LeaveIfError(rc); + + __FLOG_OPEN(KNetUpsSubsys, KNetUpsComponent); + __FLOG_1(_L("CNetUpsImpl %08x:\tConstructL()"), this); + } + +CNetUpsImpl::~CNetUpsImpl() + { + __FLOG_1(_L("CNetUpsImpl %08x:\t~CNetUpsImpl()"), this); + + for (TInt i = iDatabaseEntry.Count() - 1; i >= 0; --i) + { + delete iDatabaseEntry[i]; + } + iDatabaseEntry.Reset(); + iDatabaseEntry.Close(); + + for (TInt j = iStateMachine.Count() - 1; j >= 0; --j) + { + delete iStateMachine[j]; + } + iStateMachine.Reset(); + iStateMachine.Close(); + + iUpsSession.Close(); + + __FLOG_CLOSE; + } + +void CNetUpsImpl::SetLifeTimeMode(TLifeTimeMode aLifeTimeMode) + { + __FLOG_2(_L("CNetUpsImpl %08x:\tSetLifeTimeMode(), aLifeTimeMode = %d"), this, aLifeTimeMode); + iLifeTimeMode = aLifeTimeMode; + } + +CNetUpsImpl::TLifeTimeMode CNetUpsImpl::LifeTimeMode() + { + return iLifeTimeMode; + } + +void CNetUpsImpl::ProcessPolicyCheckRequestL(const TPolicyCheckRequestData& aPolicyCheckRequestData, TRequestId& aRequestId) + { + __FLOG_1(_L("CNetUpsImpl %08x:\tProcessPolicyCheckRequestL()"), this); + + CUpsStateMachine& upsStateMachine = IdentifyStateMachineL(aPolicyCheckRequestData.iServiceId); + + CDatabaseEntry* databaseEntry = NULL; + CProcessEntry* processEntry = NULL; + CThreadEntry* threadEntry = NULL; + + IdentifyDatabaseEntryL(aPolicyCheckRequestData, databaseEntry, processEntry, threadEntry); + __FLOG_1(_L("\tdatabaseEntry = %08x"), databaseEntry); + __ASSERT_DEBUG((databaseEntry != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsSimpl)); + __FLOG_1(_L("\tprocessEntry = %08x"), processEntry); + __ASSERT_DEBUG((processEntry != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsSimpl1)); + // threadEntry will be NULL if in process lifetime. + + aRequestId = AllocateRequestId(); + + TNetUpsState netUpsState = processEntry->NetUpsState(); + if (MapInternalStateToSessionMode(netUpsState) == ESessionMode) + { + // Already in Session Yes or Session No, no need to query UPS Server + TNetUpsDecision netUpsDecision = ESessionNo; + DetermineUpsDecision(netUpsState, netUpsDecision); + if ((netUpsDecision == ESessionYes) && (iLifeTimeMode == ENetworkLifeTimeMode)) + { + threadEntry->IncrementConnectionCountL(aPolicyCheckRequestData.iCommsId); + } + + TInt rc = aPolicyCheckRequestData.iPolicyCheckRequestOriginator.ProcessPolicyCheckResponse(netUpsDecision, aPolicyCheckRequestData.iCommsId); + __FLOG_2(_L("CNetUpsImpl %08x:\tProcessPolicyCheckRequestL(), error = %d"), this , rc ); + } + else + { + __FLOG_1(_L("\tthreadEntry = %08x"), threadEntry); + __ASSERT_DEBUG((threadEntry != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsSimpl2)); + TThreadKey threadKey(*databaseEntry, *processEntry, *threadEntry); + upsStateMachine.ProcessPolicyCheckRequestL(threadKey, aPolicyCheckRequestData, aRequestId); + } + } + + +TInt CNetUpsImpl::CancelRequest(TInt32 aServiceId, const Messages::TNodeId& aCallersNodeId, const TRequestId& aRequestId) + { +// __FLOG_4(_L("CNetUpsImpl %08x:\tCancelRequest(), aServiceId = %d, aCallersNodeId = %08x, requestId = %d"), this, aServiceId, aCallersNodeId, aRequestId); + __FLOG_3(_L("CNetUpsImpl %08x:\tCancelRequest(), aServiceId = %d, requestId = %d"), this, aServiceId, aRequestId); + + + CThreadEntry* threadEntry = NULL; + TInt rc = IdentifyDatabaseEntry(aServiceId, aCallersNodeId, threadEntry); + + if ((rc == KErrNone) && (threadEntry->SubSession()->IsActive())) + { + rc = threadEntry->RequestQueue().CancelRequest(aCallersNodeId, aRequestId); + } + + return rc; + } + +CUpsStateMachine& CNetUpsImpl::IdentifyStateMachineL(TInt32 aServiceId) + { + __FLOG_2(_L("CNetUpsImpl %08x:\tIdentifyStateMachineL(), aServiceId = %d"), this, aServiceId); + CUpsStateMachine* upsStateMachine = NULL; + const TInt count = iStateMachine.Count(); + for (TInt i = 0; i < count; ++i) + { + const TInt32 serviceId = iStateMachine[i]->ServiceId(); + if (serviceId == aServiceId) + { + upsStateMachine = iStateMachine[i]; + break; + } + } + + if (upsStateMachine == NULL) + { + upsStateMachine = CUpsStateMachine::NewL(*this, aServiceId); + CleanupStack::PushL(upsStateMachine); + iStateMachine.AppendL(upsStateMachine); + CleanupStack::Pop(upsStateMachine); + } + return *upsStateMachine; + } + +void CNetUpsImpl::IdentifyDatabaseEntryL(const TPolicyCheckRequestData& aPolicyCheckRequestData, CDatabaseEntry*& aDatabaseEntry, CProcessEntry*& aProcessEntry, CThreadEntry*& aThreadEntry) +/** Searches the database to locate the entities associated with the policy check request. If the entities +are not found then they are instantiated. + +@param aPolicyCheckRequestData The policy check request which represents the search key. +@param aDatabaseEntry An output parameter which contains a pointer to the database entry associated with the search key. It must be NULL on entry to this method. +@param aProcessEntry An output parameter which contains a pointer to the process entry associated with the search key. It must be NULL on entry to this method. +@param aThreadEntry An output parameter which contains a pointer to the threadEntry associated with the search key, or NULL if there is no associated threadEntry. + The latter is applicable when the processEntry is in process life time mode. + This parameter must be NULL on entry to this method. +*/ + { + __FLOG_4(_L("CNetUpsImpl %08x:\tIdentifyDatabaseEntriesL(), aDatabaseEntry = %08x, aProcessEntry= %08x, aThreadEntry = %08x"), this, aDatabaseEntry, aProcessEntry, aThreadEntry); + + TBool serviceIdFound; + TBool processEntryFound; + TBool threadEntryFound; + serviceIdFound = EFalse; + processEntryFound = EFalse; + threadEntryFound = EFalse; + TBool threadEntryRequired = ETrue; // if ETrue, thread entry must be present, otherwise must be created + + __ASSERT_DEBUG((aDatabaseEntry == NULL), User::Panic(KNetUpsPanic, KPanicNonNullPointerToBeOverwritten)); + __ASSERT_DEBUG((aProcessEntry == NULL), User::Panic(KNetUpsPanic, KPanicNonNullPointerToBeOverwritten)); + __ASSERT_DEBUG((aThreadEntry == NULL), User::Panic(KNetUpsPanic, KPanicNonNullPointerToBeOverwritten)); + + const TInt32 databaseEntryCount = iDatabaseEntry.Count(); + for (TInt i = 0; i < databaseEntryCount; ++i) + { + __ASSERT_DEBUG((iDatabaseEntry[i] != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsSimpl3)); + if (iDatabaseEntry[i]->ServiceId() == aPolicyCheckRequestData.iServiceId) + { + serviceIdFound = ETrue; + + aDatabaseEntry = iDatabaseEntry[i]; + __ASSERT_DEBUG((aDatabaseEntry != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsSimpl4)); + + __FLOG_2(_L("\ti = %d, databaseEntry = %08x"), i, aDatabaseEntry); + const TInt32 processEntryCount = aDatabaseEntry->ProcessEntry().Count(); + for (TInt j = 0; (j < processEntryCount && threadEntryFound == EFalse); ++j) + { + aProcessEntry = (aDatabaseEntry->ProcessEntry())[j]; + __FLOG_2(_L("\tj= %d, processEntry = %08x"), j, aProcessEntry); + __ASSERT_DEBUG((aProcessEntry != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsSimpl5)); + if (aProcessEntry->ProcessId() == aPolicyCheckRequestData.iProcessId) + { + processEntryFound = ETrue; + if ((MapInternalStateToSessionMode(aProcessEntry->NetUpsState()) == ENonSessionMode) || + (iLifeTimeMode == ENetworkLifeTimeMode)) + { + const TInt32 threadEntryCount = aProcessEntry->ThreadEntry().Count(); + for(TInt k = 0; k < threadEntryCount; ++k) + { + aThreadEntry = (aProcessEntry->ThreadEntry())[k]; + __FLOG_2(_L("\tk = %d, threadEntry = %08x"), k, aThreadEntry); + __ASSERT_DEBUG((aThreadEntry != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsSimpl6)); + if (aThreadEntry->ThreadId() == aPolicyCheckRequestData.iThreadId) + { + threadEntryFound = ETrue; + break; + } + } + } + else + { + threadEntryRequired = EFalse; + break; + } + + } + } + } + } + + if (serviceIdFound == EFalse) + { + aDatabaseEntry = CDatabaseEntry::NewL(aPolicyCheckRequestData.iServiceId); + CleanupStack::PushL(aDatabaseEntry); + __FLOG_2(_L("CNetUpsImpl %08x:\tIdentifyDatabaseEntriesL() databaseEntry = %08x"), this, aDatabaseEntry); + iDatabaseEntry.AppendL(aDatabaseEntry); + CleanupStack::Pop(aDatabaseEntry); + } + + if (processEntryFound == EFalse) + { + CUpsStateMachine& stateMachine = IdentifyStateMachineL(aPolicyCheckRequestData.iServiceId); + + + CProcessEntry* processEntry = CProcessEntry::NewL(*aDatabaseEntry, aPolicyCheckRequestData.iProcessId, stateMachine ); + CleanupStack::PushL(processEntry); + __FLOG_2(_L("CNetUpsImpl %08x:\tIdentifyDatabaseEntriesL() processEntry = %08x"), this, processEntry); + aDatabaseEntry->ProcessEntry().AppendL(processEntry); + CleanupStack::Pop(processEntry); + aProcessEntry = processEntry; + } + + if ((threadEntryFound == EFalse) && (threadEntryRequired != EFalse)) + { + CThreadEntry* threadEntry = CThreadEntry::NewL(*aDatabaseEntry, *aProcessEntry, aPolicyCheckRequestData.iThreadId, iUpsSession); + CleanupStack::PushL(threadEntry); + __FLOG_2(_L("CNetUpsImpl %08x:\tIdentifyDatabaseEntriesL() threadEntry = %08x"), this, threadEntry); + aProcessEntry->ThreadEntry().AppendL(threadEntry); + CleanupStack::Pop(threadEntry); + aThreadEntry = threadEntry; + } + + // By this point, databaseEntry and processEntry should be assigned to a Non NULL value + __ASSERT_DEBUG((aDatabaseEntry != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsSimpl7)); + __ASSERT_DEBUG((aProcessEntry != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsSimpl8)); + } + +TInt CNetUpsImpl::IdentifyDatabaseEntry(TInt32 aServiceId, const Messages::TNodeId& aCallersNodeId, CThreadEntry*& aThreadEntry) +/** Searches the database to locate the thread entry corresponding to the Service Id and CommsId specified. +@param aServiceId A Service Id which forms the 1st part of the query key. +@param aCommsId A Comms Id which forms the 2nd part of the query key. +@param aThreadEntry An output parameter which contains a pointer to the thread entry associated with the search key. The Client must initialise this parameter to NULL to indicate that the referenced memory is unassigned. +*/ + { + //__FLOG_4(_L("CNetUpsImpl %08x:\tIdentifyDatabaseEntry(), aServiceId = %d, aCallersNodeId = %08x, aThreadEntry = %08x"), this, aServiceId, aCallersNodeId, aThreadEntry); + __FLOG_3(_L("CNetUpsImpl %08x:\tIdentifyDatabaseEntry(), aServiceId = %d, aThreadEntry = %08x"), this, aServiceId, aThreadEntry); + + + CDatabaseEntry* databaseEntry = NULL; + CProcessEntry* processEntry = NULL; + TInt32 rc = IdentifyDatabaseEntry(aServiceId, aCallersNodeId, databaseEntry, processEntry, aThreadEntry); + + if ((rc == KErrNone) && (aThreadEntry == NULL)) // the previous function will identify the databaseEntry and + // processEntry but not a threadEntry if the processEntry + // is in process session life time mode. + { + rc = KErrNotFound; + } + + return rc; + } + +TInt CNetUpsImpl::IdentifyDatabaseEntry(TInt32 aServiceId, const Messages::TNodeId& aCommsId, CDatabaseEntry*& aDatabaseEntry, CProcessEntry*& aProcessEntry, CThreadEntry*& aThreadEntry) +/** Searches the database to locate the entities corresponding to the Service Id and CommsId specified. + + + +@param aServiceId A Service Id which forms the 1st part of the query key. +@param aCommsId A Comms Id which forms the 2nd part of the query key. +@param aDatabaseEntry An output parameter which contains a pointer to the database entry associated with the search key. The Client must initialise this parameter to NULL to indicate that the referenced memory is unassigned. +@param aProcessEntry An output parameter which contains a pointer to the process entry associated with the search key. The Client must initialise this parameter to NULL to indicate that the referenced memory is unassigned. +@param aThreadEntry An output parameter which contains a pointer to the thread entry associated with the search key. The Client must initialise this parameter to NULL to indicate that the referenced memory is unassigned. + This argument will remain NULL if the threadEntry does not exist. +*/ + { + //__FLOG_6(_L("CNetUpsImpl %08x\t IdentifyDatabaseEntriesL(), aServiceId, aCommsId, aDatabaseEntry = %d,\t aProcessEntry= %d,\t aThreadEntry = %d"), this, aServiceId, aCommsId, aDatabaseEntry, aProcessEntry, aThreadEntry); + __FLOG_5(_L("CNetUpsImpl %08x\t IdentifyDatabaseEntriesL(), aServiceId, aCommsId, aDatabaseEntry = %d,\t aProcessEntry= %d,\t aThreadEntry = %d"), this, aServiceId, aDatabaseEntry, aProcessEntry, aThreadEntry); + + __ASSERT_DEBUG((aDatabaseEntry == NULL), User::Panic(KNetUpsPanic, KPanicNonNullPointerToBeOverwritten)); + __ASSERT_DEBUG((aProcessEntry == NULL), User::Panic(KNetUpsPanic, KPanicNonNullPointerToBeOverwritten)); + __ASSERT_DEBUG((aThreadEntry == NULL), User::Panic(KNetUpsPanic, KPanicNonNullPointerToBeOverwritten)); + + TInt rc = KErrNotFound; + + const TInt32 databaseEntryCount = iDatabaseEntry.Count(); + for (TInt i = 0; ((i < databaseEntryCount) && (rc == KErrNotFound)); ++i) + { + __ASSERT_DEBUG((iDatabaseEntry[i] != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsSimpl9)); + if (aServiceId == iDatabaseEntry[i]->ServiceId()) + { + CDatabaseEntry* databaseEntry = iDatabaseEntry[i]; + __FLOG_2(_L("\ti = %d, databaseEntry = %08x"), i, databaseEntry); + const TInt32 processEntryCount = databaseEntry->ProcessEntry().Count(); + for (TInt j = 0; ((j < processEntryCount) && (rc == KErrNotFound)); ++j) + { + CProcessEntry* processEntry = (databaseEntry->ProcessEntry())[j]; + __FLOG_2(_L("\tj = %d, processEntry = %08x"), j, processEntry); + __ASSERT_DEBUG((processEntry != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsSimpl10)); + aDatabaseEntry = databaseEntry; + aProcessEntry = processEntry; + + + const TInt32 threadEntryCount = processEntry->ThreadEntry().Count(); + for(TInt32 k = 0; ((k < threadEntryCount) && (rc == KErrNotFound)); ++k) + { + CThreadEntry* threadEntry = (processEntry->ThreadEntry())[k]; + __FLOG_2(_L("\tk = %d, threadEntry = %08x"), k, threadEntry); + __ASSERT_DEBUG((threadEntry != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsSimpl11)); + const TInt32 commsIdCount = threadEntry->ConnectionEntry().Count(); + for(TInt32 l = 0; l < commsIdCount; ++l) + { + const Messages::TNodeId& commsId = (threadEntry->ConnectionEntry())[l]->CommsId(); + //__FLOG_2(_L("CNetUpsImpl\t i = %d, commsId = %d"), i, commsId.Printable()); + __FLOG_1(_L("\tl = %d"), l); + + if (commsId == aCommsId) + { + aThreadEntry = threadEntry; + rc = KErrNone; + break; + } + } + } + } + } + } + + return rc; + } + +void CNetUpsImpl::IncrementConnectionCountL(TInt32 aServiceId, const Messages::TNodeId& aCallersNodeId) + { + //__FLOG_3(_L("CNetUpsImpl %08x:\tIncrementConnectionCountL(), aServiceId = %d, aCallersNodeId = %08x"), this, aServiceId, aCallersNodeId); + __FLOG_2(_L("CNetUpsImpl %08x:\tIncrementConnectionCountL(), aServiceId = %d"), this, aServiceId); + + if (iLifeTimeMode != EProcessLifeTimeMode) + { + CThreadEntry* threadEntry = NULL; + TInt rc = IdentifyDatabaseEntry(aServiceId, aCallersNodeId, threadEntry); + + if (rc == KErrNone) + { + threadEntry->IncrementConnectionCountL(aCallersNodeId); + } + + User::LeaveIfError(rc); + } + } + +void CNetUpsImpl::DecrementConnectionCountL(TInt32 aServiceId, const Messages::TNodeId& aCallersNodeId) + { + //__FLOG_3(_L("CNetUpsImpl %08x:\tDecrementConnectionCountL(), aServiceId = %d, aCallersNodeId = %08x"), this, aServiceId, aCallersNodeId); + __FLOG_2(_L("CNetUpsImpl %08x:\tDecrementConnectionCountL(), aServiceId = %d"), this, aServiceId); + + if (iLifeTimeMode != EProcessLifeTimeMode) + { + CUpsStateMachine& upsStateMachine = IdentifyStateMachineL(aServiceId); + + CDatabaseEntry* databaseEntry = NULL; + CProcessEntry* processEntry = NULL; + CThreadEntry* threadEntry = NULL; + + TInt rc = IdentifyDatabaseEntry(aServiceId, aCallersNodeId, databaseEntry, processEntry, threadEntry); + if (rc == KErrNone) + { + __ASSERT_DEBUG((databaseEntry != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsSimpl12)); + __ASSERT_DEBUG((processEntry != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsSimpl13)); + + if (threadEntry != NULL) + { + TCommsIdKey commsIdKey(*databaseEntry, *processEntry, *threadEntry, aCallersNodeId); + upsStateMachine.DecrementConnectionCountL(commsIdKey); + } + else + { + User::Leave(KErrNotSupported); + } + + } + } + } + +void CNetUpsImpl::DecrementConnectionCountL(TInt32 aServiceId, const Messages::TNodeId& aCallersNodeId, TProcessId& aProcessId, TThreadId& aThreadId) + { + if (iLifeTimeMode != EProcessLifeTimeMode) + { + CUpsStateMachine& upsStateMachine = IdentifyStateMachineL(aServiceId); + + CDatabaseEntry* databaseEntry = NULL; + CProcessEntry* processEntry = NULL; + CThreadEntry* threadEntry = NULL; + + TInt rc = IdentifyDatabaseEntry(aServiceId, aCallersNodeId, aProcessId, aThreadId, databaseEntry, processEntry, threadEntry); + if (rc == KErrNone) + { + __ASSERT_DEBUG((databaseEntry != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsSimpl14)); + __ASSERT_DEBUG((processEntry != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsSimpl15)); + + if (threadEntry != NULL) + { + TCommsIdKey commsIdKey(*databaseEntry, *processEntry, *threadEntry, aCallersNodeId); + upsStateMachine.DecrementConnectionCountL(commsIdKey); + } + else + { + User::Leave(KErrNotSupported); + } + + } + } + } + +TInt CNetUpsImpl::IdentifyDatabaseEntry(TInt32 aServiceId, const Messages::TNodeId& aCallersNodeId, TProcessId& aProcessId, TThreadId& aThreadId, CDatabaseEntry*& aDatabaseEntry, CProcessEntry*& aProcessEntry, CThreadEntry*& aThreadEntry) + { + TBool serviceIdFound; + TBool processEntryFound; + TBool threadEntryFound; + serviceIdFound = EFalse; + processEntryFound = EFalse; + threadEntryFound = EFalse; + TInt rc = KErrNotFound; + + __ASSERT_DEBUG((aDatabaseEntry == NULL), User::Panic(KNetUpsPanic, KPanicNonNullPointerToBeOverwritten)); + __ASSERT_DEBUG((aProcessEntry == NULL), User::Panic(KNetUpsPanic, KPanicNonNullPointerToBeOverwritten)); + __ASSERT_DEBUG((aThreadEntry == NULL), User::Panic(KNetUpsPanic, KPanicNonNullPointerToBeOverwritten)); + + const TInt32 databaseEntryCount = iDatabaseEntry.Count(); + for (TInt i = 0; (i < databaseEntryCount && serviceIdFound == EFalse); ++i) + { + __ASSERT_DEBUG((iDatabaseEntry[i] != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsSimpl16)); + if (iDatabaseEntry[i]->ServiceId() == aServiceId) + { + serviceIdFound = ETrue; + + aDatabaseEntry = iDatabaseEntry[i]; + __ASSERT_DEBUG((aDatabaseEntry != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsSimpl17)); + + __FLOG_2(_L("\ti = %d, databaseEntry = %08x"), i, aDatabaseEntry); + const TInt32 processEntryCount = aDatabaseEntry->ProcessEntry().Count(); + for (TInt j = 0; (j < processEntryCount && processEntryFound == EFalse); ++j) + { + aProcessEntry = (aDatabaseEntry->ProcessEntry())[j]; + __FLOG_2(_L("\tj= %d, processEntry = %08x"), j, aProcessEntry); + __ASSERT_DEBUG((aProcessEntry != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsSimpl18)); + if (aProcessEntry->ProcessId() == aProcessId) + { + processEntryFound = ETrue; + if ((MapInternalStateToSessionMode(aProcessEntry->NetUpsState()) == ENonSessionMode) || + (iLifeTimeMode == ENetworkLifeTimeMode)) + { + const TInt32 threadEntryCount = aProcessEntry->ThreadEntry().Count(); + for(TInt k = 0; (k < threadEntryCount && threadEntryFound == EFalse); ++k) + { + aThreadEntry = (aProcessEntry->ThreadEntry())[k]; + __FLOG_2(_L("\tk = %d, threadEntry = %08x"), k, aThreadEntry); + __ASSERT_DEBUG((aThreadEntry != NULL), User::Panic(KNetUpsPanic, KPanicNullPointer_NetUpsSimpl19)); + if (aThreadEntry->ThreadId() == aThreadId) + { + threadEntryFound = ETrue; + + const TInt32 commsIdCount = aThreadEntry->ConnectionEntry().Count(); + for(TInt32 l = 0; l < commsIdCount; ++l) + { + const Messages::TNodeId& commsId = (aThreadEntry->ConnectionEntry())[l]->CommsId(); + //__FLOG_2(_L("CNetUpsImpl\t i = %d, commsId = %d"), i, commsId.Printable()); + __FLOG_1(_L("\tl = %d"), l); + + if (commsId == aCallersNodeId) + { + rc = KErrNone; + break; + } + } + } + } + } + } + } + } + } + + return rc; + } + +CNetUpsImpl::TSessionMode CNetUpsImpl::MapInternalStateToSessionMode(TNetUpsState aNetUpsState) + { + __FLOG_STATIC1(KNetUpsSubsys, KNetUpsComponent,_L("CNetUpsImpl::MapInternalStateToSessionMode(), aNetUpsState = %d"), aNetUpsState); + + __ASSERT_DEBUG( (aNetUpsState == ENull) || + ((aNetUpsState >= EProcLife_NonSession) && (aNetUpsState <= EProcLife_SessionNo)) || + ((aNetUpsState >= ENetLife_NonSession) && (aNetUpsState <= ENetLife_SessionYes)) , + User::Panic(KNetUpsPanic, KPanicInvalidState)); + + TSessionMode rc = ENonSessionMode; + + switch(aNetUpsState) + { + case EProcLife_Transit_SessionYes: + case EProcLife_Transit_SessionNo: + case EProcLife_SessionYes: + case EProcLife_SessionNo: + case ENetLife_SessionNo_Transit_WithoutConnections: + case ENetLife_SessionNo_WithOutConnections: + case ENetLife_SessionNo_Transit_WithConnections: + case ENetLife_SessionNo_WithConnections: + case ENetLife_Transit_SessionYes: + case ENetLife_SessionYes: + rc = ESessionMode; + break; + case ENull: + case EProcLife_NonSession: + case ENetLife_NonSession: + break; + default: + User::Panic(KNetUpsPanic, KPanicUnhandledState); + break; + } + + + return rc; + } + +void CNetUpsImpl::DetermineUpsDecision(TNetUpsState aNetUpsState, TNetUpsDecision& aNetUpsDecision) + { + __FLOG_STATIC1(KNetUpsSubsys, KNetUpsComponent,_L("CNetUpsImpl::DetermineUpsDecision, aNetUpsState = %d"), aNetUpsState); + + __ASSERT_DEBUG( (aNetUpsState == ENull) || + ((aNetUpsState >= EProcLife_NonSession) && (aNetUpsState <= EProcLife_SessionNo)) || + ((aNetUpsState >= ENetLife_NonSession) && (aNetUpsState <= ENetLife_SessionYes)) , + User::Panic(KNetUpsPanic, KPanicInvalidState)); + + switch(aNetUpsState) + { + case EProcLife_Transit_SessionYes: + case EProcLife_SessionYes: + case ENetLife_Transit_SessionYes: + case ENetLife_SessionYes: + aNetUpsDecision = ESessionYes; + break; + case EProcLife_Transit_SessionNo: + case EProcLife_SessionNo: + case ENetLife_SessionNo_Transit_WithoutConnections: + case ENetLife_SessionNo_WithOutConnections: + case ENetLife_SessionNo_Transit_WithConnections: + case ENetLife_SessionNo_WithConnections: + aNetUpsDecision = ESessionNo; + break; + default: + User::Panic(KNetUpsPanic, KPanicUnhandledState); + break; + } + + __FLOG_STATIC1(KNetUpsSubsys, KNetUpsComponent,_L("aNetUpsDecision = %d"), aNetUpsDecision); + } + +void CNetUpsImpl::IncrementRefCount(void) + { + ++iRefCount; + __FLOG_2(_L("CNetUpsImpl %08x:\tIncrementRefCount(), iRefCount = %d"), this, iRefCount); + } + +void CNetUpsImpl::DecrementRefCount(void) + { + if (--iRefCount < 0) + { + User::Panic(KNetUpsPanic, KPanicAttemptToDecrementPastZero); + } + __FLOG_2(_L("CNetUpsImpl %08x:\tDecrementRefCount(), iRefCount = %d"), this, iRefCount); + } + +TInt32 CNetUpsImpl::RefCount(void) + { + return iRefCount; + } + +TRequestId CNetUpsImpl::AllocateRequestId() + { + return ++iRequestId; + } + +} // end of namespace