diff -r 453dfc402455 -r 0aa8cc770c8a localconnectivityservice/dun/utils/src/DunTransUtils.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/localconnectivityservice/dun/utils/src/DunTransUtils.cpp Tue Aug 31 16:03:15 2010 +0300 @@ -0,0 +1,1077 @@ +/* +* Copyright (c) 2006-2010 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: Utility class for other CDunTransporter classes +* +*/ + + +#include +#include +#include "dundomainpskeys.h" +#include "DunTransUtils.h" +#include "DunDataWaiter.h" +#include "DunUpstream.h" +#include "DunDownstream.h" +#include "DunSignalCopy.h" +#include "DunSignalNotify.h" +#include "DunNoteHandler.h" +#include "DunUtils.h" +#include "DunDebug.h" + +// --------------------------------------------------------------------------- +// Two-phased constructor. +// --------------------------------------------------------------------------- +// +CDunTransUtils* CDunTransUtils::NewL( CDunTransporter& aParent, + MDunPluginManager* aPluginManager ) + { + CDunTransUtils* self = new (ELeave) CDunTransUtils( aParent, + aPluginManager ); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// Destructor. +// --------------------------------------------------------------------------- +// +CDunTransUtils::~CDunTransUtils() + { + FTRACE(FPrint( _L("CDunTransUtils::~CDunTransUtils()" ))); + FTRACE(FPrint( _L("CDunTransUtils::~CDunTransUtils() complete" ))); + } + +// --------------------------------------------------------------------------- +// CDunTransUtils::CDunTransUtils +// --------------------------------------------------------------------------- +// +CDunTransUtils::CDunTransUtils( CDunTransporter& aParent, + MDunPluginManager* aPluginManager ) : + iParent( aParent ), + iChannelData( aParent.iChannelData ), + iServAdvData( aParent.iServAdvData ), + iPluginManager( aPluginManager ) + { + } + +// --------------------------------------------------------------------------- +// CDunTransUtils::ConstructL +// --------------------------------------------------------------------------- +// +void CDunTransUtils::ConstructL() + { + FTRACE(FPrint( _L("CDunTransUtils::ConstructL()" ))); + if ( !iPluginManager ) + { + User::Leave( KErrGeneral ); + } + FTRACE(FPrint( _L("CDunTransUtils::ConstructL() complete" ))); + } + +// --------------------------------------------------------------------------- +// Manages service advertisement status changes +// --------------------------------------------------------------------------- +// +void CDunTransUtils::ManageAdvertisementStatusChange( TBool aAdvertise, + TBool aCreation ) + { + FTRACE(FPrint( _L("CDunTransUtils::ManageAdvertisementStatusChange()" ))); + TInt i; + TInt count; + iParent.iAdvertise = aAdvertise; + count = iServAdvData.Count(); + for ( i=0; iNotifyAdvertisementStart( aCreation ); + } + else + { + servAdvData.iServAdvMon->NotifyAdvertisementEnd(); + } + } + } + FTRACE(FPrint( _L("CDunTransUtils::ManageAdvertisementStatusChange() complete" ))); + } + +// --------------------------------------------------------------------------- +// Creates empty channel data +// --------------------------------------------------------------------------- +// +void CDunTransUtils::CreateEmptyChannelData( TDunChannelData& aChannel ) + { + FTRACE(FPrint( _L("CDunTransUtils::CreateEmptyChannelData()" ))); + aChannel.iNetwork = NULL; + aChannel.iComm = NULL; + aChannel.iSocket = NULL; + aChannel.iChannelName = NULL; + aChannel.iUpstreamRW = NULL; + aChannel.iDownstreamRW = NULL; + aChannel.iBufferUpstream = NULL; + aChannel.iBufferDownstream = NULL; + aChannel.iBufferUpPtr = NULL; + aChannel.iBufferDownPtr = NULL; + aChannel.iUpstreamSignalCopy = NULL; + aChannel.iDownstreamSignalCopy = NULL; + aChannel.iSignalNotify = NULL; + aChannel.iOwnerUid = TUid::Null(); + aChannel.iChannelInUse = EFalse; + FTRACE(FPrint( _L("CDunTransUtils::CreateEmptyChannelData() complete" ))); + } + +// --------------------------------------------------------------------------- +// Creates new buffer if source buffer defined, otherwise already existing +// buffer will be used +// --------------------------------------------------------------------------- +// +void CDunTransUtils::DoCreateBufferLC( TUint8* aSrcBuffer, + TPtr8* aSrcPtr, + TUint8*& aDstBuffer, + TPtr8*& aDstPtr, + TInt aBufferLength, + TInt& aItemsInCs ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoCreateBufferLC()" ))); + TUint8* buffer; + if ( !aSrcBuffer ) + { + buffer = new (ELeave) TUint8[aBufferLength]; + CleanupStack::PushL( buffer ); + aItemsInCs++; + FTRACE(FPrint( _L("CDunTransUtils::DoCreateBufferLC() new created" ))); + } + else + { + buffer = aSrcBuffer; + FTRACE(FPrint( _L("CDunTransUtils::DoCreateBufferLC() existing set" ))); + } + TPtr8* bufferPtr; + if ( !aSrcPtr ) + { + bufferPtr = new (ELeave) TPtr8( buffer, aBufferLength, aBufferLength ); + CleanupStack::PushL( bufferPtr ); + aItemsInCs++; + FTRACE(FPrint( _L("CDunTransUtils::DoCreateBufferLC() new created" ))); + } + else + { + bufferPtr = aSrcPtr; + FTRACE(FPrint( _L("CDunTransUtils::DoCreateBufferLC() existing set" ))); + } + aDstBuffer = buffer; + aDstPtr = bufferPtr; + FTRACE(FPrint( _L("CDunTransUtils::DoCreateBufferLC() complete" ))); + } + +// --------------------------------------------------------------------------- +// Creates new signal copy object if source defined, otherwise already +// existing will be used +// --------------------------------------------------------------------------- +// +void CDunTransUtils::DoCreateSignalCopyLC( CDunSignalCopy* aSrcSignalCopy, + CDunSignalCopy*& aDstSignalCopy, + TInt& aItemsInCs ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoCreateSignalCopyLC()" ))); + CDunSignalCopy* signalCopy; + if ( !aSrcSignalCopy ) + { + signalCopy = CDunSignalCopy::NewL(); + CleanupStack::PushL( signalCopy ); + aItemsInCs++; + FTRACE(FPrint( _L("CDunTransUtils::DoCreateSignalCopyLC() new created" ))); + } + else + { + signalCopy = aSrcSignalCopy; + FTRACE(FPrint( _L("CDunTransUtils::DoCreateSignalCopyLC() existing set" ))); + } + aDstSignalCopy = signalCopy; + FTRACE(FPrint( _L("CDunTransUtils::DoCreateSignalCopyLC() complete" ))); + } + +// --------------------------------------------------------------------------- +// Creates new signal notify object if source defined, otherwise already +// existing will be used +// --------------------------------------------------------------------------- +// +void CDunTransUtils::DoCreateSignalNotifyLC( + CDunSignalNotify* aSrcSignalNotify, + CDunSignalNotify*& aDstSignalNotify, + TInt& aItemsInCs ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoCreateSignalNotifyLC()" ))); + CDunSignalNotify* signalNotify; + if ( !aSrcSignalNotify ) + { + signalNotify = CDunSignalNotify::NewL( this ); + CleanupStack::PushL( signalNotify ); + aItemsInCs++; + FTRACE(FPrint( _L("CDunTransUtils::DoCreateSignalNotifyLC() new created" ))); + } + else + { + signalNotify = aSrcSignalNotify; + FTRACE(FPrint( _L("CDunTransUtils::DoCreateSignalNotifyLC() existing set" ))); + } + aDstSignalNotify = signalNotify; + FTRACE(FPrint( _L("CDunTransUtils::DoCreateSignalNotifyLC() complete" ))); + } + +// --------------------------------------------------------------------------- +// Creates transfer objects for reader and writer if sources defined, +// otherwise already existing ones will be used +// --------------------------------------------------------------------------- +// +void CDunTransUtils::DoCreateUpTransferObjectL( CDunUpstream* aSrcReader, + CDunUpstream*& aDstReader, + TInt& aItemsInCs ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoCreateUpTransferObjectL()" ))); + CDunUpstream* dunReader; + if ( !aSrcReader ) + { + dunReader = CDunUpstream::NewL( this ); + CleanupStack::PushL( dunReader ); + aItemsInCs++; + FTRACE(FPrint( _L("CDunTransUtils::DoCreateUpTransferObjectL() new created" ))); + } + else + { + dunReader = aSrcReader; + FTRACE(FPrint( _L("CDunTransUtils::DoCreateUpTransferObjectL() existing set" ))); + } + aDstReader = dunReader; + FTRACE(FPrint( _L("CDunTransUtils::DoCreateUpTransferObjectL() complete" ))); + } + +// --------------------------------------------------------------------------- +// Creates transfer objects for reader and writer if sources defined, +// otherwise already existing ones will be used +// --------------------------------------------------------------------------- +// +void CDunTransUtils::DoCreateDownTransferObjectL( CDunDownstream* aSrcReader, + CDunDownstream*& aDstReader, + TInt& aItemsInCs ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoCreateDownTransferObjectL()" ))); + CDunDownstream* dunReader; + if ( !aSrcReader ) + { + dunReader = CDunDownstream::NewL( this ); + CleanupStack::PushL( dunReader ); + aItemsInCs++; + FTRACE(FPrint( _L("CDunTransUtils::DoCreateDownTransferObjectL() new created" ))); + } + else + { + dunReader = aSrcReader; + FTRACE(FPrint( _L("CDunTransUtils::DoCreateDownTransferObjectL() existing set" ))); + } + aDstReader = dunReader; + FTRACE(FPrint( _L("CDunTransUtils::DoCreateDownTransferObjectL() complete" ))); + } + +// --------------------------------------------------------------------------- +// Resets/frees network data of aIndex:th channel +// --------------------------------------------------------------------------- +// +TInt CDunTransUtils::DeleteOneNetworkData( TInt aIndex ) + { + FTRACE(FPrint( _L("CDunTransUtils::DeleteOneNetworkData()" ))); + + if ( aIndex < 0 || + aIndex >= iChannelData.Count() ) + { + FTRACE(FPrint( _L("CDunTransUtils::DeleteOneNetworkData (not found) complete" ))); + return KErrNotFound; + } + + TDunChannelData& channelData = iChannelData[aIndex]; + if ( !channelData.iChannelInUse ) + { + FTRACE(FPrint( _L("CDunTransUtils::DeleteOneNetworkData() (channel not found) complete" ), aIndex)); + return KErrGeneral; + } + + // channelData.iDownstreamSignalCopy may or may not exist (optional) + // channelData.iSignalNotify may or may not exist (optional) + delete channelData.iDownstreamSignalCopy; + channelData.iDownstreamSignalCopy = NULL; + delete channelData.iSignalNotify; + channelData.iSignalNotify = NULL; + delete channelData.iDownstreamRW; + channelData.iDownstreamRW = NULL; + + FTRACE(FPrint( _L("CDunTransUtils::DeleteOneNetworkData complete()" ))); + return KErrNone; + } + +// --------------------------------------------------------------------------- +// Resets/frees network data of aIndex:th channel +// --------------------------------------------------------------------------- +// +TInt CDunTransUtils::DeleteOneLocalData( TInt aIndex ) + { + FTRACE(FPrint( _L("CDunTransUtils::DeleteOneLocalData()" ))); + + if ( aIndex < 0 || + aIndex >= iChannelData.Count() ) + { + FTRACE(FPrint( _L("CDunTransUtils::DeleteOneLocalData() (not found) complete" ))); + return KErrNotFound; + } + + TDunChannelData& channelData = iChannelData[aIndex]; + if ( !channelData.iChannelInUse ) + { + FTRACE(FPrint( _L("CDunTransUtils::DeleteOneLocalData() (channel not found) complete" ), aIndex)); + return KErrGeneral; + } + + // channelData.iUpstreamSignalCopy may or may not exist (optional) + delete channelData.iUpstreamSignalCopy; + channelData.iUpstreamSignalCopy = NULL; + delete channelData.iUpstreamRW; + channelData.iUpstreamRW = NULL; + + FTRACE(FPrint( _L("CDunTransUtils::DeleteOneLocalData() complete" ))); + return KErrNone; + } + +// --------------------------------------------------------------------------- +// Deletes buffering objects of aIndex:th channel +// --------------------------------------------------------------------------- +// +TInt CDunTransUtils::DeleteBuffering( TInt aIndex ) + { + FTRACE(FPrint( _L("CDunTransUtils::DeleteBuffering()" ))); + + if ( aIndex < 0 || + aIndex >= iChannelData.Count() ) + { + FTRACE(FPrint( _L("CDunTransUtils::DeleteBuffering() (not found) complete" ))); + return KErrNotFound; + } + TDunChannelData& channelData = iChannelData[aIndex]; + if ( !channelData.iChannelInUse ) + { + FTRACE(FPrint( _L("CDunTransUtils::DeleteBuffering() (channel not found) complete" ), aIndex)); + return KErrGeneral; + } + + delete channelData.iChannelName; + channelData.iChannelName = NULL; + delete channelData.iBufferUpstream; + channelData.iBufferUpstream = NULL; + delete channelData.iBufferDownstream; + channelData.iBufferDownstream = NULL; + delete channelData.iBufferUpPtr; + channelData.iBufferUpPtr = NULL; + delete channelData.iBufferDownPtr; + channelData.iBufferDownPtr = NULL; + + FTRACE(FPrint( _L("CDunTransUtils::DeleteBuffering() complete" ))); + return KErrNone; + } + +// --------------------------------------------------------------------------- +// Initializes first free channel +// --------------------------------------------------------------------------- +// +TInt CDunTransUtils::InitializeFirstFreeChannel( TConnId aLocalIdNew ) + { + FTRACE(FPrint( _L("CDunTransUtils::InitializeFirstFreeChannel()" ))); + TInt i; + TInt count; + TInt retTemp; + TInt firstFree = KErrNotFound; + count = iChannelData.Count(); + for ( i=0; i= 0 ) + { + FTRACE(FPrint( _L("CDunTransUtils::InitializeFirstFreeChannel() complete" ))); + return i; + } + // Free channel not found, now create new if possible + TDunChannelData emptyChannel; + CreateEmptyChannelData( emptyChannel ); + retTemp = iChannelData.Append( emptyChannel ); + if ( retTemp != KErrNone ) + { + FTRACE(FPrint( _L("CDunTransUtils::InitializeFirstFreeChannel() (append failed!) complete" ))); + return retTemp; + } + FTRACE(FPrint( _L("CDunTransUtils::InitializeFirstFreeChannel() complete" ))); + return i; + } + +// --------------------------------------------------------------------------- +// From class MDunTransporterUtility. +// Allocates a channel by creating and setting local media independent +// objects +// This is a common method used by exported local media dependent methods +// --------------------------------------------------------------------------- +// +void CDunTransUtils::DoAllocateChannelL( RComm* aComm, + TInt& aBufferLength, + TInt aFirstFree, + MDunBufferCorrection* aCorrection ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoAllocateChannelL()" ))); + TInt retTemp; + TInt itemsInCs = 0; + + if ( !iParent.iNetwork ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoAllocateChannelL() (iNetwork) not initialized!" ))); + User::Leave( KErrGeneral ); + } + + FTRACE(FPrint( _L("CDunTransUtils::DoAllocateChannelL() aFirstFree = %d" ), aFirstFree)); + + // Allocate network channel + RComm* networkEntity; + retTemp = iParent.iNetwork->AllocateChannel( networkEntity ); + if ( retTemp != KErrNone ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoAllocateChannelL() network allocation failed" ))); + if ( retTemp == KErrTooBig ) + { + // Start to show note + if ( iParent.iNoteHandler ) + { + iParent.iNoteHandler->IssueRequest(); + } + // Set flag to indicate that advertisement is not possible anymore + ManageAdvertisementStatusChange( EFalse ); + FTRACE(FPrint( _L("CDunTransUtils::DoAllocateChannelL() (too big) complete" ))); + User::Leave( KErrTooBig ); + } + FTRACE(FPrint( _L("CDunTransUtils::DoAllocateChannelL() (ERROR) complete" ))); + User::Leave( KErrGeneral ); + } + + TInt currentLength = networkEntity->ReceiveBufferLength(); + TInt newLength = currentLength; + FTRACE(FPrint( _L("CDunTransUtils::DoAllocateChannelL() buffer length before = %d" ), currentLength)); + if ( aCorrection ) + { + // Get network side buffer length and request change if required. + // Check "newlength>currentLength" here as it is not possible to + // increase Dataport's buffer length + newLength = aCorrection->NotifyBufferCorrection( currentLength ); + if ( newLength<=0 || newLength>currentLength ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoAllocateChannelL() unknown buffer length" ))); + User::Leave( KErrGeneral ); + } + // It is not possible to set Dataport side receive buffer length to any + // arbitrary value (currently only 8kB..20kB are supported but that + // can't be queried via an API). So here only default buffer size will + // be used from Dataport while this component's local buffering uses + // Dataport's default buffer size if not adjusted via plugin side. + // NOTE: If Dataport side starts to support arbitrary receive buffer + // size, it should be changed here if newLength != currentLength. + } + aBufferLength = newLength; + FTRACE(FPrint( _L("CDunTransUtils::DoAllocateChannelL() buffer length after = %d" ), newLength)); + + // Get channel data + + TDunChannelData& channelData = iChannelData[aFirstFree]; + + // Create buffers and set length + + TUint8* bufferUpstream; + TPtr8* bufferUpPtr; + DoCreateBufferLC( channelData.iBufferUpstream, + channelData.iBufferUpPtr, + bufferUpstream, + bufferUpPtr, + newLength, + itemsInCs ); + + TUint8* bufferDownstream; + TPtr8* bufferDownPtr; + DoCreateBufferLC( channelData.iBufferDownstream, + channelData.iBufferDownPtr, + bufferDownstream, + bufferDownPtr, + newLength, + itemsInCs ); + + // Create signal copy objects + + CDunSignalCopy* upstreamCopy = channelData.iUpstreamSignalCopy; + CDunSignalCopy* downstreamCopy = channelData.iDownstreamSignalCopy; + if ( aComm ) + { + DoCreateSignalCopyLC( channelData.iUpstreamSignalCopy, + upstreamCopy, + itemsInCs ); + DoCreateSignalCopyLC( channelData.iDownstreamSignalCopy, + downstreamCopy, + itemsInCs ); + retTemp = upstreamCopy->SetMedia( aComm, + networkEntity, + EDunStreamTypeUpstream ); + if ( retTemp != KErrNone ) + { + delete upstreamCopy; + upstreamCopy = NULL; + } + retTemp = downstreamCopy->SetMedia( aComm, + networkEntity, + EDunStreamTypeDownstream ); + if ( retTemp != KErrNone ) + { + delete downstreamCopy; + downstreamCopy = NULL; + } + } + + // Create signal notify objects + + CDunSignalNotify* signalNotify = channelData.iSignalNotify; + if ( !aComm ) // RSocket + { + DoCreateSignalNotifyLC( channelData.iSignalNotify, + signalNotify, + itemsInCs ); + retTemp = signalNotify->SetMedia( networkEntity ); + if ( retTemp != KErrNone ) + { + delete signalNotify; + signalNotify = NULL; + } + } + + // Create upstream objects + + CDunUpstream* upstreamRW; + DoCreateUpTransferObjectL( channelData.iUpstreamRW, + upstreamRW, + itemsInCs ); + upstreamRW->SetBuffering( bufferUpPtr ); + upstreamRW->SetMedia( networkEntity, EDunMediaContextNetwork ); + upstreamRW->SetActivityCallback( this ); + + // Create downstream objects + + CDunDownstream* downstreamRW; + DoCreateDownTransferObjectL( channelData.iDownstreamRW, + downstreamRW, + itemsInCs ); + downstreamRW->SetBuffering( bufferDownPtr ); + downstreamRW->SetMedia( networkEntity, EDunMediaContextNetwork ); + + // Save values + + channelData.iNetwork = networkEntity; + channelData.iUpstreamRW = upstreamRW; + channelData.iDownstreamRW = downstreamRW; + channelData.iBufferUpstream = bufferUpstream; + channelData.iBufferDownstream = bufferDownstream; + channelData.iBufferUpPtr = bufferUpPtr; + channelData.iBufferDownPtr = bufferDownPtr; + channelData.iUpstreamSignalCopy = upstreamCopy; + channelData.iDownstreamSignalCopy = downstreamCopy; + channelData.iSignalNotify = signalNotify; + + CleanupStack::Pop( itemsInCs ); + + // Set flag to indicate that advertisement is now possible + ManageAdvertisementStatusChange( ETrue, ETrue ); + + FTRACE(FPrint( _L("CDunTransUtils::DoAllocateChannelL() complete" ))); + } + +// --------------------------------------------------------------------------- +// From class MDunTransporterUtility. +// Adds connection monitor callback for either local media or network side +// by connection ID +// Connection monitor will be added to aIndex:th endpoint +// --------------------------------------------------------------------------- +// +TInt CDunTransUtils::DoAddConnMonCallback( TInt aIndex, + MDunConnMon* aCallback, + TDunDirection aDirection, + TBool aSignal ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoAddConnMonCallback()" ))); + + if ( !iParent.iNetwork ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoAddConnMonCallback() (iNetwork) not initialized!" ))); + return KErrGeneral; + } + + if ( aIndex < 0 || + aIndex >= iChannelData.Count() ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoAddConnMonCallback() (not found) complete" ))); + return KErrNotFound; + } + + TDunChannelData& channelData = iChannelData[aIndex]; + + // Get upstream and downstream + CDunUpstream* upstream = channelData.iUpstreamRW; + CDunDownstream* downstream = channelData.iDownstreamRW; + + if ( aDirection == EDunReaderUpstream ) + { + // Initialize stream for AT parsing (ignore errors) + upstream->InitializeForAtParsing( downstream, + channelData.iChannelName, + upstream, + downstream ); + downstream->InitializeForDataPushing( upstream ); + } + + // Get stream type and operation type + + TDunStreamType streamType = + static_cast( aDirection & KDunStreamTypeMask ); + TDunOperationType operationType = + static_cast( aDirection & KDunOperationTypeMask ); + + if ( streamType == EDunStreamTypeUpstream ) + { + // If signal copy object(s) exist then add RunL error monitoring for them + if ( channelData.iUpstreamSignalCopy ) // optional + { + // Add callback (ignore errors) + channelData.iUpstreamSignalCopy->AddCallback( aCallback ); + } + } + else if ( streamType == EDunStreamTypeDownstream ) + { + // If signal copy object(s) exist then add RunL error monitoring for them + if ( channelData.iDownstreamSignalCopy ) // optional + { + // Add callback (ignore errors) + channelData.iDownstreamSignalCopy->AddCallback( aCallback ); + } + } + else + { + FTRACE(FPrint( _L("CDunTransUtils::DoAddConnMonCallback() (stream) not initialized!" ) )); + return KErrGeneral; + } + + // Set signal notify callback + + if ( aSignal && aDirection==EDunReaderDownstream ) + { + if ( !channelData.iSignalNotify ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoAddConnMonCallback() (iSignalNotify) not initialized" ))); + return KErrGeneral; + } + // Add callback (ignore errors) + channelData.iSignalNotify->AddCallback( aCallback ); + } + + // Add callback (ignore errors) + if ( streamType == EDunStreamTypeUpstream ) + { + upstream->AddConnMonCallback( aCallback, operationType ); + } + else // streamType == EDunStreamTypeDownstream + { + downstream->AddConnMonCallback( aCallback, operationType ); + } + + FTRACE(FPrint( _L("CDunTransUtils::DoAddConnMonCallback() complete" ))); + return KErrNone; + } + +// --------------------------------------------------------------------------- +// From class MDunTransporterUtility. +// Adds error to consider as no error condition when doing any of the four +// endpoint's read/writer operation +// Error will be added to aIndex:th endpoint +// --------------------------------------------------------------------------- +// +TInt CDunTransUtils::DoAddSkippedError( TInt aIndex, + TInt aError, + TDunDirection aDirection ) + { + FTRACE(FPrint( _L("CDunTransUtils::AddOneSkippedError" ) )); + if ( aIndex < 0 || + aIndex >= iChannelData.Count() ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoAddSkippedError() (not found) complete" ))); + return KErrNotFound; + } + TDunChannelData& channelData = iChannelData[aIndex]; + if ( !channelData.iChannelInUse ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoAddSkippedError() (channel not found) complete" ), aIndex)); + return KErrGeneral; + } + + if ( aDirection != EDunReaderUpstream && + aDirection != EDunWriterUpstream && + aDirection != EDunReaderDownstream && + aDirection != EDunWriterDownstream ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoAddSkippedError() (ERROR) added" ) )); + return KErrNotSupported; + } + + TDunStreamType streamType = + static_cast( aDirection & KDunStreamTypeMask ); + TDunOperationType operationType = + static_cast( aDirection & KDunOperationTypeMask ); + + if ( streamType != EDunStreamTypeUpstream && + streamType != EDunStreamTypeDownstream ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoAddSkippedError() (stream) not initialized!" ) )); + return KErrGeneral; + } + + // Add skipped error (ignore errors) + + if ( streamType == EDunStreamTypeUpstream ) + { + channelData.iUpstreamRW->AddSkippedError( aError, operationType ); + } + else if ( streamType == EDunStreamTypeDownstream ) + { + channelData.iDownstreamRW->AddSkippedError( aError, operationType ); + } + else + { + FTRACE(FPrint( _L("CDunTransUtils::DoAddSkippedError() (stream) not initialized!" ) )); + return KErrGeneral; + } + + FTRACE(FPrint( _L("CDunTransUtils::DoAddSkippedError() complete" ) )); + return KErrNone; + } + +// --------------------------------------------------------------------------- +// From class MDunTransporterUtility. +// Issues transfers requests for aIndex:th transfer objects +// --------------------------------------------------------------------------- +// +TInt CDunTransUtils::DoIssueTransferRequests( TInt aIndex ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoIssueTransferRequests()" ))); + if ( aIndex < 0 || + aIndex >= iChannelData.Count() ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoIssueTransferRequests() (not found) complete" ))); + return KErrNotFound; + } + TDunChannelData& channelData = iChannelData[aIndex]; + if ( !channelData.iChannelInUse ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoIssueTransferRequests() (channel not found) complete" ), aIndex)); + return KErrGeneral; + } + + if ( !channelData.iUpstreamRW ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoIssueTransferRequests() (iUpstreamRW) not initialized!" ))); + return KErrGeneral; + } + if ( !channelData.iDownstreamRW ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoIssueTransferRequests() (iDownstreamRW) not initialized!" ))); + return KErrGeneral; + } + + // Below issuing requests on signal objects (CDunSignalCopy, + // CDunSignalNotify) before issuing request on read/write objects + // (CDunUpstream/CDunDownstream). This is to guarantee that if signals are + // already set in local media side then they will be copied to network side + // before data. + + if ( channelData.iUpstreamSignalCopy ) // optional (RComm) + { + channelData.iUpstreamSignalCopy->IssueRequest(); + } + if ( channelData.iDownstreamSignalCopy ) // optional (RComm) + { + channelData.iDownstreamSignalCopy->IssueRequest(); + } + if ( channelData.iSignalNotify ) // optional (RSocket) + { + channelData.iSignalNotify->IssueRequest(); + } + channelData.iUpstreamRW->StartStream(); + channelData.iDownstreamRW->StartStream(); + + FTRACE(FPrint( _L("CDunTransUtils::DoIssueTransferRequests() complete" ))); + return KErrNone; + } + +// --------------------------------------------------------------------------- +// From class MDunTransporterUtility. +// Stops transfers for aIndex:th transfer objects +// --------------------------------------------------------------------------- +// +TInt CDunTransUtils::DoStopTransfers( TInt aIndex ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoStopTransfers()" ))); + if ( aIndex < 0 || + aIndex >= iChannelData.Count() ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoStopTransfers() (not found) complete" ))); + return KErrNotFound; + } + + TDunChannelData& channelData = iChannelData[aIndex]; + if ( !channelData.iChannelInUse ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoStopTransfers() (channel not found) complete" ), aIndex)); + return KErrGeneral; + } + + if ( !channelData.iUpstreamRW ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoStopTransfers() (iUpstreamRW) not initialized!" ))); + return KErrGeneral; + } + if ( !channelData.iDownstreamRW ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoStopTransfers() (iDownstreamRW) not initialized!" ))); + return KErrGeneral; + } + + // Now stop operation of signal objects (CDunSignalCopy, CDunSignalNotify) + // before stopping operation on read/write objects (CDunUpstream/ + // CDunDownstream). This is to ensure that signals don't change after + // stopping read/write which in turn could cause problems. + + if ( channelData.iUpstreamSignalCopy ) // optional (RComm) + { + channelData.iUpstreamSignalCopy->Stop(); + } + if ( channelData.iDownstreamSignalCopy ) // optional (RComm) + { + channelData.iDownstreamSignalCopy->Stop(); + } + if ( channelData.iSignalNotify ) // optional (RSocket) + { + channelData.iSignalNotify->Stop(); + } + channelData.iUpstreamRW->Stop(); + channelData.iDownstreamRW->Stop(); + + FTRACE(FPrint( _L("CDunTransUtils::DoStopTransfers() complete" ))); + return KErrNone; + } + +// --------------------------------------------------------------------------- +// From class MDunTransporterUtility. +// Free aIndex:th channel's objects +// --------------------------------------------------------------------------- +// +TInt CDunTransUtils::DoFreeChannel( TInt aIndex ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoFreeChannel()" ))); + + TDunChannelData& channelData = iChannelData[aIndex]; + if ( aIndex < 0 || + aIndex >= iChannelData.Count() ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoFreeChannel (not found) complete" ))); + return KErrNotFound; + } + if ( !channelData.iChannelInUse ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoFreeChannel (already free) complete" ))); + return KErrNone; + } + if ( !iParent.iNetwork ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoFreeChannel (iNetwork) not initialized!" ))); + return KErrGeneral; + } + + DoStopTransfers( aIndex ); + DeleteOneNetworkData( aIndex ); + DeleteOneLocalData( aIndex ); + DeleteBuffering( aIndex ); + + iParent.iNetwork->FreeChannel( channelData.iNetwork ); + + channelData.iNetwork = NULL; + channelData.iComm = NULL; + channelData.iSocket = NULL; + channelData.iChannelInUse = EFalse; + + // If note exist then stop it now as no reason to show it anymore + if ( iParent.iNoteHandler ) + { + iParent.iNoteHandler->Stop(); + } + // Set flag to indicate that advertisement is now possible + ManageAdvertisementStatusChange( ETrue, EFalse ); + + FTRACE(FPrint( _L("CDunTransUtils::DoFreeChannel() complete" ))); + return KErrNone; + } + +// --------------------------------------------------------------------------- +// From class MDunTransporterUtilityAux. +// Gets local ID counterpart of a network ID +// --------------------------------------------------------------------------- +// +TConnId CDunTransUtils::GetLocalId( RComm* aComm ) + { + FTRACE(FPrint( _L("CDunTransUtils::GetLocalId()" ))); + TInt mediaIndex = iParent.GetMediaIndex( aComm, EDunMediaContextNetwork ); + if ( mediaIndex < 0 ) + { + FTRACE(FPrint( _L("CDunTransUtils::GetLocalId() (ERROR) complete (%d)" ), mediaIndex)); + return NULL; + } + if ( mediaIndex >= iChannelData.Count() ) + { + FTRACE(FPrint( _L("CDunTransUtils::GetLocalId() (not found) complete" ) )); + return NULL; + } + TDunChannelData& channelData = iChannelData[mediaIndex]; + if ( channelData.iComm ) + { + FTRACE(FPrint( _L("CDunTransUtils::GetLocalId() (iComm) complete" ))); + return channelData.iComm; + } + if ( channelData.iSocket ) + { + FTRACE(FPrint( _L("CDunTransUtils::GetLocalId() (iSocket) complete" ))); + return channelData.iSocket; + } + FTRACE(FPrint( _L("CDunTransUtils::GetLocalId() (ERROR) complete" ))); + return NULL; + } + +// --------------------------------------------------------------------------- +// From MDunTransporterUtilityAux. +// Notifies when serious read/write error is detected on a connection +// --------------------------------------------------------------------------- +// +TInt CDunTransUtils::DoNotifyConnectionNotOk( + RComm* aComm, + RSocket* aSocket, + TDunConnectionReason& aConnReason, + RPointerArray& aCallbacks ) + { + FTRACE(FPrint( _L("CDunTransUtils::DoNotifyConnectionNotOk()" ))); + TConnId localId = NULL; + if ( aComm ) + { + localId = aComm; + } + else if ( aSocket ) + { + localId = aSocket; + } + TInt i; + TInt count = aCallbacks.Count(); + for ( i=0; iNotifyProgressChangeL( localId, aConnReason ) ); + } + FTRACE(FPrint( _L("CDunTransUtils::DoNotifyConnectionNotOk() complete" ))); + return KErrNone; + } + +// --------------------------------------------------------------------------- +// From class MDunActivityManager. +// Notifies about activity on a channel +// --------------------------------------------------------------------------- +// +TInt CDunTransUtils::NotifyChannelActivity() + { + FTRACE(FPrint( _L("CDunTransUtils::NotifyChannelActivity()" ))); + iParent.iActiveChannels++; + if ( iParent.iActiveChannels == 1 ) + { + // Now set key and notify (only once) that DUN is active + TInt retTemp = RProperty::Set( KPSUidDialupConnStatus, + KDialupConnStatus, + EDialupActive ); + if ( retTemp != KErrNone ) + { + FTRACE(FPrint( _L("CDunTransUtils::NotifyChannelActivity() (ERROR) complete" ))); + return retTemp; + } + } + FTRACE(FPrint( _L("CDunTransUtils::NotifyChannelActivity() complete" ))); + return KErrNone; + } + +// --------------------------------------------------------------------------- +// From class MDunActivityManager. +// Notifies about inactivity on a channel +// --------------------------------------------------------------------------- +// +TInt CDunTransUtils::NotifyChannelInactivity() + { + FTRACE(FPrint( _L("CDunTransUtils::NotifyChannelInactivity()" ))); + if ( iParent.iActiveChannels <= 0 ) + { + FTRACE(FPrint( _L("CDunTransUtils::NotifyChannelInactivity() (wrong iActiveChannels!) complete" ))); + return KErrGeneral; + } + iParent.iActiveChannels--; + if ( iParent.iActiveChannels == 0 ) + { + // Now set key and notify (only once) that DUN is inactive + TInt retTemp = RProperty::Set( KPSUidDialupConnStatus, + KDialupConnStatus, + EDialupInactive ); + if ( retTemp != KErrNone ) + { + FTRACE(FPrint( _L("CDunTransUtils::NotifyChannelInactivity() (ERROR) complete" ))); + return retTemp; + } + } + FTRACE(FPrint( _L("CDunTransUtils::NotifyChannelInactivity() complete" ))); + return KErrNone; + }