// ---------------------------------------------------------
// CActiveDisconnectDlgPlugin::IsConnectionL
// ---------------------------------------------------------
//
TBool CActiveDisconnectDlgPlugin::IsConnectionL(
CConnectionInfo* aConnectionInfo )
{
CLOG_ENTERFN( "CActiveDisconnectDlgPlugin::IsConnectionL" );
TBool result( EFalse );
TUint i( 0 );
TUint connectionCount( 0 );
TUint connNum( 0 );
TUint subConnectionCount( 0 );
TUint connId( 0 );
TInt bearer( 0 );
TInt connStatus( 0 );
//TRequestStatus status;
TName apName;
RConnectionMonitor connMon;
result = connMon.ConnectL();
CLOG_WRITEF( _L( "result: %d" ), result );
CDisconnectDlgActiveWaiter* waiter = CDisconnectDlgActiveWaiter::NewL();
CleanupStack::PushL( waiter );
connMon.GetConnectionCount( connNum, waiter->iStatus );
waiter->WaitForRequest();
//User::WaitForRequest( status );
CLOG_WRITEF( _L( "status: %d" ), waiter->iStatus.Int() );
CLOG_WRITEF( _L( "connNum: %d" ), connNum );
for( i = 1; i < ( connNum + 1 ) && !connectionCount; ++i )
{
connMon.GetConnectionInfo( i, connId, subConnectionCount );
connMon.GetStringAttribute( connId, 0, KIAPName, apName, waiter->iStatus );
waiter->WaitForRequest();
//User::WaitForRequest( status );
CLOG_WRITEF( _L( "KIAPName status: %d" ), waiter->iStatus.Int() );
connMon.GetIntAttribute( connId, 0, KBearer, bearer, waiter->iStatus );
waiter->WaitForRequest();
//User::WaitForRequest( status );
CLOG_WRITEF( _L( "KBearer status: %d" ), waiter->iStatus.Int() );
connMon.GetIntAttribute( connId, 0, KConnectionStatus, connStatus,
waiter->iStatus );
waiter->WaitForRequest();
//User::WaitForRequest( status );
CLOG_WRITEF( _L( "KConnectionStatus status: %d" ), waiter->iStatus.Int() );
TUint iapId( 0 );
connMon.GetUintAttribute( connId, 0, KIAPId, iapId, waiter->iStatus );
waiter->WaitForRequest();
//User::WaitForRequest( status );
CLOG_WRITEF(_L( "KIAPId status: %d" ), waiter->iStatus.Int() );
CLOG_WRITEF(_L( "iapId: %d" ), iapId );
TConnMonTimeBuf timeBuf;
connMon.GetPckgAttribute( connId, 0, KStartTime, timeBuf, waiter->iStatus );
waiter->WaitForRequest();
CLOG_WRITEF(_L( "KStartTime status: %d" ), waiter->iStatus.Int() );
switch( bearer )
{
case EBearerGPRS :
case EBearerEdgeGPRS :
case EBearerExternalGPRS :
case EBearerExternalEdgeGPRS :
case EBearerWCDMA :
case EBearerExternalWCDMA :
#ifdef __WINS__
case EBearerLAN :
#endif // WINS
{
if ( ( connStatus == KLinkLayerOpen ) ||
( connStatus == KConnectionOpen &&
bearer >= EBearerExternalCSD ) )
{
apName.Trim();
if( apName.Left( KMrouterName().Length() ).
CompareF( KMrouterName ) )
{
++connectionCount;
aConnectionInfo->SetIapNameL( apName );
aConnectionInfo->SetBearerType( bearer );
aConnectionInfo->SetConnId( connId );
aConnectionInfo->SetIAPId( iapId );
aConnectionInfo->SetStartTime( timeBuf() );
TConnMonClientEnumBuf clientEnum;
connMon.GetPckgAttribute( connId, 0, KClientInfo,
clientEnum, waiter->iStatus );
waiter->WaitForRequest();
//User::WaitForRequest( status );
aConnectionInfo->SetClientInfo( clientEnum() );
CLOG_WRITEF( _L( "KClientInfo status: %d" ), waiter->iStatus.Int() );
}
}
break;
}
default :
{
break;
}
}
}
CleanupStack::PopAndDestroy( waiter );
connMon.Close();
result = connectionCount ? ETrue : EFalse;
CLOG_WRITEF( _L( "connectionCount: %d" ), connectionCount );
CLOG_WRITEF( _L( "result: %d" ), result );
CLOG_LEAVEFN( "CActiveDisconnectDlgPlugin::IsConnectionL" );
return result;
}
TMemSpyDriverChunkType DMemSpyDriverLogChanChunks::IdentifyChunkType( DChunk& aChunk )
{
TRACE( Kern::Printf("DMemSpyDriverLogChanChunks::IdentifyChunkType() - START" ) );
TMemSpyDriverChunkType ret = EMemSpyDriverChunkTypeUnknown;
TName name;
aChunk.Name( name );
TRACE( Kern::Printf("DMemSpyDriverLogChanChunks::IdentifyChunkType() - name: %S", &name ) );
DMemSpyDriverOSAdaptionDChunk& chunkAdaption = OSAdaption().DChunk();
const TChunkType type = chunkAdaption.GetType( aChunk );
if ( name == KMemSpyLitDllDollarData )
{
// This chunk contains Dll Global Data for the process
TRACE( Kern::Printf("DMemSpyDriverLogChanChunks::IdentifyChunkType() - EMemSpyDriverChunkTypeGlobalData" ) );
ret = EMemSpyDriverChunkTypeGlobalData;
}
else if ( type == ERamDrive )
{
TRACE( Kern::Printf("DMemSpyDriverLogChanChunks::IdentifyChunkType() - EMemSpyDriverChunkTypeRamDrive" ) );
ret = EMemSpyDriverChunkTypeRamDrive;
}
else if ( type == EKernelStack )
{
TRACE( Kern::Printf("DMemSpyDriverLogChanChunks::IdentifyChunkType() - EMemSpyDriverChunkTypeStackKernel" ) );
ret = EMemSpyDriverChunkTypeStackKernel;
}
else if ( name == KMemSpyLitDollarDat )
{
// This chunk contains process global data as well as user-side stacks for
// the process.
TRACE( Kern::Printf("DMemSpyDriverLogChanChunks::IdentifyChunkType() - EMemSpyDriverChunkTypeStackAndProcessGlobalData" ) );
ret = EMemSpyDriverChunkTypeStackAndProcessGlobalData;
}
else if ( name == KMemSpyLitDollarGlobalCode && type == EDll )
{
// GLOBAL$CODE is used for RAM loaded code which is globally visible. This
// basically means locale DLLs - these must be visible to every process, even
// those which haven't loaded them.
TRACE( Kern::Printf("DMemSpyDriverLogChanChunks::IdentifyChunkType() - EMemSpyDriverChunkTypeCodeGlobal" ) );
ret = EMemSpyDriverChunkTypeCodeGlobal;
}
else if ( name == KMemSpyLitDollarCode || type == EKernelCode || type == EDll || type == EUserCode )
{
// RAM-loaded code, which on the multiple memory model at least means that the code chunk is eseentially just a mapping
// artifact. The RAM itself is owned by the code segment, therefore counting the size of these CODE elements may result
// in inaccurate results if the code is shared amongst multiple processes.
TRACE( Kern::Printf("DMemSpyDriverLogChanChunks::IdentifyChunkType() - EMemSpyDriverChunkTypeCode" ) );
ret = EMemSpyDriverChunkTypeCode;
}
else if ( type == EUserSelfModCode )
{
// Dynamically create code chunk
TRACE( Kern::Printf("DMemSpyDriverLogChanChunks::IdentifyChunkType() - EMemSpyDriverChunkTypeCodeSelfModifiable" ) );
ret = EMemSpyDriverChunkTypeCodeSelfModifiable;
}
else if ( IsHeapChunk( aChunk, name ) )
{
// Catch kernel heap too
if ( type == EKernelData )
{
TRACE( Kern::Printf("DMemSpyDriverLogChanChunks::IdentifyChunkType() - EMemSpyDriverChunkTypeHeapKernel" ) );
ret = EMemSpyDriverChunkTypeHeapKernel;
}
else
{
TRACE( Kern::Printf("DMemSpyDriverLogChanChunks::IdentifyChunkType() - EMemSpyDriverChunkTypeHeap" ) );
ret = EMemSpyDriverChunkTypeHeap;
}
}
else if ( type == EUserData && chunkAdaption.GetOwningProcess( aChunk ) == NULL )
{
// Global shared chunks match this pattern. Of course, we could check the memory model mapping attributes
// as that would give us the info in a heartbeat, but it's too specific.
TRACE( Kern::Printf("DMemSpyDriverLogChanChunks::IdentifyChunkType() - EMemSpyDriverChunkTypeGlobal" ) );
ret = EMemSpyDriverChunkTypeGlobal;
}
else if ( type == EUserData && chunkAdaption.GetOwner( aChunk ) != NULL && name.Length() > KMemSpyLitLocalObject().Length() && name.Left( KMemSpyLitLocalObject().Length() ) == KMemSpyLitLocalObject )
{
TRACE( Kern::Printf("DMemSpyDriverLogChanChunks::IdentifyChunkType() - EMemSpyDriverChunkTypeLocal" ) );
ret = EMemSpyDriverChunkTypeLocal;
}
else
{
TRACE( Kern::Printf("DMemSpyDriverLogChanChunks::IdentifyChunkType() - EMemSpyDriverChunkTypeUnknown" ) );
TRACE( PrintChunkInfo( aChunk ) );
ret = EMemSpyDriverChunkTypeUnknown;
}
return ret;
}
