/*

* Copyright (c) 2006-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:    Storage for session related data.

*

*/

#include <e32math.h>

#include "natfwcredentials.h"

#include "natfwcandidate.h"

#include "natfwcandidatepair.h"

#include "mnatfwpluginobserver.h"

#include "cicesessiondata.h"

#include "cicestreamcollection.h"

#include "icecandidatehandlerdefs.h"

#include "icecandidatehandlerlogs.h"

const TUint KInitialIdentifierLength = 16;

_LIT8( KColon, ":" );

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

CIceSessionData::CIceSessionData( TUint32 aIapId )

    :

    iIapId( aIapId )

    {

    __ICEDP( "CIceSessionData::CIceSessionData" )

    }

void CIceSessionData::ConstructL( const TDesC8& aDomain )

    {

    __ICEDP( "CIceSessionData::ConstructL" )

    iTempIdentifier.CreateL( KInitialIdentifierLength );

    iDomain = aDomain.AllocL();

    }

CIceSessionData* CIceSessionData::NewL(

        const TDesC8& aDomain, TUint32 aIapId )

    {

    __ICEDP( "CIceSessionData::NewL" )

    CIceSessionData* self 

        = CIceSessionData::NewLC( aDomain, aIapId );

    CleanupStack::Pop( self );

    return self;

    }

CIceSessionData* CIceSessionData::NewLC(

        const TDesC8& aDomain, TUint32 aIapId )

    {

    __ICEDP( "CIceSessionData::NewLC" )

    CIceSessionData* self 

        = new ( ELeave ) CIceSessionData( aIapId );

    CleanupStack::PushL( self );

    self->ConstructL( aDomain );

    return self;

    }

CIceSessionData::~CIceSessionData()

    {

    __ICEDP( "CIceSessionData::~CIceSessionData" )

    iStreamCollections.ResetAndDestroy();  

    iLocalCandidateList.ResetAndDestroy();

    iRemoteCandidateList.ResetAndDestroy();

    iCredentialsList.ResetAndDestroy();

    iTempIdentifier.Close();

    delete iDomain;

    }

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

// CIceSessionData::AddPeerReflexiveCandidateL

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

//

void CIceSessionData::AddPeerReflexiveCandidateL( 

        CNATFWCandidate* aPeerCandidate, TBool aIsRemoteCand )

    {

    __ICEDP( "CIceSessionData::AddPeerReflexiveCandidateL" )

    __ASSERT_DEBUG( aPeerCandidate, User::Leave( KErrArgument ) );

    CleanupStack::PushL( aPeerCandidate );

    if ( aIsRemoteCand )

        {

        TInt ind( iRemoteCandidateList.Count() );

        while ( ind-- )

            {

            if ( TIceUtils::MatchAddresses( 

                    iRemoteCandidateList[ind]->TransportAddr(),

                    aPeerCandidate->TransportAddr() ) )

                {

                CleanupStack::PopAndDestroy( aPeerCandidate );

                return;

                }

            }

        // Assign arbitrary foundation (ICE-17, 7.2.1.3.)

        do 

            {

            const TDesC8& foundation = GenerateRandomIdentifier();

            aPeerCandidate->SetFoundationL( foundation );

            } while ( KErrNotFound != iRemoteCandidateList.Find( 

                aPeerCandidate, CNATFWCandidate::CompareFoundations ) );

        iRemoteCandidateList.AppendL( aPeerCandidate );

        CleanupStack::Pop( aPeerCandidate );

        }

    else

        {

        if ( !IsRedundantCandidate( *aPeerCandidate, iLocalCandidateList ) )

            {

            AssignFoundationForCandidateL( *aPeerCandidate );

            iLocalCandidateList.AppendL( aPeerCandidate );

            CleanupStack::Pop( aPeerCandidate );

            }

        else

            {

            CleanupStack::PopAndDestroy( aPeerCandidate );

            }

        }

    }

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

// CIceSessionData::FindLocalCandidate

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

//

const CNATFWCandidate* CIceSessionData::FindLocalCandidate( 

        const TInetAddr& aTransportAddr ) const

    {

    TInt count( iLocalCandidateList.Count() );

    for ( TInt i = 0; i < count; i++ )

        {

        const CNATFWCandidate* curItem = iLocalCandidateList[i];

        if ( TIceUtils::MatchAddresses( 

                curItem->TransportAddr(), aTransportAddr ) )

            {

            return curItem;

            }

        }

    return NULL;

    }

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

// CIceSessionData::FindLocalCandidate

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

//

const CNATFWCandidate* CIceSessionData::FindLocalCandidate( 

        TUint aStreamCollectionId,

        TUint aComponentId,

        CNATFWCandidate::TCandidateType aType ) const

    {

    TInt count( iLocalCandidateList.Count() );

    for ( TInt i = 0; i < count; i++ )

        {

        const CNATFWCandidate* curItem = iLocalCandidateList[i];

        if ( curItem->StreamCollectionId() == aStreamCollectionId 

            && curItem->ComponentId() == aComponentId

            && curItem->Type() == aType )

            {

            return curItem;

            }

        }

    return NULL;

    }

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

