/*

* Copyright (c) 2004 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:  

*

*/

//  CLASS HEADER

#include "ut_cnatfwstunsrvimpl.h"

//  EXTERNAL INCLUDES

#include <digia/eunit/eunitmacros.h>

//  INTERNAL INCLUDES

#include "natfwstunsrvimpl.h"

#include "cncmconnectionmultiplexer.h"

#include "natfwunsafbindingrequest.h"

#include "natfwcredentials.h"

#include "natfwunsafusernameattribute.h"

#include "natfwunsafattribute.h"

#include "natfwunsafpriorityattribute.h"

#include "natfwunsafusecandidateattribute.h"

#include "natfwunsafmessage.h"

#include "natfwunsafdataindication.h"

#include "natfwunsafdataattribute.h"

#include "natfwunsafbindingresponse.h"

#include "natfwunsafmappedaddressattribute.h"

#include "natfwunsafmagiccookieattribute.h"

#include "natfwunsaficecontrollingattribute.h"

#include "natfwunsaficecontrolledattribute.h"

#include "natfwunsaffingerprintattribute.h"

#include "natfwunsafbindingindication.h"

#include "natfwunittestmacros.h"

_LIT8( KUsername, "userB:userAA" );

_LIT8( KUsername2, "userB:userCC" );

_LIT8( KUsernameA, "userAA:" );

_LIT8( KTransactionId,"aaaabbbb");

_LIT8( KPassword,"aaaabbbbccccdddd");

_LIT8( KPassword2,"wrongpasswd");

_LIT( KRemoteAddress, "127.0.0.0" );

void ut_cnatfwstunsrvimpl::STUNRequestReceivedL( const TInetAddr& /*aLocalAddr*/,

    const TInetAddr& /*aFromAddr*/, const TInetAddr& /*aPeerAddr*/,

    TUint /*aPriority*/, TBool /*aRemoteFavored*/ )

    {    

    }

// CONSTRUCTION

ut_cnatfwstunsrvimpl* ut_cnatfwstunsrvimpl::NewL()

    {

    ut_cnatfwstunsrvimpl* self = ut_cnatfwstunsrvimpl::NewLC();

    CleanupStack::Pop();

    return self;

    }

