// Copyright (c) 2004-2009 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:
// Name          : CSIPQueryData.cpp
// Part of       : ServerResolver
// Version       : SIP/4.0 
//



#include <utf.h>
#include "CSIPQueryData.h"
#include "CSIPQueryBase.h"
#include "CSIPQueryA_AAAA.h"
#include "MSIPHostResolver.h"
#include "MSIPResolvingResult.h"
#include "CSIPResolvingResult.h"
#include "MSIPServerResolverObserver.h"

// ----------------------------------------------------------------------------
// CSIPQueryData::CSIPQueryData
// ----------------------------------------------------------------------------
//
CSIPQueryData::CSIPQueryData( MSIPHostResolver& aResolver,
							  RPointerArray< MSIPResolvingResult >& aResult,
							  TBool aSipsUri,
							  TBool aForceUDP ) :
	iResolver ( aResolver ),
	iResultArray ( aResult ),
	iSipsUri ( aSipsUri ),
	iForceUDP ( aForceUDP )
	{
	}

// ----------------------------------------------------------------------------
// CSIPQueryData::ConstructL
// ----------------------------------------------------------------------------
//
void CSIPQueryData::ConstructL( MSIPServerResolverObserver* aObserver,
                                TUint aPort,
                                RStringF aProtocol,
                                const TDesC8& aOriginalTarget )
	{
	iPort = aPort;
	iProtocol = aProtocol;
	iTarget = aOriginalTarget.AllocL();
	iOriginalTarget = aOriginalTarget.AllocL();
	iObserver = aObserver;
	}

// ----------------------------------------------------------------------------
// CSIPQueryData::NewL
// ----------------------------------------------------------------------------
//
CSIPQueryData* CSIPQueryData::NewL( MSIPServerResolverObserver* aObserver,
                               TUint aPort,
                               RStringF aProtocol,
                               const TDesC8& aOriginalTarget,
							   MSIPHostResolver& aResolver,
							   RPointerArray< MSIPResolvingResult >& aResult,
							   TBool aSipsUri,
							   TBool aForceUDP )
	{
	CSIPQueryData* self =
		new ( ELeave ) CSIPQueryData( aResolver, aResult, aSipsUri, aForceUDP );
	CleanupStack::PushL( self );
	self->ConstructL( aObserver, aPort, aProtocol, aOriginalTarget );
	CleanupStack::Pop( self );
	return self;
	}

// ----------------------------------------------------------------------------
// CSIPQueryData::~CSIPQueryData
// ----------------------------------------------------------------------------
//
CSIPQueryData::~CSIPQueryData()
	{	
	delete iTarget;
	delete iOriginalTarget;
	iProtocol.Close();
	}

// ----------------------------------------------------------------------------
// CSIPQueryData::ResultArray
// ----------------------------------------------------------------------------
//	
RPointerArray<MSIPResolvingResult>& CSIPQueryData::ResultArray() 
	{
	return iResultArray;
	}

// ----------------------------------------------------------------------------
// CSIPQueryData::Observer
// ----------------------------------------------------------------------------
//	
MSIPServerResolverObserver* CSIPQueryData::Observer() 
	{
	return iObserver;
	}

// ----------------------------------------------------------------------------
// CSIPQueryData::Port
// ----------------------------------------------------------------------------
//	
TUint CSIPQueryData::Port() 
	{
	return iPort;
	}

// ----------------------------------------------------------------------------
// CSIPQueryData::Protocol
// ----------------------------------------------------------------------------
//	
RStringF CSIPQueryData::Protocol() 
	{
	return iProtocol;
	}

// ----------------------------------------------------------------------------
// CSIPQueryData::Target
// ----------------------------------------------------------------------------
//	
const TDesC8& CSIPQueryData::Target() const
	{
	return *iTarget;
	}

// ----------------------------------------------------------------------------
// CSIPQueryData::OriginalTarget
// ----------------------------------------------------------------------------
//	
const TDesC8& CSIPQueryData::OriginalTarget() const
	{
	return *iOriginalTarget;
	}

// ----------------------------------------------------------------------------
// CSIPQueryData::Resolver
// ----------------------------------------------------------------------------
//	
MSIPHostResolver& CSIPQueryData::Resolver()
	{
	return iResolver;
	}

// ----------------------------------------------------------------------------
// CSIPQueryData::SetPort
// ----------------------------------------------------------------------------
//	
void CSIPQueryData::SetPort( TUint aPort )
	{
	iPort = aPort;
	}

// ----------------------------------------------------------------------------
// CSIPQueryData::SetProtocol
// ----------------------------------------------------------------------------
//	
void CSIPQueryData::SetProtocol( RStringF aProtocol )
	{	
	iProtocol.Close();
	iProtocol = aProtocol.Copy();	
	}

// ----------------------------------------------------------------------------
// CSIPQueryData::SetTargetL
// ----------------------------------------------------------------------------
//	
void CSIPQueryData::SetTargetL( const TDesC8& aTarget )
	{
	HBufC8* temp = aTarget.AllocL();
	delete iTarget;
	iTarget = temp;
	}

// ----------------------------------------------------------------------------
// CSIPQueryData::SetOriginalTargetL
// ----------------------------------------------------------------------------
//	
void CSIPQueryData::SetOriginalTargetL( const TDesC8& aOriginalTarget )
	{
	HBufC8* temp = aOriginalTarget.AllocLC();
	delete iOriginalTarget;
	iOriginalTarget = temp;
	CleanupStack::Pop( temp );
	}

// ----------------------------------------------------------------------------
// CSIPQueryData::CreateResultL
// ----------------------------------------------------------------------------
//
TBool CSIPQueryData::CreateResultL( CSIPQueryA_AAAA& aQuery )
	{
	TBool result = EFalse;
	iQuery = &aQuery;
	if ( AddResultToArrayL() )
		{
		result = ETrue;
		}
	while ( iQuery->QueryNext( iResolver ) )
		{
		if ( AddResultToArrayL() )
			{
			result = ETrue;
			}
		}
	return result;
	}

// ----------------------------------------------------------------------------
// CSIPQueryData::AddResultToArrayL
// ----------------------------------------------------------------------------
//
TBool CSIPQueryData::AddResultToArrayL()
    {
    if ( iQuery->DnsNoRoute() )
    	{
    	return EFalse;
    	}
	TInetAddr addr( iQuery->QueryResultBuf() );
	addr.SetPort( iPort );
	for ( TInt i=0;i < ResultArray().Count();i++ )
		{
		if ( ResultArray()[i]->Address().CmpAddr( addr ) 
				&& ResultArray()[i]->Protocol() == iProtocol )
			{
			return EFalse;
			}
		}

	CSIPResolvingResult* result =
		CSIPResolvingResult::NewLC( addr, iProtocol, iForceUDP );
	User::LeaveIfError( ResultArray().Append( result ) );
	CleanupStack::Pop( result );
	return ETrue;
    }

// ----------------------------------------------------------------------------
// CSIPQueryData::IsSipsUri
// ----------------------------------------------------------------------------
//
TBool CSIPQueryData::IsSipsUri()
    {
    return iSipsUri;
    }

// ----------------------------------------------------------------------------
// CSIPQueryData::SetForceUDP
// ----------------------------------------------------------------------------
//
void CSIPQueryData::SetForceUDP()
	{
	iForceUDP = ETrue;
	}

// ----------------------------------------------------------------------------
// CSIPQueryData::CompleteQueryL
// ----------------------------------------------------------------------------
//
void CSIPQueryData::CompleteQueryL()
    {
	iObserver->CompletedL();
    }