/*

* 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,