--- /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;
+ }
+