/*

* Copyright (c) 2007 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:  Controller class implementation

*

*/

#include <sdpdocument.h>

#include <random.h>

#include <centralrepository.h>

#include <unsafprotocolscrkeys.h>

#include <e32math.h>

#include <badesca.h>

#include "natfwconnectivityapi.h"

#include "natfwcandidate.h"

#include "natfwcandidatepair.h"

#include "nspsessionobserver.h"

#include "nspcontroller.h"

#include "nspsession.h"

#include "nspevents.h"

#include "nspactive.h"

#include "nspcontentparser.h"

#include "nspdefs.h"

// CONSTANTS

//_LIT8( KStun, "stun" );

//_LIT8( KTurn, "turn" );

_LIT8( KIce, "ice" );

_LIT8( KNSPCharStore,

"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+/" );

_LIT8( KNSPSingleDigit, "x" );

const TText8* const KComma = _S8( "," );

const TUint KCommaLength = 1;

const TText8* const KDot = _S8( "." );

const TUint KNSPSingleDigitLength = 1;

const TUint KNSPUsernameMinLength = 4;

const TUint KNSPPasswordMinLength = 22;

const TUint KNSPVariationLength = 4;

const TUint KDefaultUpdateSdpTimerValue = 10;

static TDesC8& TrimAll( HBufC8& aDes )

    {

    TPtr8 ptr( aDes.Des() );

    ptr.TrimAll();

    return aDes;

    }

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

// CNSPController::CNSPController

// ---------------------------------------------------------------------------

//

CNSPController::CNSPController()

    {    

    }

// ---------------------------------------------------------------------------

// CNSPController::ConstructL

// ---------------------------------------------------------------------------

//

void CNSPController::ConstructL()

    {

    NSPLOG_STR( "CNSPController::ConstructL(), Entry" )

    iInterface = CNATFWConnectivityApi::NewL();

    iInterface->RegisterObserverForEventsL(

        *this, MNATFWConnectivityObserver::EAllEvents );

    iContentParser = CNSPContentParser::NewL();

    iBase = Abs( static_cast<TInt>( Math::Random() ) );

    NSPLOG_STR( "CNSPController::ConstructL(), Exit" )

    }

// ---------------------------------------------------------------------------

// CNSPController::NewL

// ---------------------------------------------------------------------------

//

