// 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          : CSIPQuerySrv.cpp
// Part of       : ServerResolver
// Version       : SIP/4.0 
//



#include <stringpool.h>
#include "sipstrings.h"
#include "sipstrconsts.h"
#include "CSIPQuerySrv.h"
#include "MSIPHostResolver.h"

_LIT8(KDot8, ".");
// ----------------------------------------------------------------------------
// CSIPQuerySrv::CSIPQuerySrv
// ----------------------------------------------------------------------------
//
CSIPQuerySrv::CSIPQuerySrv(TBool aSipsUri)
:CSIPQueryBase(), iSipsUri(aSipsUri)
	{
	}

// ----------------------------------------------------------------------------
// CSIPQuerySrv::ConstructL
// ----------------------------------------------------------------------------
//
void CSIPQuerySrv::ConstructL( const TDesC8& aTarget )
	{
 	SetTargetL( aTarget );
	}
	
// ----------------------------------------------------------------------------
// CSIPQuerySrv::NewL
// ----------------------------------------------------------------------------
//
CSIPQuerySrv* CSIPQuerySrv::NewL( const TDesC8& aTarget, TBool aSipsUri )
	{
	CSIPQuerySrv* self = new ( ELeave ) CSIPQuerySrv(aSipsUri);
	CleanupStack::PushL( self );
	self->ConstructL( aTarget );
	CleanupStack::Pop( self );
	return self;
	}

// ----------------------------------------------------------------------------
// CSIPQuerySrv::~CSIPQuerySrv
// ----------------------------------------------------------------------------
//
CSIPQuerySrv::~CSIPQuerySrv()
	{
	delete iTarget;
	iRecordArray.Reset();
	}

// ----------------------------------------------------------------------------
// CSIPQuerySrv::SetTargetProtocolL
// ----------------------------------------------------------------------------
//
HBufC8* CSIPQuerySrv::SetTargetProtocolL( const TDesC8& aTarget,
										  RStringF aProtocol,
										  TBool aIsSipsUri )
	{
	_LIT8(Ksipudp, "_sip._udp.");
	_LIT8(Ksiptcp, "_sip._tcp.");
	_LIT8(Ksipstcp, "_sips._tcp.");
	TUint32 len = aTarget.Length() + Ksipudp().Length();
	if (aIsSipsUri)
		{
		len++;
		}
	HBufC8* temp =  HBufC8::NewLC( len );
	TPtr8 tempPtr = temp->Des();
	if (aIsSipsUri)
		{
		// If SIPS URI, ignore the value of aProtocol. and act always as
		// transport is TLS (Ksipstcp)
		tempPtr.Append( Ksipstcp );
		}

	else if ( aProtocol == SIPStrings::StringF( SipStrConsts::ETCP ) )
		{
		tempPtr.Append( Ksiptcp );
		}
		else if ( aProtocol == SIPStrings::StringF( SipStrConsts::EUDP ) )
			{
			tempPtr.Append( Ksipudp );
			}
			else
				{
				User::Leave( KErrNotSupported );
				}
	tempPtr.Append( aTarget );
	CleanupStack::Pop( temp );
	return temp;
	}
	
// ----------------------------------------------------------------------------
// CSIPQuerySrv::SetTargetTLSL
// ----------------------------------------------------------------------------
//
HBufC8* CSIPQuerySrv::SetTargetTLSL( const TDesC8& aTarget )
	{
	_LIT8(Ksiptls, "_sip._tls.");
	TUint32 len = aTarget.Length() + Ksiptls().Length();
	HBufC8* temp =  HBufC8::NewLC( len );
	TPtr8 tempPtr = temp->Des();
	tempPtr.Append( Ksiptls );
	tempPtr.Append( aTarget );
	CleanupStack::Pop( temp );
	return temp;
	}
	
// ----------------------------------------------------------------------------
// CSIPQuerySrv::AddL
// ----------------------------------------------------------------------------
//
void CSIPQuerySrv::AddL( TDnsRespSRV aSrv )
	{
	TLinearOrder<TDnsRespSRV> order( CSIPQuerySrv::Compare );
	User::LeaveIfError( iRecordArray.InsertInOrderAllowRepeats( aSrv, order ) );
	}

