/*

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

*

*/

#include "stunassert.h"

#include "natfwunsaflog.h"

#include "natfwunsafmessagefactory.h"

#include "natfwunsafbindingrequest.h"

#include "natfwunsafallocaterequest.h"

#include "natfwunsafconnectrequest.h"

#include "natfwunsafsetactivedestinationrequest.h"

#include "natfwunsafsendindication.h"

#include "cstunrelaybindingimplementation.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"

#include "natfwunsaftcprelaypacketfactory.h"

// Attributes

#include "natfwunsafusernameattribute.h"

#include "natfwunsafxoronlyattribute.h"

#include "natfwunsafunknownattributesattribute.h"

#include "natfwunsafmagiccookieattribute.h"

#include "natfwunsafdataattribute.h"

#include "natfwunsafremoteaddressattribute.h"

#include "natfwunsafusecandidateattribute.h"

#include "natfwunsafpriorityattribute.h"

#include "natfwunsaficecontrollingattribute.h"

#include "natfwunsaficecontrolledattribute.h"

#include "natfwunsafalternateserverattribute.h"

#include "natfwunsafrealmattribute.h"

#include "natfwunsafnonceattribute.h"

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

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

// CSTUNRelayBindingImplementation::NewL

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

//

CSTUNRelayBindingImplementation*

    CSTUNRelayBindingImplementation::NewL( CBinding& aBinding,  

                                           MSTUNBindingObserver& aClient,

                                           RSocket& aSocket )

    {

    CSTUNRelayBindingImplementation* self =

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CSTUNRelayBindingImplementation::NewL - overloaded

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

//

CSTUNRelayBindingImplementation*

    CSTUNRelayBindingImplementation::NewL( CBinding& aBinding,  

                                           MSTUNBindingObserver& aClient,

                                           TUint aStreamId,

                                           TUint aConnectionId,

                                           MNcmConnectionMultiplexer* aMux )

    {

    CSTUNRelayBindingImplementation* self =

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

                                               aConnectionId, aMux );

    CleanupStack::PushL( self );

    self->ConstructL( );

    CleanupStack::Pop( self );

    return self;

    }

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

// CSTUNRelayBindingImplementation::CSTUNRelayBindingImplementation

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

//

CSTUNRelayBindingImplementation::CSTUNRelayBindingImplementation(

    CBinding& aBinding,

    MSTUNBindingObserver& aClient,

    RSocket& aSocket ) :

    CBindingImplementation( aClient, aBinding, aSocket )

    {

    }

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

// CSTUNRelayBindingImplementation::CSTUNRelayBindingImplementation

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

//

CSTUNRelayBindingImplementation::CSTUNRelayBindingImplementation( 

    CBinding& aBinding,

    MSTUNBindingObserver& aClient, 

    TUint aStreamId,

    TUint aConnectionId,

    MNcmConnectionMultiplexer* aMux ) :

    CBindingImplementation( aClient, aBinding, aStreamId, aConnectionId, aMux )

    {

    }

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

// CSTUNRelayBindingImplementation::ConstructL

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

//

void CSTUNRelayBindingImplementation::ConstructL()

    {

    __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::ConstructL" )

    ClientL().AttachBindingL( iBinding );

    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 );

    }

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

// CSTUNRelayBindingImplementation::~CSTUNRelayBindingImplementation

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

//

CSTUNRelayBindingImplementation::~CSTUNRelayBindingImplementation()

    {

    __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::~CSTUNRelayBindingImplementation" )

    if ( iClient )

        {

        iClient->DetachBinding( iBinding );

        }

    this->FreeRequestData();

    delete iInit;

    delete iGetSharedSecret;

    delete iGetAddress;

    delete iWaitToRetry;

    delete iActive;

    delete iIndicationTx;

    iSocket = NULL;

    iMux = NULL;

    __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::~CSTUNRelayBindingImplementation exit" )

    }

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

// CSTUNRelayBindingImplementation::TimerExpiredL

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

//

void CSTUNRelayBindingImplementation::TimerExpiredL()

    {

    iState->TimerExpiredL( *this );

    }

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

// CSTUNRelayBindingImplementation::LeaveFromTimerExpired

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

//

void CSTUNRelayBindingImplementation::LeaveFromTimerExpired( TInt aError )

    {

    __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::LeaveFromTimerExpired" )

    __STUN_ASSERT_RETURN( aError != KErrNone, KErrArgument );

    Terminate( aError );

    }

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

// CSTUNRelayBindingImplementation::PublicAddressObtainedL

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

//

void CSTUNRelayBindingImplementation::PublicAddressObtainedL( 

    const TInetAddr& aAddress )

    {

    __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::PublicAddressObtainedL 1" )

    iState->PublicAddressReceivedL( *this, aAddress );

    }

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

// CSTUNRelayBindingImplementation::PublicAddressObtainedL

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

//

void CSTUNRelayBindingImplementation::PublicAddressObtainedL( 

    const TInetAddr& aReflexiveAddr, const TInetAddr& aRelayAddr )

    {

    __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::PublicAddressObtainedL 2" )

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

    }

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

