diff -r 000000000000 -r b16258d2340f applayerpluginsandutils/uripermissionservices/client/src/ineturilistsession.cpp --- /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 +#include "ineturilistsession.h" +#include "ineturilistserver.h" +#include "ineturiimpl.h" +#include "ineturiproperties.h" +#include "urilistreadstream.h" +#include + + +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, <Buffer ); + 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, <Buffer ); + + 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 ( 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 ( 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 ( 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 ); + }