// CIceSessionData::FindRemoteCandidate

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

//

const CNATFWCandidate* CIceSessionData::FindRemoteCandidate( 

        const TInetAddr& aTransportAddr ) const

    {

    TInt count( iRemoteCandidateList.Count() );

    for ( TInt i = 0; i < count; i++ )

        {

        const CNATFWCandidate* curItem = iRemoteCandidateList[i];

        if ( TIceUtils::MatchAddresses( 

                curItem->TransportAddr(), aTransportAddr ) )

            {

            return curItem;

            }

        }

    return NULL;

    }

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

// CIceSessionData::GetLocalCandidates

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

//

void CIceSessionData::GetLocalCandidates(

                const TUint aStreamCollectionId,

                const TUint aStreamId,

                RPointerArray<CNATFWCandidate>& aLocalCandidates )

    {

    __ICEDP( "CIceSessionData::GetLocalCandidates" )

    for ( TInt i = 0; i < iLocalCandidateList.Count(); i++ )

        {

        if ( iLocalCandidateList[i]->StreamCollectionId() 

                == aStreamCollectionId

            && iLocalCandidateList[i]->StreamId() == aStreamId ) 

            {

            aLocalCandidates.Append( iLocalCandidateList[i] );

            }

        }

    }

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

// CIceSessionData::GetLocalCandidates

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

//    

void CIceSessionData::GetLocalCandidates( 

        const TUint aStreamCollectionId,

        RPointerArray<CNATFWCandidate>& aLocalCandidates )

    {

    __ICEDP( "CIceSessionData::GetLocalCandidates" )

    for ( TInt i = 0; i < iLocalCandidateList.Count(); i++ )

        {

        if ( iLocalCandidateList[i]->StreamCollectionId() 

                == aStreamCollectionId ) 

            {

            aLocalCandidates.Append( iLocalCandidateList[i] );

            }

        }

    }

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

// CIceSessionData::GetLocalCandidates

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

//

void CIceSessionData::GetLocalCandidates(

                     RPointerArray<CNATFWCandidate>& aLocalCandidates )

    {

    __ICEDP( "CIceSessionData::GetLocalCandidates" )

    for ( TInt i = 0; i < iLocalCandidateList.Count(); i++ )

        {

        aLocalCandidates.Append( iLocalCandidateList[i] );

        }

    }

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

// CIceSessionData::DeleteCollection

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

//

void CIceSessionData::DeleteCollection( TUint aStreamCollectionId )

    { 

    __ICEDP( "CIceSessionData::DeleteCollection" )

    CIceStreamCollection* collection 

        = FindStreamCollectionById( aStreamCollectionId );

    if ( collection )

        {

        TInt ind( iStreamCollections.Find( collection ) );

        iStreamCollections.Remove( ind );

        delete collection;

        }

    }

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

// CIceSessionData::AddCredentialsL

// Existing credentials for a stream is replaced with the new one.

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

//    

void CIceSessionData::AddCredentialsL(

        const CNATFWCredentials& aCredentials )

    {

    __ICEDP( "CIceSessionData::AddCredentialsL" )

    TBool existingCredentialsFound( EFalse );

    TInt credentialsInd( iCredentialsList.Count() - 1 );

    while ( !existingCredentialsFound && 0 <= credentialsInd )

        {

        CNATFWCredentials* item = iCredentialsList[credentialsInd];

        if ( item->StreamCollectionId()

                == aCredentials.StreamCollectionId()

            && item->StreamId() == aCredentials.StreamId()

            && item->Direction() == aCredentials.Direction() )

            {

            existingCredentialsFound = ETrue;

            item->SetUsernameL( aCredentials.Username() );

            item->SetPasswordL( aCredentials.Password() );

            UpdateUserNamesL( *item );

            }

        credentialsInd--;

        }

    if ( !existingCredentialsFound )

        {

        CNATFWCredentials* newItem 

            = CNATFWCredentials::NewLC( aCredentials );

        UpdateUserNamesL( *newItem );

        iCredentialsList.AppendL( newItem );

        CleanupStack::Pop( newItem );

        }

    }

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

// CIceSessionData::Credentials

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

//

const RPointerArray<CNATFWCredentials>&

    CIceSessionData::Credentials() const

    {

    return iCredentialsList;

    }

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

// CIceSessionData::Credentials

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

//

const CNATFWCredentials* CIceSessionData::Credentials( 

        TUint aStreamId,

        CNATFWCredentials::TUtilizationDirection aDirection ) const

    {

    TInt count( iCredentialsList.Count() );

    for ( TInt i( 0 ); i < count; ++i )

        {

        if ( iCredentialsList[i]->StreamId() == aStreamId

            && iCredentialsList[i]->Direction() == aDirection )

            {

            return iCredentialsList[i];

            }

        }

    return NULL;

    }

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

// CIceSessionData::AddLocalCandidateL

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

//       

