diff -r 000000000000 -r b16258d2340f applayerpluginsandutils/uripermissionservices/server/src/ineturilistserver.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/applayerpluginsandutils/uripermissionservices/server/src/ineturilistserver.cpp	Tue Feb 02 01:09:52 2010 +0200
@@ -0,0 +1,517 @@
+// Copyright (c) 2008-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:
+//
+
+#include <s32mem.h>
+#include "ineturilistserver.h"
+#include "urilistinterface.h"
+#include "sqldbtransaction.h"
+
+
+const TUint KRangeCount = 4;
+const TUint8 KPolicyElementReadDeviceData =	0;
+const TUint8 KPolicyElementWriteDeviceData = 1;
+const TInt KOpCodeRanges [ KRangeCount ] =
+	{
+	CInetUriListServer::EListType, // AlwaysPass
+	CInetUriListServer::EQuery,	   // ReadDeviceData: CInetUriListServer::EQuery ... 
+	CInetUriListServer::EAddUri,  // WriteDeviceData: CInetUriListServer::EAddUri ... CInetUriListServer::EUpdateUri
+	CInetUriListServer::ENotSupported			
+	};
+
+const TUint8 KElementsIndex [ KRangeCount ] =
+	{	
+	CPolicyServer::EAlwaysPass,
+	KPolicyElementReadDeviceData,
+	KPolicyElementWriteDeviceData,
+	CPolicyServer::ENotSupported
+	};
+	
+const CPolicyServer::TPolicyElement KPolicyElements[] = 
+	{
+	{_INIT_SECURITY_POLICY_C1 ( ECapabilityReadDeviceData ), CPolicyServer::EFailClient }, 
+	{_INIT_SECURITY_POLICY_C1 ( ECapabilityWriteDeviceData ), CPolicyServer::EFailClient }, 
+	};
+
+const CPolicyServer::TPolicy KInetUriListServerPolicy = 
+	{
+	CPolicyServer::EAlwaysPass,
+	KRangeCount,
+	KOpCodeRanges,
+	KElementsIndex,
+	KPolicyElements
+	};
+
+CInetUriListServerSession::CInetUriListServerSession ()
+	{
+		
+	}
+
+CInetUriListServerSession::~CInetUriListServerSession ()
+	{	
+	iUriListStreams.Close ();
+	
+	( static_cast< const CInetUriListServer* >( Server() ) )->DecSessionCount();	
+	}
+
+CInetUriListServerSession* CInetUriListServerSession::NewL ()
+	{
+	CInetUriListServerSession* self = new ( ELeave ) CInetUriListServerSession;	
+	return self;
+	}
+
+void CInetUriListServerSession::ServiceL ( const RMessage2& aMessage )
+	{	
+	DispatchMessageL ( aMessage );
+	}
+
+void CInetUriListServerSession::ServiceError ( const RMessage2& aMessage, TInt aError )
+	{
+	aMessage.Complete( aError );
+	}	
+	
+CBufFlat* CInetUriListServerSession::ReadMessageLC ( TInt aParam, const RMessage2& aMessage )
+	{
+	TInt desMaxLen ( aMessage.GetDesMaxLengthL ( aParam ) ); // Maximum length of the descriptor
+	
+	// Read from client message buffer
+	CBufFlat* buffer = CBufFlat::NewL ( desMaxLen );
+	CleanupStack::PushL ( buffer );	
+	buffer->ExpandL ( 0, desMaxLen );
+	TPtr8 bufferPtr ( buffer->Ptr(0) );
+	aMessage.ReadL ( aParam, bufferPtr );
+	
+	return buffer;	
+	}
+
+CUriListStream* CInetUriListServerSession::GetListStreamL ( CUriQueryFilter* aQueryFilter )
+	{
+	CleanupStack::PushL ( aQueryFilter );
+	CUriListStream* listStream = CUriListStream::NewL ( aQueryFilter );
+	CleanupStack::Pop (); // aQueryFilter 
+	return listStream;	
+	}
+
+void CInetUriListServerSession::DispatchMessageL ( const RMessage2& aMessage )
+	{
+	TInt ret ( KErrNone );
+
+	switch ( aMessage.Function() )	
+		{	
+
+		case CInetUriListServer::EListType:
+		ret = GetListTypeL ( aMessage );
+		break;
+		
+		case CInetUriListServer::EQuery:
+		ret = QueryL ( aMessage );
+		break;
+		
+		case CInetUriListServer::EQueryWithUri:
+		ret = QueryWithUriL ( aMessage );
+		break;
+		
+		case CInetUriListServer::EReadQueryResults:
+		ret = ReadQueryResultsL ( aMessage );
+		break;
+		
+		case CInetUriListServer::ECloseSrvStream:
+		ret = CloseSrvStream ( aMessage );
+		break;
+		
+		case CInetUriListServer::EUriCount:
+		ret = UriCountL ( aMessage );
+		break;
+		
+		case CInetUriListServer::EAddUri:
+		ret = AddUriL ( aMessage );
+		break;
+		
+		case CInetUriListServer::ERemoveUri:
+		ret = RemoveUriL ( aMessage );
+		break;
+		
+		case CInetUriListServer::EUpdateUri:
+		ret = UpdateUriL ( aMessage );
+		break;
+
+		case CInetUriListServer::EQueryTldInfo:
+		ret = QueryTldInfoL ( aMessage );
+		break;
+	
+		case CInetUriListServer::ETldListType:
+		ret = GetHostTypeL(aMessage);
+		break;
+		
+		case CInetUriListServer::EPolicyLength:
+		ret = PolicyDataLengthL ( aMessage );
+		break;
+		
+		case CInetUriListServer::ENotSupported:
+		ret = KErrNotFound;	
+		break;				
+		
+		default:
+		ret = KErrNotSupported;
+		break;
+		}
+	
+	if ( ret != KRequestPending )
+		{
+		aMessage.Complete( ret );
+		}	
+	}
+
+
+TInt CInetUriListServerSession::AddUriL ( const RMessage2& aMessage )
+	{
+	CBufFlat* outBuffer = ReadMessageLC ( 0, aMessage );
+	
+	RBufReadStream readStream ( *outBuffer );
+	CleanupClosePushL ( readStream );
+	
+	TInt uriId = 0;
+	TInt propId = 0;
+	CUriListInterface* listInterface = ( static_cast < const CInetUriListServer* > ( Server() ) )->UriListInterface ();
+	listInterface->AddUriL ( readStream, uriId, propId );
+	
+	// Write back the uri id and property id
+	TPckgBuf < TInt > uriIdBuffer ( uriId );
+	TPckgBuf < TInt > propIdBuffer ( propId );
+	aMessage.WriteL ( 1, uriIdBuffer );
+	aMessage.WriteL ( 2, propIdBuffer );
+	
+	CleanupStack::PopAndDestroy ( 2 ); // outBuffer, readStream
+	return KErrNone;		
+	}
+	
+TInt CInetUriListServerSession::RemoveUriL ( const RMessage2& aMessage )
+	{
+	TPckgBuf < TInt > uriIdBuffer;
+	aMessage.ReadL ( 0, uriIdBuffer );
+	TPckgBuf < TInt > propIdBuffer;
+	aMessage.ReadL ( 1, propIdBuffer );
+	CUriListInterface* listInterface = ( static_cast < const CInetUriListServer* > ( Server() ) )->UriListInterface ();
+	
+	listInterface->RemoveUriL ( uriIdBuffer(), propIdBuffer() );
+	
+	return KErrNone;	
+	}
+
+TInt CInetUriListServerSession::UpdateUriL ( const RMessage2& aMessage )
+	{
+	TPckgBuf < TUint32 > idBuffer;
+	aMessage.ReadL ( 0, idBuffer );
+	TPckgBuf < InetUriList::TListType > listTypeBuffer;
+	aMessage.ReadL ( 1, listTypeBuffer );
+	
+	HBufC8* favouriteName = HBufC8::NewLC ( aMessage.GetDesLengthL ( 2 ) );
+	TPtr8 favouriteNamePtr ( favouriteName->Des () );
+	
+	aMessage.ReadL ( 2, favouriteNamePtr );
+	
+	CUriListInterface* listInterface = ( static_cast < const CInetUriListServer* > ( Server() ) )->UriListInterface ();
+	
+	listInterface->UpdateUriL ( idBuffer(), listTypeBuffer(), favouriteNamePtr );
+	
+	CleanupStack::PopAndDestroy (); // favouriteName
+	return KErrNone;	
+	}
+
+TInt CInetUriListServerSession::UriCountL ( const RMessage2& aMessage )
+	{
+	TPckgBuf < InetUriList::TServiceType > stBuffer;
+	TPckgBuf < InetUriList::TListType > ltBuffer;	
+	aMessage.ReadL ( 0, stBuffer );
+	aMessage.ReadL ( 1, ltBuffer );
+	
+	CUriListInterface* listInterface = ( static_cast < const CInetUriListServer* > ( Server() ) )->UriListInterface ();
+	return listInterface->CountUriL ( stBuffer(), ltBuffer() );	
+	}
+
+TInt CInetUriListServerSession::GetListTypeL ( const RMessage2& aMessage )
+	{
+	HBufC8* uri = HBufC8::NewLC ( aMessage.GetDesLengthL (0) );
+	TPtr8 uriPtr ( uri->Des() );
+	
+	aMessage.ReadL ( 0, uriPtr );
+	TPckgBuf < InetUriList::TServiceType > stBuffer;
+	aMessage.ReadL ( 1, stBuffer );
+	
+	CUriListInterface* listInterface = ( static_cast < const CInetUriListServer* > ( Server() ) )->UriListInterface ();
+	
+	InetUriList::TListType listType = listInterface->GetListTypeL ( uriPtr, stBuffer() ); 
+	TPckgBuf < InetUriList::TListType > ltBuffer ( listType );
+	
+	aMessage.WriteL ( 2, ltBuffer );
+	
+	CleanupStack::PopAndDestroy (); // uri
+	
+	return KErrNone;
+	}
+
+TInt CInetUriListServerSession::QueryWithUriL ( const RMessage2& aMessage )
+	{
+	RBuf8 uri;
+	CleanupClosePushL ( uri );
+	uri.CreateL (aMessage.GetDesLengthL (0));
+	TPckgBuf < TQueryArgs > queryArgs;
+	aMessage.ReadL ( 0, uri );
+	aMessage.ReadL ( 1, queryArgs );
+
+	CUriListInterface* listInterface = ( static_cast < const CInetUriListServer* > ( Server() ) )->UriListInterface ();
+	CUriListStream* listStream = GetListStreamL ( listInterface->QueryWithUriL ( uri, queryArgs() ) );		
+	CleanupStack::PopAndDestroy (); // uri
+	CleanupStack::PushL (listStream); 
+	iUriListStreams.AllocL ();
+	CleanupStack::Pop (); // listStream
+	return iUriListStreams.Add ( listStream );
+	}
+
+/**
+Fetches length of the Policy data
+*/	
+TInt CInetUriListServerSession::PolicyDataLengthL ( const RMessage2& aMessage )
+	{
+	RBuf8 uri;
+	CleanupClosePushL ( uri );
+	uri.CreateL (aMessage.GetDesLengthL (0));
+	TPckgBuf < TPolicyQueryArgs > queryArgs;
+	aMessage.ReadL ( 0, uri );
+	aMessage.ReadL ( 1, queryArgs );
+	CUriListInterface* listInterface = ( static_cast < const CInetUriListServer* > ( Server() ) )->UriListInterface ();
+	TInt length ( listInterface->PolicyDataLengthL( uri, queryArgs() ) );
+	CleanupStack::PopAndDestroy();//uri		
+	return length;
+	}
+
+/**
+Fetches Policy data
+*/
+TInt CInetUriListServerSession::QueryTldInfoL ( const RMessage2& aMessage )
+	{
+	RBuf8 uri;
+	CleanupClosePushL ( uri );
+	uri.CreateL (aMessage.GetDesLengthL (0));
+	TPckgBuf < TPolicyQueryArgs > queryArgs;
+	aMessage.ReadL ( 0, uri );
+	aMessage.ReadL ( 1, queryArgs );
+	CUriListInterface* listInterface = ( static_cast < const CInetUriListServer* > ( Server() ) )->UriListInterface ();
+	HBufC8* resultBuf = listInterface->QueryTldInfoL( uri, queryArgs() );
+	CleanupStack::PushL ( resultBuf );
+	TInt resultLength ( resultBuf->Length() ) ;
+	aMessage.Write(2,resultBuf->Des(),0);
+	CleanupStack::PopAndDestroy(2);//uri, resultBuf 
+	return resultLength;
+	}
+
+/**
+Identifies whther Hosttype is in Black List or White List
+*/
+TInt CInetUriListServerSession::GetHostTypeL ( const RMessage2& aMessage )
+	{
+	RBuf8 uri;
+	CleanupClosePushL ( uri );
+	uri.CreateL (aMessage.GetDesLengthL (0));
+	aMessage.ReadL ( 0, uri );
+	CUriListInterface* listInterface = ( static_cast < const CInetUriListServer* > ( Server() ) )->UriListInterface ();
+	TInt hostType ( listInterface->GetHostTypeL( uri ) ); 
+	CleanupStack::PopAndDestroy(); //uri
+	return hostType;
+	}
+
+TInt CInetUriListServerSession::QueryL ( const RMessage2& aMessage )
+	{
+	TPckgBuf < TQueryArgs > queryArgs;
+	aMessage.ReadL ( 0, queryArgs );
+	CUriListInterface* listInterface = ( static_cast < const CInetUriListServer* > ( Server() ) )->UriListInterface ();
+
+	CUriListStream* listStream = GetListStreamL ( listInterface->QueryL ( queryArgs() ) );	
+	CleanupStack::PushL (listStream); 
+	iUriListStreams.AllocL ();
+	CleanupStack::Pop ();	// listStream
+	return iUriListStreams.Add ( listStream );
+	}
+
+TInt CInetUriListServerSession::ReadQueryResultsL ( const RMessage2& aMessage )
+	{
+	TInt handle = aMessage.Int0 ();
+	TInt totalRecords = 0;
+	CUriListStream* listStream = iUriListStreams.Find ( handle );
+	if ( !listStream )
+		{
+		// Panic the client	
+		aMessage.Panic ( KInetUriListServerName(), InetUriList::KErrInvalidStreamHandle );
+		return totalRecords;
+		}
+	TPtrC8 dataPtr;
+	totalRecords = listStream->WriteUriListL ( dataPtr );
+	aMessage.WriteL ( 1, dataPtr );
+	return totalRecords;
+	}
+
+TInt CInetUriListServerSession::CloseSrvStream ( const RMessage2& aMessage )
+	{
+	TInt handle = aMessage.Int0 ();
+	iUriListStreams.Remove ( handle );
+	
+	return KErrNone;
+	}
+	
+// ----------------------------------------------------------------------
+
+
+CInetUriListServer::CInetUriListServer ()
+: CPolicyServer ( EPriorityStandard, KInetUriListServerPolicy, ESharableSessions ),
+	iSessionCount (0)
+	{
+		
+	}
+
+CInetUriListServer::~CInetUriListServer ()
+	{
+	delete iUriListInterface;
+	}
+
+CInetUriListServer* CInetUriListServer::NewL ()
+	{
+	CInetUriListServer* self = new ( ELeave ) CInetUriListServer;
+	CleanupStack::PushL ( self );
+	
+	self->ConstructL ();
+	
+	CleanupStack::Pop ( self );
+	return self;
+	}
+
+void CInetUriListServer::ConstructL ()
+	{	
+	StartL ( KInetUriListServerName );
+	
+	iUriListInterface = CUriListInterface::NewL ();
+	}
+	
+void CInetUriListServer::IncSessionCount () const
+	{
+	++iSessionCount;	
+	}
+
+void CInetUriListServer::DecSessionCount () const
+	{
+	--iSessionCount;
+	
+	if ( iSessionCount == 0 )	
+		{
+		CActiveScheduler::Stop ();			
+		}
+	}
+
+void CInetUriListServer::Error ( TInt aError )
+	{
+	Message().Complete ( aError );
+	ReStart();
+	}
+
+CSession2* CInetUriListServer::NewSessionL( const TVersion& aVersion, const RMessage2& /* aMessage */ ) const
+	{
+	TVersion ver ( KInetUriListServerMajorVersion, KInetUriListServerMinorVersion, KInetUriListServerBuildVersion );
+	if ( !User::QueryVersionSupported ( ver,aVersion ) )
+		{
+		User::Leave( KErrNotSupported );
+		}
+
+	CInetUriListServerSession* session = CInetUriListServerSession::NewL ();
+	IncSessionCount ();
+	
+	return session;
+	}
+
+CUriListInterface* CInetUriListServer::UriListInterface () const
+	{
+	return iUriListInterface;		
+	}
+// ----------------------------------------------------------------------
+
+CInetUriListSrvScheduler::CInetUriListSrvScheduler ()
+	{
+	}
+
+CInetUriListSrvScheduler::~CInetUriListSrvScheduler()
+	{
+	delete iInetUriListSrv;
+	}
+
+CInetUriListSrvScheduler* CInetUriListSrvScheduler::NewL ()
+	{
+	CInetUriListSrvScheduler* self = new ( ELeave ) CInetUriListSrvScheduler;
+	CActiveScheduler::Install ( self );
+	
+	// Create the inet urilist server
+	self->iInetUriListSrv = CInetUriListServer::NewL ();
+	
+	return self;	
+	}
+
+void CInetUriListSrvScheduler::Error ( TInt aError ) const
+	{	
+	if ( iInetUriListSrv )	
+		{
+		iInetUriListSrv->Error( aError );			
+		}
+	}
+	
+// ----------------------------------------------------------------------
+//
+// Thread top level
+// Perform all server initialisation, in particular creation of the
+// scheduler and server and then run the scheduler
+//
+
+static void RunServerL()
+	{
+	// create and install the active scheduler we need
+	CInetUriListSrvScheduler* s = CInetUriListSrvScheduler::NewL();
+	CleanupStack::PushL(s);
+
+	//
+	// naming the server thread after the server helps to debug panics
+	User::LeaveIfError ( RThread().RenameMe ( KInetUriListServerName() ) );
+
+	//
+	// Initialisation complete, now signal the client
+	RProcess::Rendezvous ( KErrNone );
+	//
+	// Ready to run
+	CActiveScheduler::Start ();
+	//
+	// Cleanup the scheduler
+	CleanupStack::PopAndDestroy ( s );
+	}
+
+// Inet URI server entrypoint
+GLDEF_C TInt E32Main()
+	{
+	__UHEAP_MARK;
+	//
+	CTrapCleanup* cleanup = CTrapCleanup::New ();
+	TInt r = KErrNoMemory;
+	if ( cleanup )
+		{
+		TRAP ( r, RunServerL () );
+		delete cleanup;
+		}
+	__UHEAP_MARKEND;
+	return r;
+	}
+