/*

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

*

*/

// INCLUDES

#include "stunassert.h"

#include "natfwunsaflog.h"

#include "natfwunsafmessagefactory.h"

#include "natfwunsafbindingrequest.h"

#include "natfwunsafbindingindication.h"

#include "cstunbindingimplementation.h"

#include "natfwstunbinding.h"

#include "cstunbindinginit.h"

#include "cstunbindinggetsharedsecret.h"

#include "cstunbindinggetaddress.h"

#include "cstunbindingactive.h"

#include "cstunbindingwaittoretry.h"

#include "mstunbindingobserver.h"

#include "cstuntransaction.h"

#include "stunutils.h"

#include "natfwstunclientdefs.h"

#include "cstunindicationtransmitter.h"

// Attribures

#include "natfwunsafusernameattribute.h"

#include "natfwunsafxoronlyattribute.h"

#include "natfwunsafunknownattributesattribute.h"

#include "natfwunsafusecandidateattribute.h"

#include "natfwunsafpriorityattribute.h"

#include "natfwunsafdataattribute.h"

#include "natfwunsafremoteaddressattribute.h"

#include "natfwunsaficecontrollingattribute.h"

#include "natfwunsaficecontrolledattribute.h"

#include "natfwunsafalternateserverattribute.h"

#include "natfwunsafrealmattribute.h"

#include "natfwunsafnonceattribute.h"

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

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

// CSTUNBindingImplementation::NewL

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

//