// CSTUNRelayBindingImplementation::TransactionError

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

//

void CSTUNRelayBindingImplementation::TransactionError( TInt aError,

    CNATFWUNSAFUnknownAttributesAttribute* aUnknownAttr )

    {

    __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::TransactionError" )

    delete iUnknownAttr;

    iUnknownAttr = aUnknownAttr;

    __STUN_ASSERT_RETURN( aError != KErrNone, KErrArgument );

    iState->TransactionError( *this, aError );

    }

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

// CSTUNRelayBindingImplementation::TransactionEventOccurredL

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

//

void CSTUNRelayBindingImplementation::TransactionEventOccurredL( 

    TSTUNCallbackInfo::TFunction aEvent )

    {

    __STUNTURNCLIENT_INT1( 

        "CSTUNRelayBindingImplementation::TransactionEventOccurredL event:",

             aEvent )

    if ( ESetActiveDestinationRequest == iRequestType )

        {

        *iTimerValue = iTransaction->TimerValue();

        }

    FreeRequestData();

    ChangeState( *iActive );

    ClientL().BindingEventOccurred( iBinding, aEvent );

    }

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

// CSTUNRelayBindingImplementation::HandleTransactionError

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

//  

TBool CSTUNRelayBindingImplementation::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( 

                "CSTUNRelayBindingImplementation - 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 (  KErrNone != 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 E437NoBindind:

            // There is none yet in place

            return EFalse;

        case E438StaleNonce:                                  

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

                {

                // retry using a nonce from error response

                return ETrue;

                }

            return EFalse;

        case E439Transitioning:

            // The client should reset the active destination, wait for 

            // 5 seconds and set the active destination to the new value.

            return EFalse;

        case E442UnsupportedTransportProtocol:

            return EFalse;

        case E443InvalidIPAddress:

            return EFalse;           

        case E444InvalidPort:

            return EFalse;

        case E445OperationForTCPOnly:

            return EFalse;

        case E446ConnectionAlreadyExists:

            return EFalse;

        case E486AllocationQuotaReached:

            // The user or client is not authorized to request additional

            // allocations.          

            return EFalse;

        case E500ServerError:               

            return ETrue;  

        case E507InsufficientCapacity:

            // The server cannot allocate a new port for this client as it has

            // exhausted its relay capacity.        

            return EFalse;

        case E600GlobalFailure:

            return EFalse; 

        case ERetryAfterAddingXorOnly:

            iAddXorOnly = ETrue;

            return ETrue;

        default:

            return STUNUtils::Is5xxResponse( aError );

        }

    }

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

// CSTUNRelayBindingImplementation::IcmpError

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

//

void CSTUNRelayBindingImplementation::IcmpError( const TInetAddr& aAddress )

    {

    __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::IcmpError" )

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

        {

        //Try next address, or terminate with KErrTimedOut.

        iTransaction->Terminate( KErrTimedOut );

        }

    }

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

// CSTUNRelayBindingImplementation::AllocateRequestL

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

//

void CSTUNRelayBindingImplementation::AllocateRequestL( TUint /*aRtoValue*/ )

    {

    __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::AllocateRequestL" )

    iRequestType = EAllocateRequest;

    iState->SendRequestL( *this );

    }

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

// CSTUNRelayBindingImplementation::SetActiveDestinationRequestL

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

//

void CSTUNRelayBindingImplementation::SetActiveDestinationRequestL( 

    const TInetAddr& aRemoteAddr, TUint32& aTimerValue )

    {

    __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::SetActiveDestinationRequestL" )

    iRequestType = ESetActiveDestinationRequest;

    iRemoteAddr = aRemoteAddr;

    iTimerValue = NULL;

    iTimerValue = &aTimerValue;

    iState->SendRequestL( *this );

    }

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

// CSTUNRelayBindingImplementation::SendIndicationL

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

//

void CSTUNRelayBindingImplementation::SendIndicationL( 

    const TInetAddr& aRemoteAddr, const TDesC8& aData, 

    TBool /*aAddFingerprint*/ )

    {

    __STUNTURNCLIENT( "CSTUNRelayBindingImplementation::SendIndicationL" )

    TNATFWUNSAFTransactionID transactionID;

    ClientL().ObtainTransactionIDL( transactionID );

    CNATFWUNSAFMessage* 

        indication = CNATFWUNSAFSendIndication::NewL( transactionID );

    CleanupStack::PushL( indication );

    indication->AddAttributeL( CNATFWUNSAFDataAttribute::NewLC( aData ) );

    CleanupStack::Pop(); // CNATFWUNSAFDataAttribute

    indication->AddAttributeL( CNATFWUNSAFRemoteAddressAttribute::NewLC( 

        aRemoteAddr ) );

    CleanupStack::Pop(); // CNATFWUNSAFRemoteAddressAttribute

    if ( iUnknownAttr )

        {

        STUNUtils::RemoveUnknownAttributes( *indication, *iUnknownAttr );