/*

* 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 "cnatfwunsafquerysrv.h"

#include "mnatfwunsafhostresolver.h"

_LIT8(KDot8, ".");

_LIT8(KUnderLine8, "_");

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

// CNATFWUNSAFQuerySrv::CNATFWUNSAFQuerySrv

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

//

CNATFWUNSAFQuerySrv::CNATFWUNSAFQuerySrv()

:CNATFWUNSAFQueryBase()

    {

    }

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

// CNATFWUNSAFQuerySrv::ConstructL

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

//

void CNATFWUNSAFQuerySrv::ConstructL( const TDesC8& aTarget )

    {

    SetTargetL( aTarget );

    }

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

// CNATFWUNSAFQuerySrv::NewL

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

//

CNATFWUNSAFQuerySrv* CNATFWUNSAFQuerySrv::NewL( const TDesC8& aTarget )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aTarget );

    CleanupStack::Pop( self );

    return self;

    }

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

// CNATFWUNSAFQuerySrv::~CNATFWUNSAFQuerySrv

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

//

CNATFWUNSAFQuerySrv::~CNATFWUNSAFQuerySrv()

    {

    delete iTarget;

    iRecordArray.Reset();

    }

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

// CNATFWUNSAFQuerySrv::SetTargetProtocolL

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

//

HBufC8* CNATFWUNSAFQuerySrv::SetTargetProtocolL( const TDesC8& aTarget,

                                            const TDesC8& aProtocol,

                                            const TDesC8& aServiceName )

    {

    HBufC8* temp = HBufC8::NewLC( KUnderLine8().Length() +

                                  aServiceName.Length()  +

                                  KDot8().Length()       +

                                  KUnderLine8().Length() +

                                  aProtocol.Length()     +

                                  KDot8().Length()       +

                                  aTarget.Length() );

    TPtr8 tempPtr = temp->Des();

    tempPtr.Append( KUnderLine8 );

    tempPtr.Append( aServiceName );

    tempPtr.Append( KDot8 );

    tempPtr.Append( KUnderLine8 );

    tempPtr.Append( aProtocol );

    tempPtr.Append( KDot8 );

    tempPtr.Append( aTarget );

    CleanupStack::Pop( temp );

    return temp;

    }

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

// CNATFWUNSAFQuerySrv::AddL

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

//

void CNATFWUNSAFQuerySrv::AddL( const TDnsRespSRV& aSrv )

    {

    TLinearOrder<TDnsRespSRV> order( CNATFWUNSAFQuerySrv::Compare );

    User::LeaveIfError(

        iRecordArray.InsertInOrderAllowRepeats( aSrv, order ) );

    }

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

// CNATFWUNSAFQuerySrv::SetTargetL

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

//

void CNATFWUNSAFQuerySrv::SetTargetL( const TDesC8& aTarget )

    {

    const TInt KMaxlength(256);

    __ASSERT_ALWAYS ( aTarget.Length() > 0, User::Leave( KErrArgument ) );

    __ASSERT_ALWAYS ( aTarget.Length() < KMaxlength, User::Leave( KErrArgument ) );

    HBufC8* temp = aTarget.AllocL();

    delete iTarget;

    iTarget = temp;

    }

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

// CNATFWUNSAFQuerySrv::RecordArray

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

//

RArray<TDnsRespSRV>& CNATFWUNSAFQuerySrv::RecordArray()

    {

    return iRecordArray;

    }

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

// CNATFWUNSAFQuerySrv::SRVRecordL

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

//

TDnsRespSRV& CNATFWUNSAFQuerySrv::SRVRecordL( TInt aIndex )

    {

    __ASSERT_ALWAYS ( aIndex < iRecordArray.Count(),

                      User::Leave( KErrArgument ) );

    return iRecordArray[aIndex];

    }

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

// CNATFWUNSAFQuerySrv::Compare

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

//

TInt CNATFWUNSAFQuerySrv::Compare( const TDnsRespSRV& aFirst,

                            const TDnsRespSRV& aSecond )

    {

    if ( aFirst.Priority() < aSecond.Priority() )

        {

        return -1;

        }

    if ( aFirst.Priority() > aSecond.Priority() )

        {

        return 1;

        }

    if ( aFirst.Priority() == aSecond.Priority() )

        {

        if ( aSecond.Weight() == 0 )

            {

            return -1;

            }

        else

            {

            return 1;

            }

        }

    return 0;

    }

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

// CNATFWUNSAFQuerySrv::QueryBuf

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

//

const TDesC8& CNATFWUNSAFQuerySrv::QueryBuf()

    {

    TDnsQuery query( *iTarget, KDnsRRTypeSRV );

    TDnsQueryBuf querybuf( query );

    return iQueryBuf = querybuf;

    }

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

// CNATFWUNSAFQuerySrv::QueryResultBuf

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

//

TDes8& CNATFWUNSAFQuerySrv::QueryResultBuf()

    {

    return iResult;

    }

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

// CNATFWUNSAFQuerySrv::QueryResult

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

//

TDnsRespSRV CNATFWUNSAFQuerySrv::QueryResult()

    {

    return iResult();

    }

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

// CNATFWUNSAFQuerySrv::Query

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

//

void CNATFWUNSAFQuerySrv::Query( MNATFWUNSAFHostResolver& aResolver )

    {

    aResolver.Resolver().Query( QueryBuf(),

                                QueryResultBuf(),

                                aResolver.RequestStatus() );

    }

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

// CNATFWUNSAFQuerySrv::HandleQueryResultL

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

//

void CNATFWUNSAFQuerySrv::HandleQueryResultL(

    MNATFWUNSAFHostResolver& aResolver )

    {

    if ( QueryResult().Target().CompareF( KDot8 ) != KErrNone )

        {

        AddL( QueryResult() );

        }

    while ( aResolver.Resolver().QueryGetNext( QueryResultBuf() )

                                                == KErrNone )

        {

        if ( QueryResult().Target().CompareF( KDot8 ) != KErrNone )

            {

            //Records are sorted in right order in inserting phase

            AddL( QueryResult() );

            }

        }

    }

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

// CNATFWUNSAFQuerySrv::ResultTargetL

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

//

const TDesC8& CNATFWUNSAFQuerySrv::ResultTargetL()

    {

    return SRVRecordL( 0 ).Target();

    }

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

// CNATFWUNSAFQuerySrv::ResultPortL

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

//

TUint CNATFWUNSAFQuerySrv::ResultPortL()

    {

    return SRVRecordL( 0 ).Port();

    }

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

// CNATFWUNSAFQuerySrv::RemoveElementL

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

//

void CNATFWUNSAFQuerySrv::RemoveElementL( TInt aIndex )

    {

    if ( aIndex < iRecordArray.Count() && aIndex >= 0 )

        {

        iRecordArray.Remove( aIndex );

        }

    }

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

// CNATFWUNSAFQuerySrv::ArrayCountL

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

//

TUint CNATFWUNSAFQuerySrv::ArrayCountL()

    {

    return iRecordArray.Count();

    }