CNSPController* CNSPController::NewL()

    {

    CNSPController* self = CNSPController::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// CNSPController::NewLC

// ---------------------------------------------------------------------------

//

CNSPController* CNSPController::NewLC()

    {

    CNSPController* self = new ( ELeave ) CNSPController;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// ---------------------------------------------------------------------------

// CNSPController::~CNSPController

// ---------------------------------------------------------------------------

//

CNSPController::~CNSPController()

    {

    NSPLOG_STR( "CNSPController::~CNSPController(), Entry" )

    iActiveObjects.ResetAndDestroy();

    iActiveObjects.Close();    

    iSessionArray.ResetAndDestroy();

    iSessionArray.Close();

    iClosingSessionArray.ResetAndDestroy();

    iClosingSessionArray.Close();

    delete iContentParser;

    if ( iInterface )

        {

        iInterface->UnregisterObserverForEvents(

            *this, MNATFWConnectivityObserver::EAllEvents );

        }

    delete iInterface;

    NSPLOG_STR( "CNSPController::~CNSPController(), Exit" )

    }

// ---------------------------------------------------------------------------

// CNSPController::EventOccured

// ---------------------------------------------------------------------------

//

void CNSPController::EventOccured( TUint aSessionId, TUint aStreamId,

        TNATFWConnectivityEvent aEvent, TInt aError, TAny* aEventData )

    {

    NSPLOG_STR( "CNSPController::EventOccured(), Entry" )

    TInt index = FindSession( aSessionId );

    if ( KErrNotFound != index )

        {

        TEventReturnStatus status = iSessionArray[index]->EventOccured(

        		aStreamId, aEvent, aError, aEventData );

        Callback( *iSessionArray[index], status );

        }

    else

        {

        index = FindClosingSession( aSessionId );

        if ( KErrNotFound != index )

            {

            TEventReturnStatus status = iClosingSessionArray[index]->EventOccured(

                    aStreamId, aEvent, aError, aEventData );

            if ( NSP_DELETE( status.iStatus ) || NSP_ERROR( status.iStatus ) )

                {

                delete iClosingSessionArray[index];

                iClosingSessionArray.Remove(index);

                iClosingSessionArray.Close();

                RemoveActiveObjects( aSessionId );

                }

            }

        else

            {

            NSPLOG_STR( "CNSPController::EventOccured(), KErrNotFound" )

            NSPLOG_INT( "CNSPController::EventOccured(), error:", aError )

            }

        }

    NSPLOG_STR( "CNSPController::EventOccured(), Exit" )

    }

// ---------------------------------------------------------------------------

// CNSPController::ContentParser

// ---------------------------------------------------------------------------

//

const CNSPContentParser& CNSPController::ContentParser()

    {

    return (*iContentParser);

    }

// ---------------------------------------------------------------------------

// CNSPController::CreateSessionL

// ---------------------------------------------------------------------------

//

TUint CNSPController::CreateSessionL( TUint32 aIapId, const TDesC8& aDomain )

    {

    return iInterface->CreateSessionL( aIapId, aDomain );

    }

// ---------------------------------------------------------------------------

// CNSPController::LoadPluginL

// ---------------------------------------------------------------------------

//

void CNSPController::LoadPluginL( TUint aSessionId, const CDesC8Array& aPlugins,

        TInt& aPluginIndex )

    {

    iInterface->LoadPluginL( aSessionId, aPlugins, aPluginIndex );

    }

// ---------------------------------------------------------------------------

// CNSPController::CreateStreamL

// ---------------------------------------------------------------------------

//

TUint CNSPController::CreateStreamL( TUint aSessionId, TUint aProtocol, TInt aQoS )

    {

    return iInterface->CreateStreamL( aSessionId, aProtocol, aQoS );

    }

// ---------------------------------------------------------------------------

// CNSPController::CreateWrapperL

// ---------------------------------------------------------------------------

//

MNATFWSocketMediaConnWrapper& CNSPController::CreateWrapperL( 

        TUint aSessionId, TUint aStreamId )

    {

    return iInterface->CreateWrapperL( aSessionId, aStreamId );

    }

// ---------------------------------------------------------------------------

// CNSPController::FetchCandidateL

// ---------------------------------------------------------------------------

//

void CNSPController::FetchCandidateL( TUint aSessionId, TUint aStreamId,

        TUint aAddrFamily )

    {

    iInterface->FetchCandidateL( aSessionId, aStreamId, aAddrFamily );

    }

// ---------------------------------------------------------------------------

// CNSPController::FetchCandidatesL

// ---------------------------------------------------------------------------

//

void CNSPController::FetchCandidatesL( TUint aSessionId, TUint aStreamId,

        TUint aCollectionId, TUint aComponentId, TUint aAddrFamily )

    {

    iInterface->FetchCandidatesL( aSessionId, aStreamId,

            aCollectionId, aComponentId, aAddrFamily );

    }

// ---------------------------------------------------------------------------

// CNSPController::SetReceivingStateL

// ---------------------------------------------------------------------------

//

void CNSPController::SetReceivingStateL( const CNATFWCandidate& aLocalCand,

        TNATFWStreamingState aState )

    {

    iInterface->SetReceivingStateL( aLocalCand, aState );

    }

// ---------------------------------------------------------------------------

// CNSPController::SetSendingStateL

// ---------------------------------------------------------------------------

//

void CNSPController::SetSendingStateL( const CNATFWCandidate& aLocalCand,

        TNATFWStreamingState aState, const TDesC8& aDestAddr, TUint aPort )

    {

    iInterface->SetSendingStateL( aLocalCand, aState, aDestAddr, aPort );

    }

// ---------------------------------------------------------------------------

// CNSPController::SetRoleL

// ---------------------------------------------------------------------------

//

void CNSPController::SetRoleL( TUint aSessionId, TNATFWIceRole aRole )

    {

    iInterface->SetRoleL( aSessionId, aRole );

    }

// ---------------------------------------------------------------------------

// CNSPController::SetCredentialsL

// ---------------------------------------------------------------------------

//

void CNSPController::SetCredentialsL( TUint aSessionId, TUint aStreamId,

        const CNATFWCredentials& aCredentials )

    {

    CNATFWCandidate* dummyCand = CNATFWCandidate::NewLC();

    dummyCand->SetSessionId( aSessionId );

    dummyCand->SetStreamId( aStreamId );

    iInterface->SetCredentialsL( *dummyCand, aCredentials );

    CleanupStack::PopAndDestroy( dummyCand );

    }

// ---------------------------------------------------------------------------

// CNSPController::PerformCandidateChecksL

// ---------------------------------------------------------------------------

//

void CNSPController::PerformCandidateChecksL( TUint aSessionId,

        RPointerArray<CNATFWCandidate>& aRemoteCandidates )

    {

    iInterface->PerformConnectivityChecksL( aSessionId, aRemoteCandidates );

    }

// ---------------------------------------------------------------------------

// CNSPController::UpdateIceProcessingL

// ---------------------------------------------------------------------------

//

void CNSPController::UpdateIceProcessingL( TUint aSessionId,

        RPointerArray<CNATFWCandidate>& aNewRemoteCands )

    {

    iInterface->UpdateIceProcessingL( aSessionId, aNewRemoteCands );

    }

// ---------------------------------------------------------------------------

// CNSPController::CloseStreamL

// ---------------------------------------------------------------------------

//

void CNSPController::CloseStreamL( TUint aSessionId, TUint aStreamId )

    {

    iInterface->CloseStreamL( aSessionId, aStreamId );

    }

// ---------------------------------------------------------------------------

// CNSPController::CloseSessionL

// ---------------------------------------------------------------------------

//

void CNSPController::CloseSessionL( TUint aSessionId )

    {

    iInterface->CloseSessionL( aSessionId );

    }

// ---------------------------------------------------------------------------

// CNSPController::CreateUniqueId

// ---------------------------------------------------------------------------

//

TUint CNSPController::CreateUniqueId()

    {

    return (iBase++);

    }

// ---------------------------------------------------------------------------

// CNSPController::OrderTimeoutL

// ---------------------------------------------------------------------------

//

TUint CNSPController::OrderTimeoutL( TUint aSessionId, TUint aStreamId,

        MNATFWConnectivityObserver::TNATFWConnectivityEvent aEvent,

        TUint aTimerInMicroSeconds )

    {

    CNSPActive* callback = NULL;

    const TInt index = FindSession( aSessionId );

    const TUint transactionId = CreateUniqueId();

    if ( KErrNotFound != index )

        {

        TRAPD( error, callback = CNSPActive::NewL( *this,

                aSessionId, aStreamId, transactionId, aEvent,

                aTimerInMicroSeconds, NULL ) );

        User::LeaveIfError( error );

        error = iActiveObjects.Append( callback );

        if ( KErrNone != error )

            {

            delete callback;

            User::LeaveIfError( error );

            }

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    return transactionId;

    }

// ---------------------------------------------------------------------------

// CNSPController::OrderUpdateSdpL

// ---------------------------------------------------------------------------

//

TUint CNSPController::OrderUpdateSdpL( TUint aSessionId, CSdpDocument* aDoc )

    {

    CNSPActive* callback = NULL;

    const TInt index = FindSession( aSessionId );

    const TUint transactionId = CreateUniqueId();

    if ( KErrNotFound != index )

        {

        CleanupStack::PushL( aDoc );

        callback = CNSPActive::NewL( *this,

                aSessionId, (TUint) KErrNone, transactionId,

                (MNATFWConnectivityObserver::TNATFWConnectivityEvent) KErrNone,

                KDefaultUpdateSdpTimerValue, aDoc );

        CleanupStack::Pop( aDoc );

        CleanupStack::PushL( callback );

        iActiveObjects.AppendL( callback );

        CleanupStack::Pop( callback );

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    return transactionId;

    }

// ---------------------------------------------------------------------------

// CNSPController::Cancel

// ---------------------------------------------------------------------------

//

void CNSPController::Cancel( TUint aTransactionId )

    {

    const TInt index = FindActiveObject( aTransactionId );

    if ( KErrNotFound != index )

        {

        iActiveObjects[index]->Cancel();

        delete (iActiveObjects[index]);

        iActiveObjects.Remove(index);

        iActiveObjects.Compress();

        }

    }

// ---------------------------------------------------------------------------

// CNSPController::GenerateUsernameL

// ---------------------------------------------------------------------------

//

void CNSPController::GenerateUsernameL( TDes8& aUsername )

    {

    aUsername.Zero();

    TInt newlength = KNSPUsernameMinLength +

                     RandomByteL() % KNSPVariationLength;

    __ASSERT_ALWAYS( aUsername.MaxLength() >= newlength,

                     User::Leave( KErrArgument ) );

    for ( TInt index = 0; index < newlength; index++ )

        {

        aUsername.Append( KNSPCharStore()[

                RandomByteL() % KNSPCharStore().Length() ] );

        }

    }

// ---------------------------------------------------------------------------

// CNSPController::GeneratePasswordL

// ---------------------------------------------------------------------------

//

void CNSPController::GeneratePasswordL( TDes8& aPassword )

    {

    aPassword.Zero();

    TInt newlength = KNSPPasswordMinLength +

                     RandomByteL() % KNSPVariationLength;    

    __ASSERT_ALWAYS( aPassword.MaxLength() >= newlength,

                     User::Leave( KErrArgument ) );

    for ( TInt index = 0; index < newlength; index++ )

        {

        aPassword.Append( KNSPCharStore()[

                RandomByteL() % KNSPCharStore().Length() ] );

        }

    }

// ---------------------------------------------------------------------------

// CNSPController::NewSessionL

// ---------------------------------------------------------------------------

//

TUint CNSPController::NewSessionL( MNSPSessionObserver& aSessionObserver,

        TUint32 aIapId, const TDesC8& aDomain, TUint aProtocol )

    {

    NSPLOG_STR( "CNSPController::NewSessionL(), Entry" )

    CNSPSession* session = CNSPSession::NewLC( *this,

            aSessionObserver, aIapId, aDomain, aProtocol );

    session->SetUseIce( UseIceL( session->Plugins(), aDomain ) );

    User::LeaveIfError( iSessionArray.Append( session ) );

    CleanupStack::Pop( session );

    NSPLOG_STR( "CNSPController::NewSessionL(), Exit" )

    return session->SessionId();

    }

// ---------------------------------------------------------------------------

// CNSPController::CloseSessionL

// ---------------------------------------------------------------------------

//

void CNSPController::ClosingSessionL( TUint aSessionId )

    {

    const TInt index = FindSession( aSessionId );

    if ( KErrNotFound != index )

        {

        CNSPSession* session = iSessionArray[index];

        iSessionArray.Remove(index);

        iSessionArray.Compress();

        CleanupStack::PushL( session );

        TNatReturnStatus status = session->CloseSessionL();

        if ( KNatReady == status )

            {

            CleanupStack::Pop( session );

            delete session;