// ----------------------------------------------------------------------------
// CSIPQuerySrv::SetTargetL
// ----------------------------------------------------------------------------
//
void CSIPQuerySrv::SetTargetL( const TDesC8& aTarget )
	{
	__ASSERT_ALWAYS ( aTarget.Length() > 0, User::Leave( KErrArgument ) );

	// KQueryDataMaxLength is same as TDnsQryData's max length in dns_qry.h
	const TInt KQueryDataMaxLength = 255; 	
	__ASSERT_ALWAYS ( aTarget.Length() < KQueryDataMaxLength, 
					User::Leave( KErrArgument ) );

	HBufC8* temp = aTarget.AllocL();
	delete iTarget;
	iTarget = temp;
	}

// ----------------------------------------------------------------------------
// CSIPQuerySrv::RecordArray
// ----------------------------------------------------------------------------
//
RArray<TDnsRespSRV>& CSIPQuerySrv::RecordArray()
	{
	return iRecordArray;
	} 

// ----------------------------------------------------------------------------
// CSIPQuerySrv::SRVRecordL
// ----------------------------------------------------------------------------
//
TDnsRespSRV& CSIPQuerySrv::SRVRecordL( TInt aIndex )
	{
	__ASSERT_ALWAYS ( aIndex < iRecordArray.Count(), 
					  User::Leave( KErrArgument ) );
					  
	return iRecordArray[aIndex];
	}

// ----------------------------------------------------------------------------
// CSIPQuerySrv::Compare
// ----------------------------------------------------------------------------
//
TInt CSIPQuerySrv::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;
	}

// ----------------------------------------------------------------------------
// CSIPQuerySrv::QueryBuf
// ----------------------------------------------------------------------------
//
const TDesC8& CSIPQuerySrv::QueryBuf()
	{
	TDnsQuery query( *iTarget, KDnsRRTypeSRV );
	TDnsQueryBuf querybuf( query );
	return iQueryBuf = querybuf;
	}

// ----------------------------------------------------------------------------
// CSIPQuerySrv::QueryResultBuf
// ----------------------------------------------------------------------------
//
TDes8& CSIPQuerySrv::QueryResultBuf()
	{
	return iResult;
	}

// ----------------------------------------------------------------------------
// CSIPQuerySrv::QueryResult
// ----------------------------------------------------------------------------
//
TDnsRespSRV CSIPQuerySrv::QueryResult()
	{
	return iResult();
	}

// ----------------------------------------------------------------------------
// CSIPQuerySrv::Query
// ----------------------------------------------------------------------------
//
void CSIPQuerySrv::Query( MSIPHostResolver& aResolver )
	{
	aResolver.Resolver().Query( QueryBuf(), 
								QueryResultBuf(), 
								aResolver.RequestStatus() );	
	}

// ----------------------------------------------------------------------------
// CSIPQuerySrv::HandleQueryResultL
// ----------------------------------------------------------------------------
//
void CSIPQuerySrv::HandleQueryResultL( MSIPHostResolver& 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() );
			}
		}
	}

// ----------------------------------------------------------------------------
// CSIPQuerySrv::ResultTargetL
// ----------------------------------------------------------------------------
//
const TDesC8& CSIPQuerySrv::ResultTargetL()
	{
	return SRVRecordL( 0 ).Target();
	}

// ----------------------------------------------------------------------------
// CSIPQuerySrv::ResultPortL
// ----------------------------------------------------------------------------
//
TUint CSIPQuerySrv::ResultPortL() 
	{
	return SRVRecordL( 0 ).Port();
	}
	
// ----------------------------------------------------------------------------
// CSIPQuerySrv::RemoveElementL
// ----------------------------------------------------------------------------
//
void CSIPQuerySrv::RemoveElementL( TInt aIndex )
	{
	if ( aIndex < iRecordArray.Count() && aIndex >= 0 )
		{
		iRecordArray.Remove( aIndex );
		}
	}

// ----------------------------------------------------------------------------
// CSIPQuerySrv::ArrayCount
// ----------------------------------------------------------------------------
//
TInt CSIPQuerySrv::ArrayCount() 
	{
	return iRecordArray.Count();
	}