/*

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

*

*/

#include "cnatfwunsafhostresolver.h"

#include "natfwunsafserverresolverobserver.h"

#include "cnatfwunsafserverquery.h"

#include "cnatfwunsafquerydata.h"

#include "cnatfwunsafrequestqueue.h"

#include "natfwunsaflog.h"

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

// CNATFWUNSAFHostResolver::CNATFWUNSAFHostResolver

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

//

CNATFWUNSAFHostResolver::CNATFWUNSAFHostResolver()

 : CActive( EPriorityStandard )

    {

    CActiveScheduler::Add( this );

    }

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

// CNATFWUNSAFHostResolver::ConstructL

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

//

void CNATFWUNSAFHostResolver::ConstructL ( RSocketServ& aServer,

                                    RConnection& aConnection )

    {

    iObserverCancel = EFalse;

    iFailed = EFalse;

    User::LeaveIfError( iResolver.Open( aServer, KAfInet, KProtocolInetUdp,

                                        aConnection ) );

    iRequestQueue = CNATFWUNSAFRequestQueue::NewL();

    }

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

// CNATFWUNSAFHostResolver::NewL

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

//

CNATFWUNSAFHostResolver* CNATFWUNSAFHostResolver::NewL( RSocketServ& aServer,

                                          RConnection& aConnection )

    {

    CNATFWUNSAFHostResolver* self = NewLC( aServer, aConnection );

    CleanupStack::Pop( self );

    return self;

    }

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

// CNATFWUNSAFHostResolver::NewLC

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

//

CNATFWUNSAFHostResolver* CNATFWUNSAFHostResolver::NewLC( RSocketServ& aServer,

                                           RConnection& aConnection )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aServer, aConnection );

    return self;

    }

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

// CNATFWUNSAFHostResolver::~CNATFWUNSAFHostResolver

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

//

CNATFWUNSAFHostResolver::~CNATFWUNSAFHostResolver()

    {

    Cancel();

    iResolver.Close();

    delete iRequestQueue;

    delete iQuery;

    }

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

// CNATFWUNSAFHostResolver::GetByQueryL

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

//

void CNATFWUNSAFHostResolver::GetByQueryL ( CNATFWUNSAFServerQuery* aQuery )

    {

    __ASSERT_ALWAYS( NULL != aQuery, User::Leave( KErrArgument ) );

    if( !IsActive() && !iQuery )

        {

        iQuery = aQuery;

        iQuery->Query( *this );

        SetActive();

        }

    else

        {

        iRequestQueue->Add( *aQuery );

        }

    }

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

// CNATFWUNSAFHostResolver::CancelResolving

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

//

void CNATFWUNSAFHostResolver::CancelResolving(

    const MNATFWUNSAFServerResolverObserver* aObserver )

    {

    if ( iQuery != 0 && iQuery->ServerResolverObserver() == aObserver )

        {

        Cancel();

        ResolveNext();

        }

    else

        {

        iRequestQueue->CancelQuery( aObserver );

        }

    }

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

// CNATFWUNSAFHostResolver::NextQuery

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

//

void CNATFWUNSAFHostResolver::NextQuery()

    {

    delete iQuery;

    iQuery = NULL;

    ResolveNext();

    }

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

// CNATFWUNSAFHostResolver::RunL

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

//

void CNATFWUNSAFHostResolver::RunL()

    {

    NATFWUNSAF_INTLOG("CNATFWUNSAFHostResolver::RunL: status", iStatus.Int())

    NATFWUNSAF_INTLOG("CNATFWUNSAFHostResolver::RunL: observerCancel",

        iObserverCancel)

    iFailed = EFalse;

    TBool subquery = EFalse;

    TInt status = iStatus.Int();

    MNATFWUNSAFServerResolverObserver* observer =

        iQuery->ServerResolverObserver();

    if ( !iObserverCancel )

        {

        subquery = iQuery->HandleQueryResultL( iStatus.Int() );

        }

    NATFWUNSAF_INTLOG("CNATFWUNSAFHostResolver::RunL: subquery", subquery);

    if ( subquery )

        {

        iQuery->Query( *this );

        SetActive();

        }

    else

        {

        if ( iObserverCancel )

            {

            iObserverCancel = EFalse;

            NextQuery();

            }

        else

            {

            if ( status == KErrNone )

                {

                NextQuery();

                observer->CompletedL();

                }

            else

                {//status _ne_ KErrNone || iFailed

                NextQuery();

                observer->ErrorOccured( status );

                }

            }

        }

    }

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

// CNATFWUNSAFHostResolver::RunError

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

//

TInt CNATFWUNSAFHostResolver::RunError ( TInt aError )

    {

    TInt err = KErrNone;

    // Complete the query, as RunL has not completed it.

    if ( iQuery )

        {

        MNATFWUNSAFServerResolverObserver* observer =

                                            iQuery->ServerResolverObserver();

        delete iQuery;

        iQuery = NULL;

        observer->ErrorOccured( aError );

        }

    if ( aError == KErrNoMemory )

        {

        err = aError;

        }

    return err;

    }

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

// CNATFWUNSAFHostResolver::ResolveNext

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

//

void CNATFWUNSAFHostResolver::ResolveNext()

    {

    if ( !IsActive() )

        {

        iQuery = iRequestQueue->NextQuery();

        if ( iQuery )

            {

            iQuery->Query( *this );

            SetActive();

            }

        }

    }

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

// CNATFWUNSAFHostResolver::DoCancel

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

//

void CNATFWUNSAFHostResolver::DoCancel ()

    {

    iResolver.Cancel();

    if ( iQuery )

        {

        iObserverCancel = ETrue;

        delete iQuery;

        iQuery = NULL;

        }

    }

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

// CNATFWUNSAFHostResolver::Resolver

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

//

RHostResolver& CNATFWUNSAFHostResolver::Resolver ()

    {

    return iResolver;

    }

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

// CNATFWUNSAFHostResolver::RequestStatus

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

//

TRequestStatus& CNATFWUNSAFHostResolver::RequestStatus ()

    {

    return iStatus;

    }

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

// CNATFWUNSAFHostResolver::SetIPListFailed

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

//

void CNATFWUNSAFHostResolver::SetIPListFailed( TBool aFailed )

    {

    iFailed = aFailed;

    }