ut_cnatfwstunsrvimpl* ut_cnatfwstunsrvimpl::NewLC()

    {

    ut_cnatfwstunsrvimpl* self = new( ELeave ) ut_cnatfwstunsrvimpl();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor (virtual by CBase)

ut_cnatfwstunsrvimpl::~ut_cnatfwstunsrvimpl()

    {

    }

// Default constructor

ut_cnatfwstunsrvimpl::ut_cnatfwstunsrvimpl()

    {

    }

// Second phase construct

void ut_cnatfwstunsrvimpl::ConstructL()

    {

    // The ConstructL from the base class CEUnitTestSuiteClass must be called.

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void ut_cnatfwstunsrvimpl::SetupL(  )

    {

    iConnMux = CNcmConnectionMultiplexer::NewL( *this );

    iStunSrvImpl = CNATFWSTUNSrvImpl::NewL( *this, *iConnMux ); 

    }

void ut_cnatfwstunsrvimpl::Teardown(  )

    {

    delete iStunSrvImpl;

    delete iConnMux;

    }

// Encodes requests

HBufC8* ut_cnatfwstunsrvimpl::EncodeMessageL( 

    const CNATFWUNSAFMessage& aRequest, const TBool aUseSharedSecret,

    const TBool aAddFingerPrint )

    {

    CBufBase* message = NULL;       

    if ( !aUseSharedSecret )

        {

        message = aRequest.EncodeL(); 

        }

    else if ( !aAddFingerPrint )

        {

        message = aRequest.EncodeL( KPassword );

        }

    else

        {

        // ETrue indicates that fingerprint attribute will be added

        message = aRequest.EncodeL( KPassword, ETrue );

        } 

    CleanupStack::PushL( message );

    TInt length = message->Size();

    HBufC8* readBuf = HBufC8::NewLC( length );

    TPtr8 writable( readBuf->Des() );

    message->Read( 0, writable, length );

    CleanupStack::Pop( readBuf );

    CleanupStack::PopAndDestroy( message );

    return readBuf;

    }

void ut_cnatfwstunsrvimpl::ut_cnatfwstunsrvimpl_AddAuthenticationParamsLL(  )

    {

    TBufC8<16> password( KPassword );

    TBufC8<7> usernameA( KUsernameA );    

    CNATFWCredentials* credential = CNATFWCredentials::NewLC();    

    credential->SetPasswordL( password );

    credential->SetUsernameL( usernameA ); 

    RPointerArray<CNATFWCredentials> identifications;

    identifications.Append( credential );

    CleanupClosePushL( identifications );

    NATFW_EUNIT_ASSERT_NO_LEAVE(

        iStunSrvImpl->AddAuthenticationParamsL( identifications ) );

    NATFW_EUNIT_ASSERT_NO_LEAVE( 

        iStunSrvImpl->AddAuthenticationParamsL( identifications ) );

    NATFW_EUNIT_ASSERT_NO_LEAVE( 

        iStunSrvImpl->RemoveAuthenticationParamsL( identifications ) );

    CleanupStack::PopAndDestroy( &identifications );

    CleanupStack::PopAndDestroy( credential );   

    }

void ut_cnatfwstunsrvimpl::ut_cnatfwstunsrvimpl_RemoveAuthenticationParamsL(  )

    {

    _LIT8( KUsernameA1, "userCC" );

    _LIT8( KPassword1,"aaaabbbbcccceeee");    

    TBufC8<16> password1( KPassword1 );

    TBufC8<7> usernameA1( KUsernameA1 );

    CNATFWCredentials* identification1 = CNATFWCredentials::NewLC();

    identification1->SetPasswordL( password1 );

    identification1->SetUsernameL( usernameA1 );

    TBufC8<12> username( KUsername );

    TBufC8<16> password( KPassword );

    TBufC8<7> usernameA( KUsernameA );

    CNATFWCredentials* credential = CNATFWCredentials::NewLC();

    credential->SetPasswordL( password );

    credential->SetUsernameL( usernameA );

    CNATFWCredentials* identification2 = CNATFWCredentials::NewLC();

    RPointerArray<CNATFWCredentials> identifications;

    CleanupClosePushL( identifications );

    identifications.Append( credential );

    identifications.Append( identification1 );

    NATFW_EUNIT_ASSERT_NO_LEAVE(

        iStunSrvImpl->AddAuthenticationParamsL( identifications ) );

    identifications.Append( identification2 );                                                                        

    iStunSrvImpl->RemoveAuthenticationParamsL( identifications ); 

    //identifications.ResetAndDestroy();

    CleanupStack::PopAndDestroy( &identifications );

    CleanupStack::PopAndDestroy( identification2 );

    CleanupStack::PopAndDestroy( credential );

    CleanupStack::PopAndDestroy( identification1 );

    }

void ut_cnatfwstunsrvimpl::ut_cnatfwstunsrvimpl_SetOperationModeLL()

    {

    TUint64 tieBraker = 32;

    NATFW_EUNIT_ASSERT_NO_LEAVE(

        iStunSrvImpl->SetRoleL( EIceRoleControlled, tieBraker ) );

    NATFW_EUNIT_ASSERT_NO_LEAVE(

        iStunSrvImpl->SetRoleL( EIceRoleControlling, tieBraker ) );

    }

void ut_cnatfwstunsrvimpl::ut_cnatfwstunsrvimpl_IncomingMessageLL(  )

    {               

    TBufC8<12> username( KUsername );

    TBufC8<16> password( KPassword );

    TBufC8<7> usernameA( KUsernameA );

    TBufC8<12> username2( KUsername2 );

    CNATFWCredentials* credential = CNATFWCredentials::NewLC();

    credential->SetPasswordL( password );

    credential->SetUsernameL( usernameA );

    CNATFWCredentials* identification2 = CNATFWCredentials::NewLC();

    identification2->SetPasswordL( password );

    identification2->SetUsernameL( username );

    CNATFWCredentials* identification3 = CNATFWCredentials::NewLC();

    identification3->SetPasswordL( password );

    identification3->SetUsernameL( username2 );

    RPointerArray<CNATFWCredentials> identifications;

    CleanupClosePushL( identifications );

    identifications.Append( credential );

    identifications.Append( identification2 );

    identifications.Append( identification3 );

    NATFW_EUNIT_ASSERT_NO_LEAVE(

        iStunSrvImpl->AddAuthenticationParamsL( identifications ) );  

    TNATFWUNSAFTransactionID transactionID;

    transactionID.Copy( KTransactionId );

    TBool consumed( EFalse );

    TUint streamId(0);

    TInetAddr localAddress;

    TInetAddr fromAddr;

    _LIT( KAddress, "127.0.0.0" );

    fromAddr.SetPort(250);

    fromAddr.Input( KAddress );

    TInetAddr peerRemoteAddress;

    CNATFWUNSAFBindingRequest* request =

        CNATFWUNSAFBindingRequest::NewLC( transactionID );

// Missing priority attribute  

    HBufC8* message = EncodeMessageL( *request );

    CleanupStack::PushL( message );

    NATFW_EUNIT_ASSERT_NO_LEAVE( iStunSrvImpl->IncomingMessageL( 

        streamId,  *message, localAddress, fromAddr, peerRemoteAddress, consumed ) ); 

    EUNIT_ASSERT( ETrue == consumed );

    CleanupStack::PopAndDestroy( message );

// No username attribute

    request->AddAttributeL( CNATFWUNSAFPriorityAttribute::NewLC( 

                                        CNATFWUNSAFAttribute::EPriority ) );

    CleanupStack::Pop(); // CNATFWUNSAFPriorityAttribute

    message = EncodeMessageL( *request );

    CleanupStack::PushL( message );

    NATFW_EUNIT_ASSERT_NO_LEAVE( iStunSrvImpl->IncomingMessageL(

        streamId, *message, localAddress, fromAddr, peerRemoteAddress, consumed ) );       

    EUNIT_ASSERT( ETrue == consumed );

    CleanupStack::PopAndDestroy( message );

// OK    

    request->AddAttributeL( CNATFWUNSAFUsernameAttribute::NewLC( username ) );

    CleanupStack::Pop(); // CNATFWUNSAFUsernameAttribute

    request->AddAttributeL( CNATFWUNSAFUseCandidateAttribute::NewLC() );

    CleanupStack::Pop(); // CNATFWUNSAFUseCandidateAttribute

    message = EncodeMessageL( *request );

    CleanupStack::PushL( message );

    NATFW_EUNIT_ASSERT_NO_LEAVE( iStunSrvImpl->IncomingMessageL(

        streamId, *message, localAddress, fromAddr, peerRemoteAddress, consumed ) );        

    EUNIT_ASSERT( ETrue == consumed ); 

    CleanupStack::PopAndDestroy( message );

    CleanupStack::PopAndDestroy( request );

// Data indication including stun request

    CNATFWUNSAFDataIndication* indication =

        CNATFWUNSAFDataIndication::NewLC( transactionID );

    CNATFWUNSAFBindingRequest* request1 =

        CNATFWUNSAFBindingRequest::NewLC( transactionID );

    request1->AddAttributeL( CNATFWUNSAFUsernameAttribute::NewLC( username ) );

    CleanupStack::Pop(); // CNATFWUNSAFUsernameAttribute

    request1->AddAttributeL( CNATFWUNSAFPriorityAttribute::NewLC( 

                                        CNATFWUNSAFAttribute::EPriority ) );

    CleanupStack::Pop(); // CNATFWUNSAFPriorityAttribute 

    request1->AddAttributeL( CNATFWUNSAFUseCandidateAttribute::NewLC() );

    CleanupStack::Pop(); // CNATFWUNSAFUseCandidateAttribute

    message = EncodeMessageL( *request1 );

    CleanupStack::PushL( message );

    indication->AddAttributeL( CNATFWUNSAFDataAttribute::NewLC( *message ) );

    CleanupStack::Pop(); // CNATFWUNSAFDataAttribute

    CleanupStack::PopAndDestroy( message );

    message = EncodeMessageL( *indication, ETrue, EFalse );

    CleanupStack::PushL( message );

    NATFW_EUNIT_ASSERT_NO_LEAVE( iStunSrvImpl->IncomingMessageL(

        streamId, *message, localAddress, fromAddr, peerRemoteAddress, consumed ) );

    EUNIT_ASSERT( ETrue == consumed );

    CleanupStack::PopAndDestroy( message );

    CleanupStack::PopAndDestroy( request1 );

    CleanupStack::PopAndDestroy( indication );

    CleanupStack::PopAndDestroy( &identifications );   

    CleanupStack::PopAndDestroy( identification3 );

    CleanupStack::PopAndDestroy( identification2 );

    CleanupStack::PopAndDestroy( credential ); 

    }

void ut_cnatfwstunsrvimpl::ut_cnatfwstunsrvimpl_IncomingMessageL2L(  )

    {

    TBufC8<12> username( KUsername );

    TBufC8<16> password( KPassword );    

    TBufC8<7> usernameA( KUsernameA );

    TBufC8<12> username2( KUsername2 );

    CNATFWCredentials* credential = CNATFWCredentials::NewLC();

    credential->SetPasswordL( password );

    credential->SetUsernameL( usernameA );

    CNATFWCredentials* identification2 = CNATFWCredentials::NewLC();

    identification2->SetPasswordL( password );

    identification2->SetUsernameL( username );

    CNATFWCredentials* identification3 = CNATFWCredentials::NewLC();

    identification3->SetPasswordL( password );

    identification3->SetUsernameL( username2 );

    RPointerArray<CNATFWCredentials> identifications;

    CleanupClosePushL( identifications );

    identifications.Append( credential );

    identifications.Append( identification2 );

    identifications.Append( identification3 );

    NATFW_EUNIT_ASSERT_NO_LEAVE(

        iStunSrvImpl->AddAuthenticationParamsL( identifications ) );

    TNATFWUNSAFTransactionID transactionID;

    transactionID.Copy( KTransactionId );

    TBool consumed( EFalse );

    TUint streamId(0);

    TInetAddr localAddress;

    TInetAddr fromAddr;

    _LIT( KAddress, "127.0.0.0" );

    fromAddr.SetPort(250);

    fromAddr.Input( KAddress );

    TInetAddr peerRemoteAddress;   

// Keepalive stun binding indication

    CNATFWUNSAFBindingIndication* binding =

        CNATFWUNSAFBindingIndication::NewLC( transactionID );

    HBufC8* message = EncodeMessageL( *binding );

    CleanupStack::PushL( message );

    NATFW_EUNIT_ASSERT_NO_LEAVE( iStunSrvImpl->IncomingMessageL( 

        streamId, *message, localAddress, fromAddr, peerRemoteAddress, consumed ) );

    EUNIT_ASSERT( ETrue == consumed );

    CleanupStack::PopAndDestroy( message );

    CleanupStack::PopAndDestroy( binding );

// Data indication including some other message

    CNATFWUNSAFDataIndication* indication =

        CNATFWUNSAFDataIndication::NewLC( transactionID );

    CNATFWUNSAFBindingResponse* response =

        CNATFWUNSAFBindingResponse::NewLC( transactionID );

    message = EncodeMessageL( *response );

    CleanupStack::PushL( message );

    indication->AddAttributeL( CNATFWUNSAFDataAttribute::NewLC( *message ) );

    CleanupStack::Pop(); // CNATFWUNSAFDataAttribute

    CleanupStack::PopAndDestroy( message );

    message = EncodeMessageL( *indication, ETrue, EFalse ); 

    CleanupStack::PushL( message );

    NATFW_EUNIT_ASSERT_NO_LEAVE( iStunSrvImpl->IncomingMessageL(

        streamId,  *message, localAddress, fromAddr, peerRemoteAddress, consumed ) );

    EUNIT_ASSERT( EFalse == consumed );

    CleanupStack::PopAndDestroy( message );

    CleanupStack::PopAndDestroy( response );

    CleanupStack::PopAndDestroy( indication );

// Some other message

    response = CNATFWUNSAFBindingResponse::NewLC( transactionID );

    response->AddAttributeL( CNATFWUNSAFMappedAddressAttribute::NewLC( fromAddr ) );

    CleanupStack::Pop(); // CNATFWUNSAFMappedAddressAttribute

    message = EncodeMessageL( *response );

    CleanupStack::PushL( message );

    NATFW_EUNIT_ASSERT_NO_LEAVE( iStunSrvImpl->IncomingMessageL(

        streamId,  *message, localAddress, fromAddr, peerRemoteAddress, consumed ) );

    EUNIT_ASSERT( EFalse == consumed );

    CleanupStack::PopAndDestroy( message );

    CleanupStack::PopAndDestroy( response );

    CleanupStack::PopAndDestroy( &identifications );   

    CleanupStack::PopAndDestroy( identification3 );

    CleanupStack::PopAndDestroy( identification2 );

    CleanupStack::PopAndDestroy( credential );

    }

void ut_cnatfwstunsrvimpl::ut_cnatfwstunsrvimpl_IsRoleConflictPresentL()

    {

    TUint64 tieBraker = 32;

    TNATFWUNSAFTransactionID transactionID;

    CNATFWUNSAFBindingRequest* request =

        CNATFWUNSAFBindingRequest::NewLC( transactionID );

// no role attribute present

    EUNIT_ASSERT_EQUALS(

        iStunSrvImpl->IsRoleConflictPresent( *request ), EFalse );

// stun srv has controlled attribute, request controlling    

    request->AddAttributeL( CNATFWUNSAFIceControllingAttribute::NewLC( tieBraker ) );

    CleanupStack::Pop(); // CNATFWUNSAFIceControllingAttribute

    iStunSrvImpl->SetRoleL( EIceRoleControlled, tieBraker );

    EUNIT_ASSERT_EQUALS(

        iStunSrvImpl->IsRoleConflictPresent( *request ), EFalse );

// both have controlling attribute, stun srv has bigger or equal tiebraker

    iStunSrvImpl->SetRoleL( EIceRoleControlling, tieBraker );    

    EUNIT_ASSERT_EQUALS(

        iStunSrvImpl->IsRoleConflictPresent( *request ), ETrue );

// both have controlling attribute, stun srv has smaller tiebraker

    iStunSrvImpl->iTieBreaker = 16;

    EUNIT_ASSERT_EQUALS(

        iStunSrvImpl->IsRoleConflictPresent( *request ), EFalse );

// both have controlled attribute, stun srv has smaller tiebraker    

    //request->DetachAttribute( CNATFWUNSAFIceControllingAttribute::NewL( tieBraker ) );

    request->DeleteAttribute( CNATFWUNSAFAttribute::EIceControlling );

    request->AddAttributeL(

        CNATFWUNSAFIceControlledAttribute::NewLC( tieBraker ) );

    CleanupStack::Pop(); // CNATFWUNSAFIceControllingAttribute 

    tieBraker = 16;    

    iStunSrvImpl->SetRoleL( EIceRoleControlled, tieBraker );

    EUNIT_ASSERT_EQUALS(

        iStunSrvImpl->IsRoleConflictPresent( *request ), ETrue );

// both have controlled attribute, stun srv has bigger or equal tiebraker    

    iStunSrvImpl->iTieBreaker = 64;

    EUNIT_ASSERT_EQUALS(

        iStunSrvImpl->IsRoleConflictPresent( *request ), EFalse );

// stun srv has controlling attribute, request controlled

    iStunSrvImpl->SetRoleL( EIceRoleControlling, tieBraker );

    EUNIT_ASSERT_EQUALS(

        iStunSrvImpl->IsRoleConflictPresent( *request ), EFalse );   

    CleanupStack::PopAndDestroy( request ); 

    }

void ut_cnatfwstunsrvimpl::ut_cnatfwstunsrvimpl_SetPeerRemoteAddressL()

    {

    TInetAddr localAddress;

    TInetAddr fromAddr;

    TInetAddr peerRemoteAddress;

    iStunSrvImpl->SetPeerRemoteAddress( fromAddr, peerRemoteAddress );

    peerRemoteAddress.Input( KRemoteAddress );

    iStunSrvImpl->SetPeerRemoteAddress( fromAddr, peerRemoteAddress );

    iStunSrvImpl->SetPeerRemoteAddress( fromAddr, peerRemoteAddress );

    }

void ut_cnatfwstunsrvimpl::ut_cnatfwstunsrvimpl_DecodeMessageLL()

    {

    TNATFWUNSAFTransactionID transactionID;

    CNATFWUNSAFBindingResponse* response =

        CNATFWUNSAFBindingResponse::NewLC( transactionID );

    CBufBase* msg = response->EncodeL();

    CleanupStack::PushL( msg );        

    TInt length = msg->Size();

    HBufC8* readBuf = HBufC8::NewLC( length );

    TPtr8 writable( readBuf->Des() );

    msg->Read( 0, writable );