--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/natfw/natfwconnectionmultiplexer/src/cncmconnectionmultiplexer.cpp Tue Feb 02 01:04:58 2010 +0200
@@ -0,0 +1,1162 @@
+/*
+* Copyright (c) 2006-2008 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: Connection multiplexer is responsible for handling network
+* connections, send and receive data from the
+* network and allow client to start media flow between
+* connection multiplexer and socket media connection wrapper.
+*
+*/
+
+
+
+
+#include <in_sock.h>
+
+#include "cncmconnectionmultiplexer.h"
+#include "mncmconnectionmultiplexerobserver.h"
+#include "cncmportstore.h"
+#include "cncmmediasource.h"
+#include "ncmconnectionmultiplexerlogs.h"
+#include "cncmsession.h"
+#include "cncmstream.h"
+#include "cncmconnection.h"
+#include "natfwmediawrapper.h"
+#include "cncmcallbackexecuter.h"
+#include "ncmconnectionmultiplexerassert.h"
+#include "cncmconnectionobserverhandler.h"
+
+const TUint KFirstSessionId = 1;
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::CNcmConnectionMultiplexer
+// ---------------------------------------------------------------------------
+//
+CNcmConnectionMultiplexer::CNcmConnectionMultiplexer(
+ MNcmConnectionMultiplexerObserver& aObserver ) :
+ iObserver( aObserver ), iNextSessionId( KFirstSessionId )
+ {
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::NewL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C CNcmConnectionMultiplexer* CNcmConnectionMultiplexer::NewL(
+ MNcmConnectionMultiplexerObserver& aObserver )
+ {
+ __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::NewL" )
+
+ CNcmConnectionMultiplexer* self =
+ new (ELeave) CNcmConnectionMultiplexer( aObserver );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::ConstructL
+// -----------------------------------------------------------------------------
+//
+void CNcmConnectionMultiplexer::ConstructL()
+ {
+ iAsyncCallback = CNcmCallBackExecuter::NewL();
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::~CNcmConnectionMultiplexer
+// ---------------------------------------------------------------------------
+//
+CNcmConnectionMultiplexer::~CNcmConnectionMultiplexer()
+ {
+ __CONNECTIONMULTIPLEXER(
+ "CNcmConnectionMultiplexer::~CNcmConnectionMultiplexer" )
+
+ iSessions.ResetAndDestroy();
+ delete iAsyncCallback;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::CreateSessionL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TUint CNcmConnectionMultiplexer::CreateSessionL( TUint32 aIapId,
+ TUint aPortRangeStart, TUint aPortRangeStop )
+ {
+ __CONNECTIONMULTIPLEXER_INT3(
+ "CNcmConnectionMultiplexer::CreateSessionL - aIapId:", aIapId,
+ "aPortRangeStart: ", aPortRangeStart, "aPortRangeStop: ", aPortRangeStop )
+
+ CNcmSession* session =
+ CNcmSession::NewLC( iNextSessionId, aIapId,
+ aPortRangeStart, aPortRangeStop, iObserver, *this );
+
+ iSessions.AppendL( session );
+ CleanupStack::Pop( session );
+
+ iNextSessionId++;
+
+ return session->SessionId();
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::CreateStreamL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TUint CNcmConnectionMultiplexer::CreateStreamL( TUint aSessionId,
+ TInt aQos, TUint aProtocol )
+ {
+ __CONNECTIONMULTIPLEXER_INT3(
+ "CNcmConnectionMultiplexer::CreateStreamL - aSessionId:", aSessionId,
+ "aQos: ", aQos, "aProtocol: ", aProtocol )
+
+ CNcmSession* session( SessionByIdL( aSessionId ) );
+
+ __ASSERT_ALWAYS( session->Initialized(), User::Leave( KErrNotReady ) );
+
+ return ( session->CreateStreamL( aQos, aProtocol ) );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::GetStreamInfoL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::GetStreamInfoL(
+ TUint aStreamId, TUint32& aIapId, TInt& aQos,
+ TUint& aProtocol )
+ {
+ __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::GetStreamInfoL" )
+
+ CNcmStream* stream( StreamByIdL( aStreamId ) );
+
+ aIapId = SessionByStreamIdL( aStreamId )->IapId();
+ aQos = stream->Qos();
+ aProtocol = stream->StreamProtocol();
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::LocalIPAddressL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TInetAddr& CNcmConnectionMultiplexer::LocalIPAddressL(
+ TUint aStreamId, TUint aConnectionId )
+ {
+ return StreamByIdL( aStreamId )->
+ ConnectionL( aConnectionId )->LocalAddress();
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::ResolveDestinationAddressL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::ResolveDestinationAddressL(
+ TUint aStreamId, const TDesC8& aAddress, TUint aPort,
+ TInetAddr& aResult )
+ {
+ __CONNECTIONMULTIPLEXER(
+ "CNcmConnectionMultiplexer::ResolveDestinationAddressL, FQDN" )
+
+ SessionByStreamIdL( aStreamId )->ResolveDestinationAddressL(
+ aAddress, aPort, aResult );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::CreateConnectionL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TUint CNcmConnectionMultiplexer::CreateConnectionL(
+ TUint aStreamId, TUint aAddrFamily )
+ {
+ __CONNECTIONMULTIPLEXER_INT2(
+ "CNcmConnectionMultiplexer::CreateConnectionL - Entry, aStreamId:", aStreamId,
+ "aAddrFamily: ", aAddrFamily )
+
+ __CONNECTIONMULTIPLEXER_ASSERT_L( ( KAfInet == aAddrFamily || KAfInet6 == aAddrFamily ),
+ KErrArgument );
+
+ CNcmStream* stream( StreamByIdL( aStreamId ) );
+ CNcmSession* session( SessionByStreamIdL( aStreamId ) );
+
+ TInetAddr addr( KInetAddrNone, 0 );
+
+ addr = ( KAfInet == aAddrFamily )
+ ? session->LocalIPv4Address()
+ : session->LocalIPv6Address();
+
+ __CONNECTIONMULTIPLEXER_ADDRLOG(
+ "CNcmConnectionMultiplexer::CreateConnectionL - ADDRESS: ", addr )
+
+ __ASSERT_ALWAYS( !addr.IsUnspecified(), User::Leave( KErrNotFound ) );
+
+ addr.SetPort( session->PortStore().Port() );
+
+ __CONNECTIONMULTIPLEXER_ADDRLOG(
+ "CNcmConnectionMultiplexer::CreateConnectionL - PORT: ", addr.Port() )
+
+ // Create Connection
+ return stream->CreateConnectionL(
+ *this, stream->ConnectionObserverHandler(),
+ session->SocketServer(),
+ session->Connection(), addr, EFalse );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::CreateConnectionL - overloaded
+// ---------------------------------------------------------------------------
+//
+EXPORT_C TUint CNcmConnectionMultiplexer::CreateConnectionL(
+ TUint aStreamId, const TInetAddr& aLocalAddr )
+ {
+ __CONNECTIONMULTIPLEXER_ADDRLOG(
+ "CNcmConnectionMultiplexer::CreateConnectionL - overloaded - \
+ Local address:", aLocalAddr )
+
+ __CONNECTIONMULTIPLEXER_ASSERT_L( ( !aLocalAddr.IsUnspecified() ),
+ KErrNotSupported );
+
+ CNcmStream* stream( StreamByIdL( aStreamId ) );
+ CNcmSession* session( SessionByStreamIdL( aStreamId ) );
+
+ TInetAddr addr( KInetAddrNone, 0 );
+ addr = aLocalAddr;
+
+ // Create Connection
+ return stream->CreateConnectionL(
+ *this, stream->ConnectionObserverHandler(),
+ session->SocketServer(),
+ session->Connection(), addr, ETrue );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNATFWConnectionMultiplexer::OpenTcpConnectionL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::OpenTcpConnectionL(
+ TUint aStreamId, TUint aConnectionId, TNATFWTcpConnectionSetup aConfig,
+ const TInetAddr& aDestAddr )
+ {
+ __CONNECTIONMULTIPLEXER_INT2(
+ "CNcmConnectionMultiplexer::OpenTcpConnectionL - aStreamId:", aStreamId,
+ "aConnectionId: ", aConnectionId )
+ __CONNECTIONMULTIPLEXER_ADDRLOG(
+ "CNcmConnectionMultiplexer::OpenTcpConnectionL - aDestAddr: ", aDestAddr )
+
+ StreamByIdL( aStreamId )->ConnectionL( aConnectionId )->
+ OpenTcpConnectionL( aConfig, aDestAddr );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNATFWConnectionMultiplexer::CloseTcpConnection
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::CloseTcpConnection(
+ TUint aStreamId, TUint aConnectionId )
+ {
+ __CONNECTIONMULTIPLEXER_INT2(
+ "CNcmConnectionMultiplexer::CloseTcpConnection - aStreamId:", aStreamId,
+ "aConnectionId: ", aConnectionId )
+
+ TRAP_IGNORE( this->CloseTcpConnectionL( aStreamId, aConnectionId ) )
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNATFWConnectionMultiplexer::CloseTcpConnectionL
+// ---------------------------------------------------------------------------
+//
+void CNcmConnectionMultiplexer::CloseTcpConnectionL(
+ TUint aStreamId, TUint aConnectionId )
+ {
+ __CONNECTIONMULTIPLEXER(
+ "CNATFWConnectionMultiplexer::CloseTcpConnectionL" )
+
+ StreamByIdL( aStreamId )->ConnectionL( aConnectionId )->
+ CloseTcpConnectionL();
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::RemoveSessionL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::RemoveSessionL( TUint aSessionId )
+ {
+ __CONNECTIONMULTIPLEXER_INT1(
+ "CNcmConnectionMultiplexer::RemoveSessionL - aSessionId:", aSessionId )
+
+ TInt sessionCount( iSessions.Count() );
+
+ for ( TInt i = 0; i < sessionCount; i++ )
+ {
+ if ( iSessions[i]->SessionId() == aSessionId )
+ {
+ delete iSessions[i];
+ iSessions.Remove( i );
+ return;
+ }
+ }
+ User::Leave( KErrNotFound );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::RemoveStreamL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::RemoveStreamL( TUint aStreamId )
+ {
+ __CONNECTIONMULTIPLEXER_INT1(
+ "CNcmConnectionMultiplexer::RemoveStreamL - aStreamId:", aStreamId )
+
+ CNcmSession* session( SessionByStreamIdL( aStreamId ) );
+ session->RemoveStreamL( aStreamId );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::RemoveConnectionL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::RemoveConnectionL(
+ TUint aStreamId, TUint aConnectionId )
+ {
+ __CONNECTIONMULTIPLEXER_INT2(
+ "CNcmConnectionMultiplexer::RemoveConnectionL - aStreamId:", aStreamId,
+ "aConnectionId: ", aConnectionId )
+
+ CNcmStream* stream( StreamByIdL( aStreamId ) );
+
+ if ( stream->MediaConnectionId() == aConnectionId )
+ {
+ // media connection can't be deleted.
+ User::Leave( KErrPermissionDenied );
+ }
+
+ stream->RemoveConnectionL( aConnectionId );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::RegisterIncomingConnectionObserverL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::
+ RegisterIncomingConnectionObserverL( TUint aStreamId,
+ MNcmIncomingConnectionObserver& aObserver )
+ {
+ __CONNECTIONMULTIPLEXER(
+ "CNcmConnectionMultiplexer::RegisterIncomingConnectionObserver" )
+
+ StreamByIdL( aStreamId )->
+ ConnectionObserverHandler().
+ RegisterIncomingConnectionObserverL( aObserver );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::RegisterOutgoingConnectionObserverL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::
+ RegisterOutgoingConnectionObserverL(
+ TUint aStreamId, MNcmOutgoingConnectionObserver& aObserver )
+ {
+ __CONNECTIONMULTIPLEXER(
+ "CNcmConnectionMultiplexer::RegisterOutgoingConnectionObserver" )
+
+ StreamByIdL( aStreamId )->
+ ConnectionObserverHandler().
+ RegisterOutgoingConnectionObserverL( aObserver );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::UnregisterIncomingConnectionObserverL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::
+ UnregisterIncomingConnectionObserverL(
+ TUint aStreamId,MNcmIncomingConnectionObserver& aObserver )
+ {
+ __CONNECTIONMULTIPLEXER(
+ "CNcmConnectionMultiplexer::UnregisterIncomingConnectionObserver" )
+
+ StreamByIdL( aStreamId )->ConnectionObserverHandler().
+ UnregisterIncomingConnectionObserverL( aObserver );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::UnregisterOutgoingConnectionObserverL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::
+ UnregisterOutgoingConnectionObserverL(
+ TUint aStreamId, MNcmOutgoingConnectionObserver& aObserver )
+ {
+ __CONNECTIONMULTIPLEXER(
+ "CNcmConnectionMultiplexer::UnregisterOutgoingConnectionObserver" )
+
+ StreamByIdL( aStreamId )->ConnectionObserverHandler().
+ UnregisterOutgoingConnectionObserverL( aObserver );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::RegisterConnectionObserverL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::RegisterConnectionObserverL(
+ TUint aStreamId, MNcmConnectionObserver& aObserver )
+ {
+ __CONNECTIONMULTIPLEXER(
+ "CNcmConnectionMultiplexer::RegisterConnectionObserverL" )
+
+ StreamByIdL( aStreamId )->
+ ConnectionObserverHandler().
+ RegisterConnectionObserverL( aObserver );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::UnregisterConnectionObserverL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::UnregisterConnectionObserverL(
+ TUint aStreamId, MNcmConnectionObserver& aObserver )
+ {
+ __CONNECTIONMULTIPLEXER(
+ "CNcmConnectionMultiplexer::UnregisterConnectionObserverL" )
+
+ StreamByIdL( aStreamId )->ConnectionObserverHandler().
+ UnregisterConnectionObserverL( aObserver );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::RegisterMessageObserverL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::RegisterMessageObserverL(
+ TUint aStreamId, MNcmMessageObserver& aObserver )
+ {
+ StreamByIdL( aStreamId )->ConnectionObserverHandler().
+ RegisterMessageObserver( aObserver );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::UnregisterMessageObserverL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::UnregisterMessageObserverL(
+ TUint aStreamId, MNcmMessageObserver& aObserver )
+ {
+ StreamByIdL( aStreamId )->ConnectionObserverHandler().
+ UnregisterMessageObserver( aObserver );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::RegisterMediaWrapperL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::RegisterMediaWrapperL(
+ MNATFWMediaWrapper* aMediaWrapper )
+ {
+ __CONNECTIONMULTIPLEXER(
+ "CNcmConnectionMultiplexer::RegisterMediaWrapperL" )
+
+ __ASSERT_ALWAYS( aMediaWrapper, User::Leave( KErrNotReady ) );
+
+ TUint streamId( aMediaWrapper->StreamId() );
+
+ CNcmStream* stream( StreamByIdL( streamId ) );
+ CNcmSession* session( SessionByStreamIdL( streamId ) );
+
+ stream->RegisterWrapperL( aMediaWrapper );
+
+ TInetAddr addr( session->LocalIPv4Address() );
+
+ if ( addr.IsUnspecified() )
+ {
+ addr = session->LocalIPv6Address();
+
+ if ( addr.IsUnspecified() )
+ {
+ User::Leave( KErrNotReady );
+ }
+ }
+
+ // Register media source for stream
+ stream->RegisterMediaSourceL( CNcmMediaSource::NewLC( *this,
+ *stream->WrapperL(), SessionByStreamIdL( streamId )->SocketServer(),
+ addr ) );
+
+ CleanupStack::Pop();
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::SendL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::SendL( TUint aStreamId,
+ TUint aConnectionId, const TDesC8& aMessage,
+ MNcmSenderObserver* aSenderObserver )
+ {
+ __CONNECTIONMULTIPLEXER_INT2(
+ "CNcmConnectionMultiplexer::SendL - aStreamId:", aStreamId,
+ "aConnectionId: ", aConnectionId )
+
+ CNcmConnection* connection = StreamByIdL( aStreamId )->
+ ConnectionL( aConnectionId );
+
+ connection->Send( aMessage, KAFUnspec, aSenderObserver );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::SendL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::SendL( TUint aStreamId,
+ TUint aConnectionId, const TDesC8& aMessage,
+ const TInetAddr& aDestinationAddress,
+ MNcmSenderObserver* aSenderObserver )
+ {
+ __CONNECTIONMULTIPLEXER_INT2(
+ "CNcmConnectionMultiplexer::SendL - aStreamId:", aStreamId,
+ "aConnectionId: ", aConnectionId )
+
+ CNcmConnection* connection(StreamByIdL( aStreamId )->ConnectionL(
+ aConnectionId ) );
+
+ connection->Send( aMessage, aDestinationAddress, aSenderObserver );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::SendL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::SendL( TUint aStreamId,
+ const TDesC8& aMessage, const TInetAddr& aNextHopAddress,
+ const TInetAddr& aDestinationAddress )
+ {
+ __CONNECTIONMULTIPLEXER_INT1(
+ "CNcmConnectionMultiplexer::SendL - aStreamId:", aStreamId )
+ __CONNECTIONMULTIPLEXER_ADDRLOG(
+ "CNcmConnectionMultiplexer::SendL - aDestinationAddress: ", aDestinationAddress )
+ __CONNECTIONMULTIPLEXER_ADDRLOG(
+ "CNcmConnectionMultiplexer::SendL - aNextHopAddress: ", aNextHopAddress )
+
+ CNcmConnection* connection( NULL );
+ CNcmStream* stream = StreamByIdL( aStreamId );
+
+ connection = stream->ConnectionByDestinationAddressL( aNextHopAddress );
+
+ connection->Send( aMessage, aDestinationAddress, NULL );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::SendL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::SendL( TUint aStreamId,
+ TUint aConnectionId, const TDesC8& aMessage, TBool aSendDirectly,
+ MNcmSenderObserver* aSenderObserver )
+ {
+ __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::SendL - \
+ overloaded, send message directly from connection" )
+ __CONNECTIONMULTIPLEXER_INT2( "CNcmConnectionMultiplexer::SendL - \
+ aStreamId:", aStreamId, "aConnectionId: ", aConnectionId )
+
+ if ( aSendDirectly )
+ {
+ StreamByIdL( aStreamId )->ConnectionL( aConnectionId )->
+ SendDirectlyToNetwork( aMessage, aSenderObserver );
+ }
+ else
+ {
+ this->SendL( aStreamId, aConnectionId, aMessage, aSenderObserver );
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::CancelMessageSend
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::CancelMessageSend( TUint aStreamId,
+ TUint aConnectionId, const MNcmSenderObserver* aSenderObserver )
+ {
+ __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::CancelMessageSend " )
+
+ TRAP_IGNORE( this->CancelMessageSendL( aStreamId, aConnectionId,
+ aSenderObserver ) )
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::CancelMessageSendL
+// ---------------------------------------------------------------------------
+//
+void CNcmConnectionMultiplexer::CancelMessageSendL( TUint aStreamId,
+ TUint aConnectionId, const MNcmSenderObserver* aSenderObserver )
+ {
+ __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::CancelMessageSendL " )
+
+ StreamByIdL( aStreamId )->
+ ConnectionL( aConnectionId )->CancelMessageSendL( aSenderObserver );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::PortStoreL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C CNcmPortStore& CNcmConnectionMultiplexer::PortStoreL(
+ TUint aSessionId )
+ {
+ __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::PortStoreL" )
+
+ return SessionByIdL( aSessionId )->PortStore();
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::GetSessionInfoL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C RSocketServ* CNcmConnectionMultiplexer::GetSessionInfoL(
+ TUint aSessionId, TName& aConnectionName )
+ {
+ __CONNECTIONMULTIPLEXER_INT1(
+ "CNcmConnectionMultiplexer::GetSessionInfoL - aSessionId:", aSessionId )
+
+ CNcmSession* session( SessionByIdL( aSessionId ) );
+
+ User::LeaveIfError( session->GetConnectionName( aConnectionName ) );
+ return &session->SocketServer();
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::SetSendingStateForMediaL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::SetSendingStateForMediaL(
+ TUint aStreamId, TUint aConnectionId, TNATFWStreamingState aState )
+ {
+ __CONNECTIONMULTIPLEXER_INT2(
+ "CNcmConnectionMultiplexer::SetSendingStateForMediaL - \
+ aStreamId:", aStreamId, "aConnectionId: ", aConnectionId )
+
+ CNcmStream* stream( StreamByIdL( aStreamId ) );
+ MNATFWMediaWrapper* wrapper = stream->WrapperL();
+ TMultiplexerConnectionNotifyType type( EMultiplexerConnectionError );
+
+ CNcmConnection* connection( stream->ConnectionL( aConnectionId ) );
+ stream->SetMediaConnectionId( aConnectionId );
+
+ if ( aState == EStreamingStateActive )
+ {
+ stream->ConnectionObserverHandler().
+ RegisterMediaSourceObserver( *connection );
+ wrapper->SetReceivingStateForMuxWrapper( aState );
+ type = EMultiplexerMediaSendingActivated;
+ }
+ else if ( aState == EStreamingStatePassive )
+ {
+ stream->ConnectionObserverHandler().
+ UnregisterMediaSourceObserver( *connection );
+ wrapper->SetReceivingStateForMuxWrapper( aState );
+ type = EMultiplexerMediaSendingDeactivated;
+ }
+ else
+ {
+ __CONNECTIONMULTIPLEXER_ASSERT_L( EFalse, KErrNotSupported );
+ }
+
+ TNcmCallBack callback( HandleCallBack, *this, aStreamId, aConnectionId,
+ type, KErrNone );
+ iAsyncCallback->AddCallBackL( callback );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::SetReceivingStateForMediaL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::SetReceivingStateForMediaL(
+ TUint aStreamId, TUint aConnectionId, TNATFWStreamingState aState )
+ {
+ __CONNECTIONMULTIPLEXER_INT2(
+ "CNcmConnectionMultiplexer::SetReceivingStateForMediaL - \
+ aStreamId:", aStreamId, "aConnectionId: ", aConnectionId )
+
+ CNcmStream* stream( StreamByIdL( aStreamId ) );
+ TMultiplexerConnectionNotifyType type(
+ EMultiplexerConnectionError );
+
+ // Is connection real
+ stream->ConnectionL( aConnectionId );
+ stream->SetMediaConnectionId( aConnectionId );
+
+ if ( EStreamingStateActive == aState )
+ {
+ type = EMultiplexerMediaReceivingActivated;
+ }
+ else if( EStreamingStatePassive == aState )
+ {
+ type = EMultiplexerMediaReceivingDeactivated;
+ }
+ else
+ {
+ __CONNECTIONMULTIPLEXER_ASSERT_L( EFalse, KErrNotSupported );
+ }
+
+ stream->ConnectionObserverHandler().SetReceivingState( aState );
+
+ TNcmCallBack callback( HandleCallBack, *this, aStreamId, aConnectionId,
+ type, KErrNone );
+ iAsyncCallback->AddCallBackL( callback );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::SetSendingStateL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::SetSendingStateL(
+ TUint aStreamId, TUint aConnectionId, const TInetAddr& aDestAddr,
+ TNATFWStreamingState aState )
+ {
+ __CONNECTIONMULTIPLEXER_INT2(
+ "CNcmConnectionMultiplexer::SetSendingStateL - \
+ aStreamId:", aStreamId, "aConnectionId: ", aConnectionId )
+
+ StreamByIdL( aStreamId )->
+ ConnectionL( aConnectionId )->SetSendingStateL( aDestAddr, aState );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::SetReceivingStateL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::SetReceivingStateL(
+ TUint aStreamId, TUint aConnectionId, TNATFWStreamingState aState )
+ {
+ __CONNECTIONMULTIPLEXER_INT2(
+ "CNcmConnectionMultiplexer::SetReceivingStateL - \
+ aStreamId:", aStreamId, "aConnectionId: ", aConnectionId )
+
+ StreamByIdL( aStreamId )->
+ ConnectionL( aConnectionId )->SetReceivingStateL( aState );
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::SetAcceptedFromAddressL
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CNcmConnectionMultiplexer::SetAcceptedFromAddressL(
+ TUint aStreamId, TUint aConnectionId, const TInetAddr& aAddress )
+ {
+ __CONNECTIONMULTIPLEXER_INT2(
+ "CNcmConnectionMultiplexer::SetAcceptedFromAddressL - \
+ aStreamId:", aStreamId, "aConnectionId: ", aConnectionId )
+
+ StreamByIdL( aStreamId )->
+ ConnectionL( aConnectionId )->SetAcceptedFromAddressL( aAddress );
+ }
+
+
+// ---------------------------------------------------------------------------
+// From class MNcmMultiplexerConnectionObserver
+//
+// CNcmConnectionMultiplexer::ConnectionError
+// ---------------------------------------------------------------------------
+//
+void CNcmConnectionMultiplexer::ConnectionError(
+ TUint aSessionId, TUint aStreamId, TUint aConnectionId,
+ TMultiplexerConnectionNotifyType aNotifyType, TInt aError )
+ {
+ __CONNECTIONMULTIPLEXER_INT1(
+ "CNcmConnectionMultiplexer::ConnectionError - ERROR: ", aError )
+
+ CNcmStream* stream( StreamById( aStreamId ) );
+
+ if ( stream )
+ {
+ // Notify connection observers
+ stream->ConnectionObserverHandler().
+ ConnectionNotify( aStreamId, aConnectionId, aNotifyType, aError );
+
+ // Lets notify stream user
+ iObserver.Notify( aSessionId, aStreamId,
+ MNcmConnectionMultiplexerObserver::EStreamError, aError );
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// From class MNcmMultiplexerConnectionObserver
+//
+// CNcmConnectionMultiplexer::GetNewFreePort
+// ---------------------------------------------------------------------------
+//
+void CNcmConnectionMultiplexer::GetNewFreePort( TUint aStreamId,
+ TUint aConnectionId, TUint& aPort )
+ {
+ __CONNECTIONMULTIPLEXER(
+ "CNcmConnectionMultiplexer::GetNewFreePort" )
+
+ TRAP_IGNORE( GetNewFreePortL( aStreamId, aConnectionId, aPort ) )
+ }
+
+
+// ---------------------------------------------------------------------------
+// From class MNcmMultiplexerConnectionObserver
+//
+// CNcmConnectionMultiplexer::ConnectionNotify
+// ---------------------------------------------------------------------------
+//
+void CNcmConnectionMultiplexer::ConnectionNotify( TUint aStreamId,
+ TUint aConnectionId, TMultiplexerConnectionNotifyType aType,
+ TInt aError )
+ {
+ __CONNECTIONMULTIPLEXER_INT2(
+ "CNcmConnectionMultiplexer::ConnectionNotify - \
+ aStreamId:", aStreamId, "aConnectionId: ", aConnectionId )
+ __CONNECTIONMULTIPLEXER_INT2(
+ "CNcmConnectionMultiplexer::ConnectionNotify - \
+ aType:", aType, "aError: ", aError )
+
+ TRAP_IGNORE( this->ConnectionNotifyL( aStreamId, aConnectionId, aType,
+ aError ) )
+ }
+
+
+// ---------------------------------------------------------------------------
+// From class MNcmMultiplexerConnectionObserver
+//
+// CNcmConnectionMultiplexer::ConnectionNotifyL
+// ---------------------------------------------------------------------------
+//
+void CNcmConnectionMultiplexer::ConnectionNotifyL( TUint aStreamId,
+ TUint aConnectionId, TMultiplexerConnectionNotifyType aType,
+ TInt aError )
+ {
+ __CONNECTIONMULTIPLEXER(
+ "CNcmConnectionMultiplexer::ConnectionNotifyL" )
+
+ TNcmCallBack callback( HandleCallBack, *this, aStreamId, aConnectionId,
+ aType, aError );
+ iAsyncCallback->AddCallBackL( callback );
+ }
+
+
+// ---------------------------------------------------------------------------
+// From class MNcmMultiplexerConnectionObserver
+//
+// CNcmConnectionMultiplexer::GetNewFreePortL
+// ---------------------------------------------------------------------------
+//
+void CNcmConnectionMultiplexer::GetNewFreePortL( TUint aStreamId,
+ TUint /*aConnectionId*/, TUint& aPort )
+ {
+ __CONNECTIONMULTIPLEXER(
+ "CNcmConnectionMultiplexer::GetNewFreePortL" )
+
+ aPort = SessionByStreamIdL( aStreamId )->PortStore().Port();
+ }
+
+
+// ---------------------------------------------------------------------------
+// From class MNcmSessionObserver
+//
+// Called as a result for CreateSessionL() when wrapper is connected
+// ---------------------------------------------------------------------------
+//
+void CNcmConnectionMultiplexer::SessionCreationFailed( TUint aSessionId )
+ {
+ __CONNECTIONMULTIPLEXER(
+ "CNcmConnectionMultiplexer::SessionCreationFailed" )
+
+ TRAP_IGNORE( RemoveSessionL( aSessionId ) )
+ }
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::SessionByIdL()
+// ---------------------------------------------------------------------------
+//
+CNcmSession* CNcmConnectionMultiplexer::SessionByIdL(
+ TUint aSessionId )
+ {
+ TInt ind( iSessions.Count() );
+
+ while ( ind-- )
+ {
+ if ( iSessions[ind]->SessionId() == aSessionId )
+ {
+ return iSessions[ind];
+ }
+ }
+
+ User::Leave( KErrNotFound );
+#ifndef _DEBUG_EUNIT
+ return NULL;
+#endif
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::StreamByIdL()
+// ---------------------------------------------------------------------------
+//
+CNcmStream* CNcmConnectionMultiplexer::StreamByIdL(
+ TUint aStreamId )
+ {
+ TInt sessInd( iSessions.Count() );
+
+ while ( sessInd-- )
+ {
+ CNcmStream* stream = iSessions[sessInd]->
+ StreamByIdL( aStreamId );
+
+ if ( stream )
+ {
+ return stream;
+ }
+ }
+
+ User::Leave( KErrNotFound );
+#ifndef _DEBUG_EUNIT
+ return NULL;
+#endif
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::StreamById()
+// ---------------------------------------------------------------------------
+//
+CNcmStream* CNcmConnectionMultiplexer::StreamById(
+ TUint aStreamId )
+ {
+ CNcmStream* stream( NULL );
+
+ TRAP_IGNORE( ( stream = StreamByIdL( aStreamId ) ) )
+
+ return stream;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::SessionByStreamIdL()
+// ---------------------------------------------------------------------------
+//
+CNcmSession* CNcmConnectionMultiplexer::SessionByStreamIdL(
+ TUint aStreamId )
+ {
+ TInt sessInd( iSessions.Count() );
+
+ while ( sessInd-- )
+ {
+ CNcmStream* stream = iSessions[sessInd]->
+ StreamByIdL( aStreamId );
+
+ if ( stream )
+ {
+ return iSessions[sessInd];
+ }
+ }
+
+ User::Leave( KErrNotFound );
+#ifndef _DEBUG_EUNIT
+ return NULL;
+#endif
+ }
+
+
+// ---------------------------------------------------------------------------
+// From class MNcmMediaSourceObserver
+//
+// CNcmConnectionMultiplexer::WrapperSenderError
+// ---------------------------------------------------------------------------
+//
+void CNcmConnectionMultiplexer::WrapperSenderError( TUint aStreamId,
+ TInt aError )
+ {
+ __CONNECTIONMULTIPLEXER_INT1(
+ "CNcmConnectionMultiplexer::WrapperSenderObserver - Error: ", aError )
+
+ TUint connectionId( 0 );
+
+ TRAP_IGNORE( ( connectionId = StreamByIdL( aStreamId )->
+ MediaConnectionId() ) )
+
+ this->ConnectionNotify( aStreamId, connectionId,
+ EMultiplexerConnectionError, aError );
+ }
+
+
+// ---------------------------------------------------------------------------
+// From class MNcmMediaSourceObserver
+//
+// CNcmConnectionMultiplexer::GetFreePort
+// ---------------------------------------------------------------------------
+//
+void CNcmConnectionMultiplexer::GetFreePort( TUint aStreamId, TUint& aPort )
+ {
+ __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::GetFreePort" )
+
+ TRAP_IGNORE( ( aPort = SessionByStreamIdL(
+ aStreamId )->PortStore().Port() ) )
+ }
+
+
+// ---------------------------------------------------------------------------
+// From class MNcmMediaSourceObserver
+//
+// CNcmConnectionMultiplexer::FirstMediaPacketSent
+// ---------------------------------------------------------------------------
+//
+void CNcmConnectionMultiplexer::FirstMediaPacketSent( TUint aStreamId )
+ {
+ __CONNECTIONMULTIPLEXER_INT1(
+ "CNcmConnectionMultiplexer::FirstMediaPacketSent- aStreamId: ", aStreamId )
+
+ TInt connectionId( 0 );
+
+ TRAP_IGNORE(
+ ( connectionId = StreamByIdL( aStreamId )->MediaConnectionId() ) )
+
+ TRAP_IGNORE( this->ConnectionNotifyL( aStreamId, connectionId,
+ EMultiplexerFirstMediaPacketSent, KErrNone ) )
+ }
+
+
+// ---------------------------------------------------------------------------
+// From class MNcmAsyncCallbackObserver
+//
+// CNcmConnectionMultiplexer::HandleCallBack
+// ---------------------------------------------------------------------------
+//
+void CNcmConnectionMultiplexer::HandleCallBack( CBase& aObject,
+ TUint aStreamId, TUint aConnectionId,
+ TMultiplexerConnectionNotifyType aType, TInt aError )
+ {
+ CNcmConnectionMultiplexer& connMux(
+ static_cast<CNcmConnectionMultiplexer&>( aObject ) );
+
+ TRAP_IGNORE( connMux.HandleCallBackL( aStreamId,
+ aConnectionId,
+ aType,
+ aError ) )
+ }
+
+
+// ---------------------------------------------------------------------------
+// CNcmConnectionMultiplexer::HandleCallBackL
+// ---------------------------------------------------------------------------
+//
+void CNcmConnectionMultiplexer::HandleCallBackL( TUint aStreamId,
+ TUint aConnectionId, TMultiplexerConnectionNotifyType aType, TInt aError )
+ {
+ __CONNECTIONMULTIPLEXER( "CNcmConnectionMultiplexer::HandleCallBackL" )
+
+ CNcmStream* stream( StreamByIdL( aStreamId ) );
+ TUint sessionId( SessionByStreamIdL( aStreamId )->SessionId() );
+
+ switch ( aType )
+ {
+ case EMultiplexerMediaReceivingActivated:
+ {
+ iObserver.Notify( sessionId, aStreamId,
+ MNcmConnectionMultiplexerObserver::
+ EReceivingActivated, aError );
+ break;
+ }
+ case EMultiplexerMediaReceivingDeactivated:
+ {
+ MNATFWMediaWrapper* wrapper = stream->WrapperL();
+ wrapper->SetReceivingStateForMuxWrapper( EStreamingStateActive );
+ iObserver.Notify( sessionId, aStreamId,
+ MNcmConnectionMultiplexerObserver::
+ EReceivingDeactivated, aError );
+ break;
+ }
+ case EMultiplexerMediaSendingActivated:
+ {
+ iObserver.Notify( sessionId, aStreamId,
+ MNcmConnectionMultiplexerObserver::
+ ESendingActivated, aError );
+ break;
+ }
+ case EMultiplexerMediaSendingDeactivated:
+ {
+ MNATFWMediaWrapper* wrapper = stream->WrapperL();
+ wrapper->SetReceivingStateForMuxWrapper( EStreamingStatePassive );
+ iObserver.Notify( sessionId, aStreamId,
+ MNcmConnectionMultiplexerObserver::
+ ESendingDeactivated, aError );
+ break;
+ }
+
+ case EMultiplexerReceivingActivated:
+ case EMultiplexerSendingActivated:
+ case EMultiplexerReceivingDeactivated:
+ case EMultiplexerSendingDeactivated:
+ case EMultiplexerConnectionRemoved:
+ case EMultiplexerTcpSetupCompleted:
+ case EMultiplexerFirstMediaPacketSent:
+ {
+ stream->ConnectionObserverHandler().
+ ConnectionNotify( aStreamId, aConnectionId, aType, aError );
+ break;
+ }
+
+ case EMultiplexerConnectionError:
+ {
+ if( aConnectionId == stream->MediaConnectionId() )
+ {
+ iObserver.Notify( sessionId, aStreamId,
+ MNcmConnectionMultiplexerObserver::EStreamError,
+ aError );
+ }
+
+ stream->ConnectionObserverHandler().
+ ConnectionNotify( aStreamId, aConnectionId, aType, aError );
+ break;
+ }
+ }
+ }