--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/applayerpluginsandutils/uripermissionservices/client/src/ineturilistsession.cpp	Tue Feb 02 01:09:52 2010 +0200
@@ -0,0 +1,323 @@
+// 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 "ineturilistsession.h"
+#include "ineturilistserver.h"
+#include "ineturiimpl.h"
+#include "ineturiproperties.h"
+#include "urilistreadstream.h"
+#include <uri8.h>
+
+
+const TInt KNumConnectRetries = 5;
+
+_LIT( KServerCode, "INETURILISTSERVER" );
+
+RInetUriListSession::RInetUriListSession ()
+	{
+	
+	}
+	
+RInetUriListSession::~RInetUriListSession ()
+	{
+	Close ();
+	}
+
+/**
+Connects to the ineturilist server, attempting to start if necessary. 
+ */
+TInt RInetUriListSession::Connect ()
+	{
+	TInt retry = KNumConnectRetries;
+	TVersion version ( KInetUriListServerMajorVersion, 
+						KInetUriListServerMinorVersion, 
+						KInetUriListServerBuildVersion );
+	FOREVER
+		{
+		TInt err = CreateSession ( KInetUriListServerName, version );
+
+		if ( err != KErrNotFound && err != KErrServerTerminated )
+			{
+			return err;
+			}
+		// need to restart server
+		if ( --retry == 0 )
+			{
+			return err;
+			}
+		err = StartServer ();
+		if ( err != KErrNone && err != KErrAlreadyExists )
+			{
+			return err;
+			}
+		}
+	}
+	
+void RInetUriListSession::Close ()
+	{
+	if ( Handle() )
+		{
+		RSessionBase::Close ();
+		}
+	}
+
+
+TInt RInetUriListSession::StartServer ()
+	{
+	const TInt KIntServerType = 0x20009D70; 
+	const TUidType serverUid ( KNullUid, KNullUid, TUid::Uid( KIntServerType ) );
+	
+	TRequestStatus started ( KRequestPending );
+	TRendezvous rendezvous;
+	rendezvous.iId = RThread ().Id ();		// id of this thread
+	rendezvous.iStatus = &started;
+
+	RProcess server;
+	TInt err = server.Create( KServerCode,
+						TPtrC ( reinterpret_cast < TText* > ( &rendezvous ),
+						sizeof ( rendezvous ) / sizeof ( TText ) ), serverUid );
+
+	if ( err != KErrNone )
+		{
+		return err;
+		}
+
+	server.SetPriority ( EPriorityHigh );
+	
+	TRequestStatus stat;
+	server.Rendezvous ( stat );
+	if ( stat != KRequestPending )
+		{
+		server.Kill ( 0 );		// abort startup
+		}
+	else
+		{
+		server.Resume ();	// logon OK - start the server
+		}
+	User::WaitForRequest ( stat );		// wait for start or death
+	server.Close ();
+	return stat.Int ();
+	}
+
+/**
+Returns a buffer of size specified as argument.
+
+*/
+CBufFlat* RInetUriListSession::GetBufferLC ( TInt aSize )
+	{
+	CBufFlat* buffer = CBufFlat::NewL ( aSize );
+	CleanupStack::PushL ( buffer );
+	buffer->ExpandL ( 0, aSize );
+	return buffer;
+	}
+
+/**
+Sends the IPC data packet the server for adding into the storage. On return of
+the IPC call the URI Id & Property ID will be updated.
+
+@param aInetUri The URI object with its associated properties. The URI Id & property
+Id will be updated on this object on return of the IPC call.
+*/
+void RInetUriListSession::AddL ( CInetUriImpl& aInetUri )
+	{
+	TInt uriSize = aInetUri.Size ();
+	
+	CBufFlat* inBuffer = GetBufferLC ( uriSize );
+		
+	RBufWriteStream writeStream ( *inBuffer );
+	CleanupClosePushL ( writeStream );
+	
+	// Pack the data
+	aInetUri.PackL ( writeStream );
+	
+	TPtr8 ptr ( inBuffer->Ptr (0) );		
+	
+	TInt uriId = 0;
+	TInt propId = 0;
+	
+	TPckgBuf < TInt > uriIdBuffer ( uriId );
+	TPckgBuf < TInt > propIdBuffer ( propId );
+		
+	TIpcArgs args ( &ptr, &uriIdBuffer, &propIdBuffer );
+	const TInt result = SendReceive ( CInetUriListServer::EAddUri, args );
+	
+	User::LeaveIfError ( result );
+	
+	aInetUri.SetUriId ( uriIdBuffer() );
+	aInetUri.Properties().SetPropId ( propIdBuffer() );
+	
+	CleanupStack::PopAndDestroy ( 2 ); // writeStream, inBuffer	
+	}
+
+/**
+Sends the IPC data packet to the server for removing from the storage. 
+
+@param aInetUri The URI object with its associated properties that need to be 
+removed from the storage
+*/
+void RInetUriListSession::RemoveL ( const CInetUriImpl& aInetUri )
+	{
+	// Only URI Id & Properties ID need to be sent to the server which will issue a 
+	// DELETE statement based on the Properties ID to the DB storage
+	TPckg < TInt > uriIdBuffer ( aInetUri.UriId() );
+	TPckg < TInt > propIdBuffer ( aInetUri.Properties().PropId() );
+	TIpcArgs args ( &uriIdBuffer, &propIdBuffer );
+	
+	const TInt result = SendReceive ( CInetUriListServer::ERemoveUri, args );
+	User::LeaveIfError ( result );
+	}
+/**
+Sends the IPC data packet to the server for updating the storage. Only favouritename
+and listtype will be updated.
+
+@param aInetUri The URI object whose favouritename & listype that need updation
+*/
+void RInetUriListSession::UpdateL ( const CInetUriImpl& aInetUri )
+	{
+	// Only Favourite Name & List type can be updated. Sent the 
+	// IPC args with those values and the URI ID
+	TPckg < TUint32 > propIdBuffer ( aInetUri.Properties().PropId() );	
+	TPckg < InetUriList::TListType > listTypeBuffer ( aInetUri.Properties().ListType() );
+	
+	TIpcArgs args ( &propIdBuffer, &listTypeBuffer, &( aInetUri.Properties().FavouriteName() ) );
+	
+	const TInt result = SendReceive ( CInetUriListServer::EUpdateUri, args );
+	User::LeaveIfError ( result );
+	}
+
+/**
+Counts the number of URIs present in the list for a given servicetype & listtype. The data will 
+be packaged and send to the server. The count value will be returned as a return value to 
+the SendReceive fn
+*/
+TInt RInetUriListSession::Count ( InetUriList::TServiceType aServiceType, InetUriList::TListType aListType )
+	{
+	TPckg < InetUriList::TServiceType > stBuffer ( aServiceType );
+	TPckg < InetUriList::TListType > ltBuffer ( aListType );
+	
+	TIpcArgs args ( &stBuffer, &ltBuffer );
+	return SendReceive ( CInetUriListServer::EUriCount, args );
+	}
+
+/**
+Get the listtype for a URI, given a servicetype
+*/
+TInt RInetUriListSession::GetListTypeL ( const TDesC8& aUri, InetUriList::TServiceType aServiceType, InetUriList::TListType& aListType )
+	{	
+//	InetUriList::TListType lt;
+	
+	TPckg < InetUriList::TServiceType > stBuffer ( aServiceType );
+	TPckgBuf < InetUriList::TListType > ltBuffer;// ( lt );
+	
+	TIpcArgs args ( &aUri, &stBuffer, &ltBuffer );
+	
+	const TInt result = SendReceive ( CInetUriListServer::EListType, args );
+	if ( result != KErrNone )
+		{
+		User::Leave ( result );			
+		}
+
+	aListType = ltBuffer();
+	
+	return result;
+	}
+
+/**
+Queries the URI in the list by providing query arguments. The server will setup a stream
+and the handle will be returned as a return value for SendReceive fn. Using that handle
+client can stream the query result.
+*/
+CUriListReadStream* RInetUriListSession::QueryUriL ( const TQueryArgs& aArgs )
+	{
+	TPckg < TQueryArgs > queryArgs ( aArgs );	
+	TIpcArgs args ( &queryArgs );
+	const TInt result = SendReceive ( CInetUriListServer::EQuery, args );
+	User::LeaveIfError ( result );
+	
+	return CUriListReadStream::NewL( *this, result );
+	}
+	
+/**
+Queries the URI in the list by providing query arguments. The server will return 
+the policydata by writing it back into IpcArgs. And return value for SendReceive 
+fn contains the length of the aCharset filled by server.
+aArgs contains Query args and aCharSet is an out parameter.
+*/
+TInt RInetUriListSession::QueryTldInfo ( const TPolicyQueryArgs& aArgs, TPtr8& aCharSet )
+	{
+	const TDesC8& inputUri = *(reinterpret_cast<TDesC8*> ( aArgs.Get ( TPolicyQueryArgs::ETldUri ) ));
+	TPckg < TPolicyQueryArgs > queryArgs ( aArgs );	
+	TIpcArgs args ( &inputUri, &queryArgs, &aCharSet );
+	return SendReceive ( CInetUriListServer::EQueryTldInfo, args );
+	}
+
+/**
+Fetch the length of Policy data
+*/
+TInt RInetUriListSession::PolicyDataLength ( const TPolicyQueryArgs& aArgs )
+	{
+	const TDesC8& inputUri = *(reinterpret_cast<TDesC8*> ( aArgs.Get ( TPolicyQueryArgs::ETldUri ) ));
+	TPckg < TPolicyQueryArgs > queryArgs ( aArgs );	
+	TIpcArgs args (&inputUri, &queryArgs );
+	return SendReceive ( CInetUriListServer::EPolicyLength, args );	
+	}
+	
+/**
+Identifies whether the given Uri is BlackListed or Whitelisted
+*/
+TInt RInetUriListSession::GetHostType ( const TPolicyQueryArgs& aArgs )
+	{
+	const TDesC8& inputUri = *(reinterpret_cast<TDesC8*> ( aArgs.Get ( TPolicyQueryArgs::ETldUri ) ));
+	TIpcArgs args (&inputUri);	
+	TInt err = SendReceive ( CInetUriListServer::ETldListType, args );
+	return err;
+	}
+
+/**
+Queries the URI in the list by providing query arguments and a URI. The server will setup 
+a stream and the handle will be returned as a return value for SendReceive fn. Using that 
+handle, client can stream the query result.
+*/
+CUriListReadStream* RInetUriListSession::QueryUriL ( const TDesC8& aUri, const TQueryArgs& aArgs )
+	{
+	TPckg < TQueryArgs > queryArgs ( aArgs );	
+	TIpcArgs args ( &aUri, &queryArgs );
+	const TInt result = SendReceive ( CInetUriListServer::EQueryWithUri, args );
+	User::LeaveIfError ( result );
+	
+	return CUriListReadStream::NewL( *this, result );
+	}
+
+/**
+The query results stream has been setup in the server and the server stream handle is 
+returned via QueryUriL call. Read the query results using that handle. 
+*/		
+TInt RInetUriListSession::ReadQueryResults ( TInt aHandle, TPtr8& aPtr )
+	{
+	TIpcArgs args ( aHandle, &aPtr );
+	
+	return SendReceive ( CInetUriListServer::EReadQueryResults, args );
+	}
+	
+/**
+Close the server stream handle.
+*/
+void RInetUriListSession::CloseSrvStream ( TInt aHandle )
+	{
+	TIpcArgs args ( aHandle );
+	
+	SendReceive ( CInetUriListServer::ECloseSrvStream, args );		
+	}