TBool CIceSessionData::AddLocalCandidateL(

        CNATFWCandidate* aLocalCandidate )

    {

    __ICEDP( "CIceSessionData::AddLocalCandidateL" )

    __ASSERT_DEBUG( aLocalCandidate, User::Leave( KErrArgument ) );

    CleanupStack::PushL( aLocalCandidate );

    TBool redundantCand 

        = IsRedundantCandidate( *aLocalCandidate, iLocalCandidateList );

    if ( !redundantCand )

        {

        AssignFoundationForCandidateL( *aLocalCandidate );

        iLocalCandidateList.AppendL( aLocalCandidate );

        CleanupStack::Pop( aLocalCandidate );

        }

    else

        {

        CleanupStack::PopAndDestroy( aLocalCandidate );

        }

    return redundantCand;

    }

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

// CIceSessionData::AddRemoteCandidateL

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

//       

void CIceSessionData::AddRemoteCandidateL( CNATFWCandidate* aRemoteCandidate )

    {

    __ICEDP( "CIceSessionData::AddRemoteCandidateL" )

    CleanupStack::PushL( aRemoteCandidate );

    __ASSERT_DEBUG( NULL != aRemoteCandidate, User::Leave( KErrArgument ) );

    if ( IsRedundantCandidate( *aRemoteCandidate, iRemoteCandidateList ) )

        {

        CleanupStack::PopAndDestroy( aRemoteCandidate );

        }

    else

        {

        iRemoteCandidateList.AppendL( aRemoteCandidate );

        CleanupStack::Pop( aRemoteCandidate );

        }

    }

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

// CIceSessionData::AddRemoteCandidatesL

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

//               

void CIceSessionData::AddRemoteCandidatesL( 

        RPointerArray<CNATFWCandidate>& aRemoteCandidates )

    {

    TInt numOfCandidates = aRemoteCandidates.Count();

    __ICEDP_INT1( "CIceSessionData::AddRemoteCandidatesL, COUNT:",

         numOfCandidates )

    __ASSERT_ALWAYS( 0 != numOfCandidates, User::Leave( KErrArgument ) );

    // check that there is not redundancy in input array

    RPointerArray<CNATFWCandidate> candidatesToComp;

    CleanupClosePushL( candidatesToComp );

    for ( TInt i(0); i < numOfCandidates; ++i )

        {

        candidatesToComp.AppendL( aRemoteCandidates[i] );

        }

    for ( TInt i(0); i < numOfCandidates; ++i )

        {

        candidatesToComp.Remove(0);

        if ( IsRedundantCandidate( *aRemoteCandidates[i], candidatesToComp ) )

            {

            __ICEDP( "CIceSessionData::AddRemoteCandidatesL, REDUNDANT" )

            User::Leave( KErrArgument );

            }

        }

    CleanupStack::PopAndDestroy( &candidatesToComp );

    // add previously unknown candidates to the list

    for ( TInt i(0); i < numOfCandidates; ++i )

        {

        if ( !IsRedundantCandidate( 

                *aRemoteCandidates[i], iRemoteCandidateList ) )

            {

            CNATFWCandidate* candidate 

                = CNATFWCandidate::NewLC( *aRemoteCandidates[i] );

            iRemoteCandidateList.AppendL( candidate );

            CleanupStack::Pop( candidate );

            }

        }

    }

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

// CIceSessionData::GetRemoteCandidatesL

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

//         

void CIceSessionData::GetRemoteCandidatesL( 

        const TUint aStreamCollectionId,

        RPointerArray<CNATFWCandidate>& aRemoteCandidates )

    {

    __ICEDP( "CIceSessionData::GetRemoteCandidatesL" )

    TInt counter = iRemoteCandidateList.Count();

    for ( TInt i = 0; i < counter; ++i )

        {

        if ( iRemoteCandidateList[i]->StreamCollectionId() 

                == aStreamCollectionId )

            {

            aRemoteCandidates.AppendL( iRemoteCandidateList[i] );

            }

        }

    }

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

// CIceSessionData::GetRemoteCandidatesL

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

//         

void CIceSessionData::GetRemoteCandidatesL( 

                const TUint aStreamCollectionId,

                const TUint aComponentId,

                RPointerArray<CNATFWCandidate>& aRemoteCandidates )

    {

    __ICEDP( "CIceSessionData::GetRemoteCandidatesL" )

    TInt count = iRemoteCandidateList.Count();

    for ( TInt i = 0; i < count;i++ )

        {

        if ( iRemoteCandidateList[i]->StreamCollectionId() 

                == aStreamCollectionId && 

            iRemoteCandidateList[i]->ComponentId() == aComponentId )

            {

            aRemoteCandidates.AppendL( iRemoteCandidateList[i] );

            }

        }

    }

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

// CIceSessionData::GetStreamCollectionIdsL

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

//

void CIceSessionData::GetStreamCollectionIdsL( 

        RArray<TUint>& aStreamCollIds ) const

    {

    __ICEDP( "CIceSessionData::GetStreamCollectionIdsL" )

    TInt count = iStreamCollections.Count();

    for ( TInt i = 0; i < count; i++ )

         {

         aStreamCollIds.AppendL( 

            iStreamCollections[i]->StreamCollectionId() );

         }

    }