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



#include "CSIPHostResolver.h"
#include "CServerQuery.h"
#include "CRequestQueue.h"
#include "MSIPServerResolverObserver.h"
#include "siperr.h"

// ----------------------------------------------------------------------------
// CSIPHostResolver::CSIPHostResolver
// ----------------------------------------------------------------------------
//
CSIPHostResolver::CSIPHostResolver() 
 : CActive( EPriorityStandard )
	{
	CActiveScheduler::Add( this );
	}

// ----------------------------------------------------------------------------
// CSIPHostResolver::ConstructL
// ----------------------------------------------------------------------------
//
void CSIPHostResolver::ConstructL ( RSocketServ& aServer, 
                                    RConnection& aConnection )
	{
	iObserverCancel = EFalse;
	iFailed = EFalse;
	User::LeaveIfError( iResolver.Open( aServer, KAfInet, KProtocolInetUdp, 
		                                aConnection ) );
	iRequestQueue = CRequestQueue::NewL();
	
	}

// ----------------------------------------------------------------------------
// CSIPHostResolver::NewL
// ----------------------------------------------------------------------------
//
CSIPHostResolver* CSIPHostResolver::NewL( RSocketServ& aServer, 
                                          RConnection& aConnection )
	{
	CSIPHostResolver* self = NewLC( aServer, aConnection );
	CleanupStack::Pop( self );
	return self;
	}

// ----------------------------------------------------------------------------
// CSIPHostResolver::NewLC
// ----------------------------------------------------------------------------
//
CSIPHostResolver* CSIPHostResolver::NewLC( RSocketServ& aServer, 
                                           RConnection& aConnection )
	{
	CSIPHostResolver* self = new ( ELeave ) CSIPHostResolver();
	CleanupStack::PushL( self );
	self->ConstructL( aServer, aConnection );
	return self;
	}

// ----------------------------------------------------------------------------
// CSIPHostResolver::~CSIPHostResolver
// ----------------------------------------------------------------------------
//
CSIPHostResolver::~CSIPHostResolver()
	{
	Cancel();
	iResolver.Close();
	delete iRequestQueue;
	delete iQuery;
	}

// ----------------------------------------------------------------------------
// CSIPHostResolver::GetByQueryL
// ----------------------------------------------------------------------------
//
void CSIPHostResolver::GetByQueryL ( CServerQuery* aQuery )
	{
	if( !IsActive() && !iQuery )
		{
		iQuery = aQuery;
		iQuery->Query( *this );
		SetActive();
		}
	else
		{
		if ( iQuery->ServerResolverObserver() == 
										    aQuery->ServerResolverObserver() )
			{
			User::Leave( KErrAlreadyExists );
			}
		iRequestQueue->AddL( *aQuery );
		}
	}

// ----------------------------------------------------------------------------
// CSIPHostResolver::CancelGetByURI
// ----------------------------------------------------------------------------
//
void CSIPHostResolver::CancelGetByURI( MSIPServerResolverObserver* aObserver )
	{
	if ( iQuery != 0 && iQuery->ServerResolverObserver() == aObserver )
		{
		Cancel();
		ResolveNext();
		}
	else
		{
		iRequestQueue->CancelQuery( aObserver );
		}
	}

// ----------------------------------------------------------------------------
// CSIPHostResolver::RunL
// ----------------------------------------------------------------------------
//
void CSIPHostResolver::RunL()
	{
	iFailed = EFalse;
	TBool subquery = EFalse;
	TInt status = iStatus.Int();
	
	MSIPServerResolverObserver* observer = NULL;
	
	if(iQuery != 0)
	{
		observer = iQuery->ServerResolverObserver();

		if ( iQuery && !iObserverCancel )
		{
			subquery = iQuery->HandleQueryResultL( iStatus.Int() );
		}

		if ( subquery )
		{
			iQuery->Query( *this );
			SetActive();
		}
		else
		{
			delete iQuery;
			iQuery = NULL;
			ResolveNext();
		}
	}
	else
	{
		delete iQuery;
		iQuery = NULL;
		ResolveNext();
	}

		
	if ( !subquery && ( status != KErrNone || iFailed ) && !iObserverCancel)
		{
		if ( status != KErrNoMemory )
			{
			status = KErrSIPResolvingFailure;
			}
		if(observer != 0)
			observer->ErrorOccured( status );
		}
	else
		{
		iObserverCancel = EFalse;
		}
	}

// ----------------------------------------------------------------------------
// CSIPHostResolver::RunError
// ----------------------------------------------------------------------------
//
TInt CSIPHostResolver::RunError ( TInt aError )
	{
	TInt err = KErrNone;
	// Complete the query, as RunL has not completed it.
	if ( iQuery )
		{
		MSIPServerResolverObserver* observer = iQuery->ServerResolverObserver();
		delete iQuery; 
		iQuery = NULL;
		observer->ErrorOccured( aError );
		}
		
	if ( aError == KErrNoMemory )
		{
		err = aError;
		}
		
	return err;
	}

// ----------------------------------------------------------------------------
// CSIPHostResolver::ResolveNext
// ----------------------------------------------------------------------------
//
void CSIPHostResolver::ResolveNext()
	{
	if ( !IsActive() )
		{
		iQuery = iRequestQueue->NextQuery();
		if ( iQuery )
			{
			iQuery->Query( *this );
			SetActive();
			}
		}
	}

// ----------------------------------------------------------------------------
// CSIPHostResolver::DoCancel
// ----------------------------------------------------------------------------
//
void CSIPHostResolver::DoCancel ()
	{
	iResolver.Cancel();
	if ( iQuery )
		{
		iObserverCancel = ETrue;
		delete iQuery; 
		iQuery = NULL;
		}
	}

// ----------------------------------------------------------------------------
// CSIPHostResolver::Resolver
// ----------------------------------------------------------------------------
//
RHostResolver& CSIPHostResolver::Resolver ()
	{
	return iResolver;
	}

// ----------------------------------------------------------------------------
// CSIPHostResolver::RequestStatus
// ----------------------------------------------------------------------------
//
TRequestStatus& CSIPHostResolver::RequestStatus ()
	{
	return iStatus;
	}

// ----------------------------------------------------------------------------
// CSIPHostResolver::SetIPListFailed
// ----------------------------------------------------------------------------
//
void CSIPHostResolver::SetIPListFailed( TBool aFailed )
	{
	iFailed = aFailed;
	}