--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/applayerpluginsandutils/uripermissionservices/client/src/ineturilistimpl.cpp	Tue Feb 02 01:09:52 2010 +0200
@@ -0,0 +1,327 @@
+// Copyright (c) 2007-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:
+// ineturilist.cpp
+//
+//
+
+#include <e32base.h>
+#include "ineturilistimpl.h"
+#include "ineturiimpl.h"
+#include <uriutils.h>
+
+CInetUriListImpl::CInetUriListImpl ()
+	{		
+	}
+	
+CInetUriListImpl::~CInetUriListImpl ()
+	{
+	iInetUriListSession.Close ();
+	}
+/**
+Standard factory construction method
+
+*/
+CInetUriListImpl* CInetUriListImpl::NewL ()
+	{
+	CInetUriListImpl* self = new ( ELeave ) CInetUriListImpl ();
+	CleanupStack::PushL ( self );
+	self->ConstructL ();
+	CleanupStack::Pop ( self );	
+	return self;
+	}
+	
+void CInetUriListImpl::ConstructL ()
+	{
+	User::LeaveIfError ( iInetUriListSession.Connect () );
+	}
+/**
+Add a new URI to the storage. The session with the server must have been already opened.
+
+@param aInetUri A fully constructed URI object
+
+*/
+void CInetUriListImpl::AddL ( const RInetUri& aInetUri )
+	{
+	// Add to the database
+	iInetUriListSession.AddL ( aInetUri.Impl() );
+	}
+
+/**
+Removes the URI from the storage. Function will leave if the URI object is read-only
+
+@leave KErrUriReadOnly The URI object is read-only and cannot be removed
+*/
+void CInetUriListImpl::RemoveL ( const RInetUri& aInetUri )
+	{		
+	// Only URIs with read-write permission can be removed
+	aInetUri.Impl().LeaveIfReadOnlyL ();
+
+	// Remove from the list and database
+	iInetUriListSession.RemoveL ( aInetUri.Impl() );
+	}
+
+/**
+Updates the URI in the storage. Only favouritename & listtype will be updated
+
+@param aInetUri URI object
+@leave KErrUriReadOnly The URI object is read-only and cannot be modified
+*/
+void CInetUriListImpl::UpdateL ( const RInetUri& aInetUri )
+	{		
+	// Only URIs with read-write permission can be updated
+	aInetUri.Impl().LeaveIfReadOnlyL ();
+
+	// Update the list and database
+	iInetUriListSession.UpdateL ( aInetUri.Impl() );
+	}
+
+/**
+Counts the number of URIs in the list, given ServiceType and a ListType
+*/
+TInt CInetUriListImpl::Count ( InetUriList::TServiceType aServiceType, InetUriList::TListType aListType )
+	{
+	return 	iInetUriListSession.Count ( aServiceType, aListType );
+	}
+
+/**
+Retrieves the Listtype of a give URI, given ServiceType. 
+
+@return KErrUriNotFound The URI is not found in the list
+		KErrNone The URI is found in the list and the aListType value is set.
+*/
+TInt CInetUriListImpl::GetListType ( const TDesC8& aUri, InetUriList::TServiceType aServiceType, InetUriList::TListType& aListType )
+	{		
+	TInt ret = KErrNone;
+	TRAPD ( err, ret = iInetUriListSession.GetListTypeL ( DoNormalisationLC ( aUri, NULL ), aServiceType, aListType ); CleanupStack::PopAndDestroy (); );	
+	if ( err != KErrNone )
+		ret = err;
+	return ret;
+	}
+
+/**
+Queries the URI in the list, given ServiceType & URI as argument. An exact URI match
+will be performed.
+
+@param aUri URI descriptor
+@param aServiceType Servicetype which the URI represents
+
+@return A RInetUri object. Application can use this object for further operations
+@leave KErrUriNotFound The URI is not found in the list for the given servicetype
+*/
+RInetUri CInetUriListImpl::QueryUriL ( const TDesC8& aUri, InetUriList::TServiceType aServiceType )
+	{
+	TQueryArgs args ( aServiceType, InetUriList::EExact );
+	CUriListReadStream* uriListStream = iInetUriListSession.QueryUriL ( DoNormalisationLC ( aUri, NULL ), args );
+	CleanupStack::PushL ( uriListStream );
+
+	TInt totalRecords = uriListStream->ReadUriListL ();
+	
+	if ( totalRecords <= 0 )
+		{
+		User::Leave ( InetUriList::KErrUriNotFound );
+		}
+
+	RInetUri inetUri = UnpackL ( uriListStream->BufReadStream() );
+	CleanupStack::PopAndDestroy (2); // uriListStream, object added in DoSyntaxNormalisationLC
+	return inetUri;
+	}
+
+/**
+Queries for the URI in the list.
+
+@param aArgs Query argument. The ServiceType is mandatory and need to be set with the argument. 
+			 Other query parameters are optional
+@param aQueryCallback The callback function that will be called to return the query results 
+@param aUriCustomiser The callback function that need to implement the customisation of the URI if the application wishes
+
+@leave KErrServiceTypeNotPresent The servicetype value is not present in the query argument and is mandatory
+
+*/
+void CInetUriListImpl::QueryUriL ( const TQueryArgs& aArgs, MQueryResultsCallback& aQueryCallback, MUriCustomiser* aUriCustomiser )
+	{
+	// Check service type is present in the args. Without service type no query operation
+	// will be performed
+	if ( aArgs.Get ( TQueryArgs::EServiceType ) == KErrNotFound )
+		{
+		User::Leave ( InetUriList::KErrServiceTypeNotPresent );
+		}
+	
+	CUriListReadStream* uriListStream = NULL;
+	
+	#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
+  	if ( aArgs.Get ( TQueryArgs::EUri ) != KErrNotFound ) 
+ 		{
+ 		const TDesC8& uri = *(reinterpret_cast<TDesC8*> ( aArgs.Get ( TQueryArgs::EUri ) ));
+		// Do normalisation
+		TPtrC8 customisedUri ( DoNormalisationLC ( uri, aUriCustomiser ) );
+		uriListStream = iInetUriListSession.QueryUriL ( customisedUri, aArgs );	
+		CleanupStack::PopAndDestroy (); // objects added in DoNormalisationLC
+		}
+	else
+		{
+		uriListStream = iInetUriListSession.QueryUriL ( aArgs );	
+		}	
+	#else
+  	if ( aArgs.IsSet ( TQueryArgs::EUri ) )
+ 		{
+ 		const TDesC8& uri = *(reinterpret_cast<TDesC8*> ( aArgs.Get ( TQueryArgs::EUri ) ));
+		// Do normalisation
+		TPtrC8 customisedUri ( DoNormalisationLC ( uri, aUriCustomiser ) );
+		uriListStream = iInetUriListSession.QueryUriL ( customisedUri, aArgs );	
+		CleanupStack::PopAndDestroy (); // objects added in DoNormalisationLC
+		}
+	else
+		{
+		uriListStream = iInetUriListSession.QueryUriL ( aArgs );	
+		}	
+	
+	#endif	//SYMBIAN_ENABLE_SPLIT_HEADERS
+
+	CleanupStack::PushL ( uriListStream );
+	
+	RetrieveResultsL ( *uriListStream, aQueryCallback );
+
+	CleanupStack::PopAndDestroy (); // uriListStream
+
+	}
+
+/**
+Retrieves the query results from the server. The stream will be closed once the client has received
+all the records or upon request by the application via the reqturn value of query results callback function
+*/	
+void CInetUriListImpl::RetrieveResultsL ( CUriListReadStream& aListStream, MQueryResultsCallback& aQueryCallback )
+	{
+	TBool bContinue = ETrue;
+	do
+		{
+		TInt totalRecords = aListStream.ReadUriListL ();
+		if ( totalRecords <= 0 )
+			{
+			bContinue = EFalse;
+			}
+		
+		
+		for ( TInt i = 1; i <= totalRecords; ++i )
+			{
+			// Unpack and do callback				
+			RInetUri inetUri = UnpackL ( aListStream.BufReadStream() );
+			if ( !aQueryCallback.OnQueryResultsL ( inetUri ) )
+				{
+				// Client has asked to stop the retrieval of query resuls
+				// break the operation.
+				bContinue = EFalse;
+				break;
+				}
+			}
+		} while ( bContinue );		
+	}
+	
+/**
+Unpacks the data stream and constructs a full URI object
+*/
+RInetUri CInetUriListImpl::UnpackL ( RReadStream& aStream )
+	{
+	CInetUriImpl* inetUri = CInetUriImpl::NewL ();
+	CleanupStack::PushL ( inetUri )	;
+	inetUri->UnpackL ( aStream );
+	RInetUri inetUriObj;
+	inetUriObj.Attach ( *inetUri );
+	CleanupStack::Pop (); //inetUri
+	return inetUriObj;
+	}
+
+
+/**
+Does the syntax based normalisation. If the MUriCustomiser is set then it customises the URI, 
+that is, do the protocol/scheme-based normalisation on the URI. The customisation algorithm needs 
+to be implemented by the application. 
+*/
+const TDesC8& CInetUriListImpl::DoNormalisationLC ( const TDesC8& aUri, MUriCustomiser* aUriCustomiser )
+	{
+	// Do a syntax based normalisation
+	TUriParser8 uriParser;
+	User::LeaveIfError ( uriParser.Parse ( aUri ) );
+	CUri8* normalisedUri = UriUtils::NormaliseUriL ( uriParser );	
+	CleanupStack::PushL ( normalisedUri );
+	if ( aUriCustomiser )
+		{
+		normalisedUri = aUriCustomiser->OnUriCustomisationL	( normalisedUri->Uri() );
+		CleanupStack::PopAndDestroy (); // Added after UriUtils::NormaliseUriL
+		CleanupStack::PushL ( normalisedUri );
+		}
+	return 	normalisedUri->Uri().UriDes();	
+	}
+	
+/**
+Queries on Uri either to fetch the TLD Policy data or get the List type of the given Uri.
+
+@param aArgs TPolicyQueryArgs argument. The Uri and Querytype are mandatory. 
+			 To fetch Charset, List type is Mandatory, whereas to fetch List type it is not.
+@param aResultArgs is out parmeter contains either List type info or Charset info. Based on the QueryType.
+
+@leave KErrInvalidTLD The TLD type if No policy data is available for the given TLD and Requested ListType.
+*/
+void CInetUriListImpl::QueryTldInfoL ( const TPolicyQueryArgs& aArgs, TQueryResults&   aResultArgs )
+	{
+	// Check Uri type is present in the args.
+	if ( aArgs.Get ( TPolicyQueryArgs::ETldUri ) == KErrNotFound )
+		{
+		User::Leave ( InetUriList::KErrTldUriNotPresent );
+		}
+	// Query type is present in the args. 
+	// Without these no query operation will be performed
+	if ( aArgs.Get ( TPolicyQueryArgs::ETldQueryType ) == KErrNotFound )
+		{
+		User::Leave ( InetUriList::KErrTldQueryTypeNotPresent );
+		}
+
+	InetUriList::TTLDQueryType queryType (InetUriList::EPolicyListType);
+	queryType = static_cast < InetUriList::TTLDQueryType > ( aArgs.Get ( TPolicyQueryArgs::ETldQueryType ) );	
+		
+	// Identify the Host type whether it is WhiteListed or BlackListed
+	if ( queryType == InetUriList::EPolicyListType )
+		{
+		InetUriList::TListType lt(InetUriList::EBlackList);
+		TInt result = iInetUriListSession.GetHostType(aArgs);
+		User::LeaveIfError( result );				
+		lt = static_cast < InetUriList::TListType > ( result );
+		aResultArgs.Set(lt);
+		}
+	//fetch Policy data and send the results in TQueryResults
+	else 	
+		{
+		HBufC8* results(NULL);
+		results = FetchPolicyDataL ( aArgs );
+		//owner ship of results with TQueryResults	
+		aResultArgs.Set(results);
+		}
+	}
+
+/**
+Fetch Policy data
+*/
+HBufC8* CInetUriListImpl::FetchPolicyDataL(const TPolicyQueryArgs& aArgs )	
+	{
+	TInt policyLength = iInetUriListSession.PolicyDataLength( aArgs );
+	//Policy file contains empty body for Requested white/Black listed data
+	User::LeaveIfError ( policyLength );		
+	HBufC8* policydata = HBufC8::NewL( policyLength );
+	CleanupStack::PushL( policydata );
+	TPtr8 ptr ( policydata->Des() ) ;
+	TInt err = iInetUriListSession.QueryTldInfo( aArgs, ptr );
+	CleanupStack::Pop( policydata );
+	User::LeaveIfError( err );
+	return policydata;
+	}
+