CSTUNBindingImplementation*

    CSTUNBindingImplementation::NewL( CBinding& aBinding,

                                      MSTUNBindingObserver& aClient,

                                      RSocket& aSocket )

    {

    CSTUNBindingImplementation* self =

    new ( ELeave ) CSTUNBindingImplementation( aBinding, aClient, aSocket );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CSTUNBindingImplementation::NewL - overloaded

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

//

CSTUNBindingImplementation*

    CSTUNBindingImplementation::NewL( CBinding& aBinding,

                                      MSTUNBindingObserver& aClient,

                                      TUint aStreamId,

                                      TUint aConnectionId,

                                      MNcmConnectionMultiplexer* aMux )

    {

    CSTUNBindingImplementation* self =

    new ( ELeave ) CSTUNBindingImplementation( aBinding, aClient, aStreamId,

                                               aConnectionId, aMux );

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop( self );

    return self;

    }

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

// CSTUNBindingImplementation::CSTUNBindingImplementation

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

//

CSTUNBindingImplementation::CSTUNBindingImplementation(

    CBinding& aBinding,

    MSTUNBindingObserver& aClient,

    RSocket& aSocket ) :

    CBindingImplementation( aClient, aBinding, aSocket )

    {

    }

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

// CSTUNBindingImplementation::CSTUNBindingImplementation

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

//

CSTUNBindingImplementation::CSTUNBindingImplementation(

    CBinding& aBinding,

    MSTUNBindingObserver& aClient,

    TUint aStreamId,

    TUint aConnectionId,

    MNcmConnectionMultiplexer* aMux ) :

    CBindingImplementation( aClient, aBinding, aStreamId, aConnectionId,

    aMux ), iDestAddr( KAFUnspec )

    {

    }

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

// CSTUNBindingImplementation::ConstructL

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

//

void CSTUNBindingImplementation::ConstructL()

    {

    ClientL().AttachBindingL( iBinding );

    iRetransmitInterval = ClientL().RetransmitInterval();

    iGetAddress = new ( ELeave ) CSTUNBindingGetAddress();

    iGetSharedSecret =

    new ( ELeave ) CSTUNBindingGetSharedSecret( *iGetAddress );

    iInit = new ( ELeave ) CSTUNBindingInit( *iGetSharedSecret );

    iActive = new ( ELeave ) CSTUNBindingActive( *iGetSharedSecret );

    iWaitToRetry = new ( ELeave ) CSTUNBindingWaitToRetry( *iGetSharedSecret );

    iGetAddress->SetNeighbourStates( *iGetSharedSecret,

                                     *iWaitToRetry,

                                     *iActive );

    iIndicationTx = CStunIndicationTransmitter::NewL( *iMux, 

        iStreamId, iConnectionId );

    ChangeState( *iInit );

    }

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

// CSTUNBindingImplementation::~CSTUNBindingImplementation

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

//

CSTUNBindingImplementation::~CSTUNBindingImplementation()

    {

    __STUNTURNCLIENT( "CSTUNBindingImplementation::~CSTUNBindingImplementation" )

    if ( iClient )

        {

        iClient->DetachBinding( iBinding );

        }

    this->FreeRequestData();

    delete iInit;

    delete iGetSharedSecret;

    delete iGetAddress;

    delete iWaitToRetry;

    delete iActive;

    delete iIndicationTx;

    iSocket = NULL;

    iMux = NULL;

    __STUNTURNCLIENT( "CSTUNBindingImplementation::~CSTUNBindingImplementation exit" )

    }

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

// CSTUNBindingImplementation::TimerExpiredL

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

//

void CSTUNBindingImplementation::TimerExpiredL()

    {

    iState->TimerExpiredL( *this );

    }

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

// CSTUNBindingImplementation::LeaveFromTimerExpired

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

//

void CSTUNBindingImplementation::LeaveFromTimerExpired( TInt aError )

    {

    __STUN_ASSERT_RETURN( aError != KErrNone, KErrArgument );

    Terminate( aError );

    }

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

// CSTUNBindingImplementation::PublicAddressObtainedL

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

//

void CSTUNBindingImplementation::PublicAddressObtainedL(

    const TInetAddr& aAddress )

    {

    iState->PublicAddressReceivedL( *this, aAddress );

    }

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

// CSTUNBindingImplementation::PublicAddressObtainedL

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

//

void CSTUNBindingImplementation::PublicAddressObtainedL(

    const TInetAddr& aReflexiveAddr, const TInetAddr& aRelayAddr )

    {

    iState->PublicAddressReceivedL( *this, aReflexiveAddr, aRelayAddr );

    }

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

// CSTUNBindingImplementation::TransactionError

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

//

void CSTUNBindingImplementation::TransactionError( TInt aError,

    CNATFWUNSAFUnknownAttributesAttribute* aUnknownAttr )

    {

    delete iUnknownAttr;

    iUnknownAttr = aUnknownAttr;

    __STUN_ASSERT_RETURN( aError != KErrNone, KErrArgument );

    iState->TransactionError( *this, aError );

    }

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

// CSTUNBindingImplementation::TransactionEventOccurredL

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

//

void CSTUNBindingImplementation::TransactionEventOccurredL(

    TSTUNCallbackInfo::TFunction /*aEvent*/ )

    {

    __STUNTURNCLIENT(

        "CSTUNBindingImplementation::TransactionEventOccurredL -should not get called" )

    }

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

// CSTUNBindingImplementation::HandleTransactionError

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

TBool CSTUNBindingImplementation::HandleTransactionError( TInt aError )

    {

    __STUNTURNCLIENT_INT1( "HandleTransactionError, reason", aError )

    const TInt KMaxErrorResponseCount = 3;

    __STUN_ASSERT_RETURN_VALUE( iRequest && aError != KErrNone,

    EFalse );

    delete iTransaction;

    iTransaction = NULL;

    iTransactionError = aError;

    if ( ( aError > 0 ) && ( ++iErrorResponseCount >= KMaxErrorResponseCount ) )

        {

        iErrorResponseCount = 0;

        return EFalse;

        }

    CNATFWUNSAFAlternateServerAttribute* alternateServer = NULL;

    HBufC8* realmValue = NULL;

    switch ( aError )

        {

        case KErrTimedOut:

            __STUNTURNCLIENT(

                "CSTUNBindingImplementation - KErrTimedOut" )

            //Clear iAddXorOnly as another address is tried

            iAddXorOnly = EFalse;

            return iClient && iClient->ObtainServerAddress( iServerAddress );

        case E300TryAlternate:

            // The client SHOULD attempt a new transaction to the server

            // indicated in the ALTERNATE-SERVER attribute.

            alternateServer = static_cast<CNATFWUNSAFAlternateServerAttribute*>

            ( iRequest->Attribute( CNATFWUNSAFAttribute::EAlternateServer ) );

            if ( alternateServer )

                {

                iServerAddress = alternateServer->Address();

                return ETrue;

                }

            return EFalse;

        case E4XX:

            return EFalse;

        case E401Unauthorized:

            if ( iSharedSecret )

                {

                CNATFWUNSAFRealmAttribute* realm =

                    static_cast<CNATFWUNSAFRealmAttribute*>

                    ( iRequest->Attribute( CNATFWUNSAFAttribute::ERealm ) );

                if ( realm || !iRealmFromResponse )

                    {

                    // indicates that this was retry and it did not work.

                    // notify client -> unrecoverable error

                    return EFalse;

                    }

                }

            return ETrue;

        case E420UnknownAttributes:

            //Remove the unknown attributes and retry

            return iUnknownAttr != NULL;

        case E430StaleCredentials:

            // Client used a short term credential that has expired so

            // generate a new Shared Secret request

            return iSharedSecret != NULL;

        case E431IntegrityCheckFailure:

            {

            TBool retry = EFalse;

            TRAPD( err, retry =

                ClientL().SharedSecretRejectedL( iBinding,

                                                Username(),

                                                *iSharedSecret ) );

            return err == KErrNone && retry;

            }

        case E432MissingUsername:

            //If missing USERNAME or MESSAGE-INTEGRITY, add them and retry

            return !iRequest->Attribute( CNATFWUNSAFAttribute::EUsername ) ||

               !iSharedSecret;

        case E433UseTLS:

            // If request was a Shared Secret request and wasn't sent over

            // TLS, the client SHOULD retry the request with TLS.

            return iSharedSecret != NULL;

        case E434MissingRealm:

            if ( !iRequest->Attribute( CNATFWUNSAFAttribute::ERealm ) &&

                 iSharedSecret )

                {

                // use a long term credential and retry the request using the username

                // and password associated with the REALM

                return ETrue;

                }  

            TRAPD( err, realmValue = ( static_cast<CNATFWUNSAFRealmAttribute*>

                ( iRequest->Attribute( CNATFWUNSAFAttribute::ERealm ) ) )->

                Value().AllocL() );

            if ( err || !realmValue )

                {

                delete realmValue;

                return EFalse;

                }

            if ( realmValue->Compare( *iRealmFromResponse ) )

                {

                // the client SHOULD retry using the username and

                // password associated with the REALM in the response

                iUseRealmFromResponse = ETrue;

                delete realmValue;

                return ETrue;

                }

            delete realmValue;

            return EFalse;

        case E435MissingNonce:

            if ( iRequest->Attribute( CNATFWUNSAFAttribute::ENonce ) )

                {

                return EFalse;

                }

            // retry using a nonce from error response

            return ETrue;

        case E436UnknownUsername:

            if ( iSharedSecret )

                {

                return ETrue;

                }

            // If the username was collected from the user, alert the user.

            return EFalse;

        case E438StaleNonce:

            if ( iRequest->Attribute( CNATFWUNSAFAttribute::ENonce ) )

                {

                // retry using a nonce from error response

                return ETrue;

                }

            return EFalse;

        case E487RoleConflict:

            return EFalse;

        case E500ServerError:

            return ETrue;

        case E600GlobalFailure:

            return EFalse;

        case ERetryAfterAddingXorOnly:

            iAddXorOnly = ETrue;

            return ETrue;

        default:

            return STUNUtils::Is5xxResponse( aError );

        }

    }

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

// CSTUNBindingImplementation::IcmpError

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

//

void CSTUNBindingImplementation::IcmpError( const TInetAddr& aAddress )

    {

    if ( iTransaction && iServerAddress.CmpAddr( aAddress ) )

        {

        //Try next address, or terminate with KErrTimedOut.

        iTransaction->Terminate( KErrTimedOut );

        }

    }

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

// CSTUNBindingImplementation::SendRequestL

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

//

void CSTUNBindingImplementation::SendRequestL()

    {

    iRetransmitInterval = ClientL().RetransmitInterval();

    iAddFingerprint = EFalse;

    iState->SendRequestL( *this );

    }

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

// CSTUNBindingImplementation::SendRequestL

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

//

void CSTUNBindingImplementation::SendRequestL( const TInetAddr& aDestAddr,

                                               TBool aAddFingerprint,

                                               TUint aRtoValue )

    {

    if ( 0 != aRtoValue )

        {

        iRetransmitInterval = aRtoValue;

        }

    if ( KAFUnspec != aDestAddr.Family() )

        {

        iDestAddr.SetAddress( aDestAddr.Address() );

        iDestAddr.SetPort( aDestAddr.Port() );

        }

    iAddFingerprint = aAddFingerprint;

    iState->SendRequestL( *this );

    }

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

// CSTUNBindingImplementation::StreamId

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

//

TUint CSTUNBindingImplementation::StreamId() const

    {

    return iStreamId;

    }

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

// CSTUNBindingImplementation::ConnectionId

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

//

TUint CSTUNBindingImplementation::ConnectionId() const

    {

    return iConnectionId;

    }

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

// CSTUNBindingImplementation::CancelRequest

// If transaction exists, delete it to stop using the socket.

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

//

void CSTUNBindingImplementation::CancelRequest()

    {

    if ( AddressResolved() )

        {

        ChangeState( *iActive );

        delete iTransaction;

        iTransaction = NULL;

        }

    else

        {

        //The initial request is canceled

        ChangeState( *iInit );

        Terminate( KErrCancel );

        }

    }

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

// CSTUNBindingImplementation::Socket

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

//

const RSocket& CSTUNBindingImplementation::Socket() const

    {

    return *iSocket;

    }

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

// CSTUNBindingImplementation::AddressResolved

// The most recent public address is kept also during a refresh.

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

//

TBool CSTUNBindingImplementation::AddressResolved() const

    {

    return !iPublicAddr.IsUnspecified();

    }

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

// CSTUNBindingImplementation::PublicAddr

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

//

const TInetAddr& CSTUNBindingImplementation::PublicAddr() const

    {

    return iPublicAddr;

    }

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

// CSTUNBindingImplementation::AlternateServerAddr

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

//