--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/applayerpluginsandutils/uripermissionservices/server/src/urilistinterface.cpp Tue Feb 02 01:09:52 2010 +0200
@@ -0,0 +1,1291 @@
+// 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:
+//
+
+#include <ineturilistdef.h>
+#include <tldlistdef.h>
+#include "urilistinterface.h"
+#include "sqldbaccessor.h"
+#include "ineturiimpl.h"
+#include "urilistwritestream.h"
+#include "urilist.h"
+#include "urilistinitializer.h"
+#include "tldlistinitializer.h"
+#include "uriqueryfilter.h"
+#include "tldproperties.h"
+#include <delimitedpath8.h>
+#include "tldlist.h"
+#include <swi/sisregistrysession.h>
+#include <swi/sisregistryentry.h>
+#include <bautils.h>
+#include <uriutils.h>
+
+const TInt KMaxLength = 1024;
+const TInt pkgId(0x2000A471);
+_LIT(KRomDirectory, "z");
+_LIT(KUriListFile, ":\\private\\20009D70\\ineturilist.xml");
+#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
+_LIT(KPolicyFile, ":\\private\\20009D70\\tldpolicy.xml");
+#endif //SYMBIAN_ENABLE_SPLIT_HEADERS
+
+CUriListInterface::CUriListInterface ()
+ {
+
+ }
+
+CUriListInterface::~CUriListInterface ()
+ {
+ if ( iDbAccessor )
+ {
+ iDbAccessor->Release ();
+ }
+ iStringPool.Close ();
+ }
+
+CUriListInterface* CUriListInterface::NewL ()
+ {
+ CUriListInterface* self = new ( ELeave ) CUriListInterface ();
+ CleanupStack::PushL ( self );
+ self->ConstructL ();
+ CleanupStack::Pop ( self );
+
+ return self;
+ }
+
+
+void CUriListInterface::ConstructL ()
+ {
+ iStringPool.OpenL ( URILIST::Table );
+ iStringPool.OpenL ( TLDLIST::Table );
+ iDbAccessor = CSqlDbAccessor::NewL ( iStringPool );
+ InitializeDatabaseL ();
+ }
+
+/**
+Add a new URI and its associated properties into the storage.
+
+@param aUriStream A stream to read the CInetUriImpl object.
+@param aUriId URI Id value that will be returned to the caller
+@param aPropId Property Id value that will be returned to the caller
+
+*/
+void CUriListInterface::AddUriL ( RReadStream& aUriStream, TInt& aUriId, TInt& aPropId )
+ {
+ CInetUriImpl* inetUri = CInetUriImpl::NewL ();
+ CleanupStack::PushL ( inetUri );
+ inetUri->UnpackL ( aUriStream );
+ InsertL ( *inetUri );
+ aUriId = inetUri->UriId ();
+ aPropId = inetUri->Properties().PropId ();
+ CleanupStack::PopAndDestroy ( inetUri );
+ }
+
+/**
+Removes the properties from the URIPropertiesTbl. The function removes the URI from the
+URITbl table if it is not having a dependency. See the table structure
+
+@param aUriId URI Id value
+@param aPropId Property Id value
+*/
+void CUriListInterface::RemoveUriL ( TInt aUriId, TInt aPropId )
+ {
+ iDbAccessor->BeginTransactionL ();
+ // This is not to delete the object rather to do a rollback operation incase of a failure
+ CleanupStack::PushL ( TCleanupItem ( CUriListInterface::RollbackTrans, iDbAccessor ) );
+
+ // Delete from properties table
+ DeleteL ( KUriPropsTblName(), URILIST::EPropId, aPropId );
+
+ // The URI also need to be removed if it is not marked for another service type.
+ // Check for dependency.
+ if ( CheckDependencyL( aUriId ) )
+ {
+ // No dependency. The URI also need to be removed
+ DeleteL ( KUriTblName(), URILIST::EId, aUriId );
+ }
+
+ // Delete the same from view
+ DeleteL ( KViewName(), URILIST::EPropId, aPropId );
+ iDbAccessor->CommitTransactionL ();
+ CleanupStack::Pop (); // iDbAccessor
+ }
+
+/**
+Updates the listtype and favouritename. Only, these 2 properties can be modified.
+
+@param aUriPropsId Property ID which uniquely identifies the row in the URIPropertiesTbl
+@param aListType New Listtype
+@param aFavouriteName New favourite name for the URI
+*/
+void CUriListInterface::UpdateUriL ( TInt aUriPropsId, InetUriList::TListType aListType, const TDesC8& aFavouriteName )
+ {
+ iDbAccessor->BeginTransactionL ();
+ // This is not to delete the object rather to do a rollback operation incase of a failure
+ CleanupStack::PushL ( TCleanupItem ( CUriListInterface::RollbackTrans, iDbAccessor ) );
+
+ // Only update List Type & Favourite Name. Other properties are not allowed to update.
+ if ( UpdateL ( KUriPropsTblName(), aUriPropsId, aListType, aFavouriteName ) == 0 )
+ User::Leave ( InetUriList::KErrUriNotFound );
+
+ User::LeaveIfError ( UpdateL ( KViewName(), aUriPropsId, aListType, aFavouriteName ) );
+
+ iDbAccessor->CommitTransactionL ();
+ CleanupStack::Pop (); // iDbAccessor
+ }
+
+/**
+Inserts the information into URITbl, URIPropertiesTbl & the URI view. Checks whether
+the URI is already present in the storage and applies the blacklist/whitelist rule
+before insertion.
+
+@param aInetUri URI information object. On return the new property id and URI id will be set.
+*/
+void CUriListInterface::InsertL ( CInetUriImpl& aInetUri )
+ {
+ TInt result = KErrNone;
+ const TUriC8& uri ( aInetUri.Uri().Uri() );
+ MDBTransaction* dbTrans = DoSearchExactUriLC ( uri, aInetUri.Properties().ServiceType() );
+ if ( dbTrans->Next() )
+ {
+ // URI already exists for the requested service type.
+ result = InetUriList::KErrUriAlreadyExists;
+ }
+ User::LeaveIfError ( result );
+ CleanupStack::PopAndDestroy (); // dbTrans
+
+ // Now the URI can be added.
+ iDbAccessor->BeginTransactionL ();
+ // This is not to delete the object rather to do a rollback operation incase of a failure
+ CleanupStack::PushL ( TCleanupItem ( CUriListInterface::RollbackTrans, iDbAccessor ) );
+
+ TInt uriId = 0;
+ if ( InsertIntoUriTblL ( aInetUri.Uri().Uri(), uriId ) == 0 )
+ User::Leave ( InetUriList::KErrUriAddFailed );
+
+ aInetUri.SetUriId ( uriId );
+
+ // Now add the properties
+ TInt propId = 0;
+ if ( InsertIntoUriPropsTblL ( aInetUri.UriId(), aInetUri.Properties(), propId ) == 0 )
+ User::Leave ( InetUriList::KErrUriAddFailed );
+ aInetUri.Properties().SetPropId( propId );
+ User::LeaveIfError ( InsertIntoViewL ( aInetUri ) );
+ iDbAccessor->CommitTransactionL ();
+ CleanupStack::Pop (); // iDbAccessor
+ }
+
+/**
+Inserts the information into TLDTbl. Checks whether
+the URI is already present in the storage and applies the blacklist/whitelist rule
+before insertion.
+
+@param aTldPolicydata Tld information object.
+*/
+void CUriListInterface::InsertTldPolicyDataL ( CTldProperties& aTldPolicydata )
+ {
+ //First check whether such row is available
+ //if yes dont insert.
+ // Now the TLD Policy data can be added.
+ iDbAccessor->BeginTransactionL ();
+ // This is not to delete the object rather to do a rollback operation incase of a failure
+ CleanupStack::PushL ( TCleanupItem ( CUriListInterface::RollbackTrans, iDbAccessor ) );
+ //Inserts unique row
+ if( !IsDuplicateEntryL( aTldPolicydata ) )
+ {
+ InsertIntoTldTblL ( aTldPolicydata );
+ }
+
+ iDbAccessor->CommitTransactionL ();
+ CleanupStack::Pop (); // iDbAccessor
+ }
+
+/**
+Inserts the data into the URITbl.
+
+@param aUri URI object
+@param [out] aUriId The URI will be filled upon successful insertion. This ID
+ uniquelly indentifies the URI.
+
+@return Returns the number of rows inserted. Normally 1. Otherwise returns with
+ system-wide error code.
+*/
+TInt CUriListInterface::InsertIntoUriTblL ( const TUriC8& aUri, TInt& aUriId )
+ {
+ const TDesC8& id ( iStringPool.String (URILIST::EId,URILIST::Table).DesC() );
+ aUriId = GetMaxIdValueL ( KUriTblName(), id ) + 1;
+ _LIT8 ( KUriTblInsertStmt, "INSERT INTO %S VALUES (:V1, :V2, :V3, :V4, :V5, :V6, :V7, :V8)" );
+
+ RBuf8 sqlStmt;
+ sqlStmt.CreateL ( KMaxDbStmtLen );
+ CleanupClosePushL ( sqlStmt );
+ sqlStmt.Format ( KUriTblInsertStmt(), &(KUriTblName()) );
+ MDBTransaction* dbTrans = iDbAccessor->PrepareTransactionL ( sqlStmt );
+ CleanupStack::PopAndDestroy (); // sqlStmt
+ CleanupStack::PushL ( TCleanupItem ( CUriListInterface::DestroyTransObj, dbTrans ) );
+ // We are having 8 parameters for this query. First bind the query with parameter position 0
+ // and so on
+ dbTrans->BindIntL ( URILIST::EId, aUriId );
+ dbTrans->BindTextL ( URILIST::EScheme, aUri.IsPresent(EUriScheme) ? aUri.Extract ( EUriScheme ) : KNullDesC8() );
+ dbTrans->BindTextL ( URILIST::EUserInfo, aUri.IsPresent(EUriUserinfo) ? aUri.Extract ( EUriUserinfo ) : KNullDesC8() );
+ dbTrans->BindTextL ( URILIST::EHost, aUri.IsPresent(EUriHost) ? aUri.Extract ( EUriHost ) : KNullDesC8() );
+ dbTrans->BindTextL ( URILIST::EPort, aUri.IsPresent(EUriPort) ? aUri.Extract ( EUriPort ) : KNullDesC8() );
+ dbTrans->BindTextL ( URILIST::EPath, aUri.IsPresent(EUriPath) ? aUri.Extract ( EUriPath ) : KNullDesC8() );
+ dbTrans->BindTextL ( URILIST::EQuery, aUri.IsPresent(EUriQuery) ? aUri.Extract ( EUriQuery ) : KNullDesC8() );
+ dbTrans->BindTextL ( URILIST::EFragments, aUri.IsPresent(EUriFragment) ? aUri.Extract ( EUriFragment ) : KNullDesC8() );
+
+ TInt result = dbTrans->ExecuteL ();
+ CleanupStack::PopAndDestroy (); //dbTrans
+ return result;
+ }
+
+/**
+Inserts the data into the TLDTbl.
+
+@return Returns the number of rows inserted. Normally 1. Otherwise returns with
+ system-wide error code.
+*/
+TInt CUriListInterface::InsertIntoTldTblL ( const CTldProperties& aTldProps )
+ {
+ _LIT8 ( KTldTblInsertStmt, "INSERT INTO %S VALUES ( :V1, :V2, :V3 )" );
+ RBuf8 sqlStmt;
+ sqlStmt.CreateL ( KMaxDbStmtLen );
+ CleanupClosePushL ( sqlStmt );
+ sqlStmt.Format ( KTldTblInsertStmt(), &(KTldTblName()) );
+ MDBTransaction* dbTrans = iDbAccessor->PrepareTransactionL ( sqlStmt );
+ CleanupStack::PushL ( TCleanupItem ( CUriListInterface::DestroyTransObj, dbTrans ) );
+ dbTrans->BindTextL ( TLDLIST::ETLDName, aTldProps.TldName() );
+ TInt lt = static_cast<TInt> ( aTldProps.ListType() ) ;
+ dbTrans->BindIntL ( TLDLIST::EListType, lt );
+ dbTrans->BindTextL ( TLDLIST::ECharacterSet, aTldProps.CharacterSet() );
+ TInt result = dbTrans->ExecuteL ();
+ CleanupStack::PopAndDestroy (2); // sqlStmt, dbTrans
+ return result;
+ }
+
+/**
+Checks whether the duplicate entry in the TLDTbl.
+
+@return ETrue if already such row exist else retrns EFalse
+*/
+TBool CUriListInterface::IsDuplicateEntryL ( const CTldProperties& aTldProps )
+ {
+ _LIT8 ( KTldTblSearchStmt, "SELECT * FROM %S WHERE %S=:V1 and %S=:V2" );
+ const TDesC8& KTldName (iStringPool.String (TLDLIST::ETLDName,TLDLIST::Table).DesC());
+ const TDesC8& KTldListType (iStringPool.String (TLDLIST::EListType,TLDLIST::Table).DesC());
+ RBuf8 sqlStmt;
+ sqlStmt.CreateL ( KMaxDbStmtLen );
+ CleanupClosePushL ( sqlStmt );
+ sqlStmt.Format ( KTldTblSearchStmt(), &(KTldTblName()), &KTldName, &KTldListType );
+ MDBTransaction* dbTrans = iDbAccessor->PrepareTransactionL ( sqlStmt );
+ CleanupStack::PushL ( TCleanupItem ( CUriListInterface::DestroyTransObj, dbTrans ) );
+ dbTrans->BindTextL ( TLDLIST::ETLDName, aTldProps.TldName() );
+ TInt lt = static_cast<TInt> ( aTldProps.ListType() ) ;
+ dbTrans->BindIntL ( TLDLIST::EListType, lt );
+ TBool result( dbTrans->Next () );
+ CleanupStack::PopAndDestroy (2); // sqlStmt, dbTrans
+ return result;
+ }
+
+/**
+Inserts the data into the URIPropertiesTbl.
+
+@param aUri URI object
+@param [out] aUriId The URI will be filled upon successful insertion. This ID
+ uniquelly indentifies the URI.
+
+@return Returns the number of rows inserted. Normally 1. Otherwise returns with
+ system-wide error code.
+*/
+TInt CUriListInterface::InsertIntoUriPropsTblL ( TInt aUriId, const CInetUriProperties& aUriProps, TInt& aPropId )
+ {
+ const TInt KMaxLen = 128;
+ const TDesC8& propId ( iStringPool.String (URILIST::EPropId,URILIST::Table).DesC() );
+ aPropId = GetMaxIdValueL ( KUriPropsTblName(), propId ) + 1;
+ _LIT8 ( KInsertStmt, "INSERT INTO %S VALUES (%d, %d, %d, %d, %d, :V1)");
+ RBuf8 queryBuf;
+ CleanupClosePushL (queryBuf);
+ queryBuf.CreateL ( KMaxLen );
+ queryBuf.AppendFormat ( KInsertStmt, &(KUriPropsTblName()), aUriId, aPropId, aUriProps.ServiceType(), aUriProps.ListType(), aUriProps.Permission() );
+ MDBTransaction* dbTrans = iDbAccessor->PrepareTransactionL ( queryBuf );
+ CleanupStack::PushL ( TCleanupItem ( CUriListInterface::DestroyTransObj, dbTrans ) );
+ dbTrans->BindTextL ( 0, aUriProps.FavouriteName () ); // Bind with parameter index 0
+ TInt result = dbTrans->ExecuteL ();
+ CleanupStack::PopAndDestroy (2); // queryBuf, dbTrans
+
+ return result;
+ }
+
+/**
+Insert the data into the view. The view insertion will happen via a trigger.
+The SQLite views are read-only and cannot do any INSERT/DELETE/UPDATE operation directly.
+
+@param aInetUri The URI information
+
+@return KErrNone for success else return any of the system wide error code.
+
+Note: The view insertion execution will not give the number of rows actualy
+inserted. It returns KErrNone
+*/
+TInt CUriListInterface::InsertIntoViewL ( const CInetUriImpl& aInetUri )
+ {
+ _LIT8 ( KUriViewInsertStmt, "INSERT INTO %S \
+ VALUES (:V1, :V2, :V3, :V4, :V5, :V6, :V7, :V8, \
+ :V9, :V10, :V11, :V12, :V13)" );
+
+ RBuf8 sqlStmt;
+ sqlStmt.CreateL ( KMaxDbStmtLen );
+ CleanupClosePushL ( sqlStmt );
+ sqlStmt.Format ( KUriViewInsertStmt(), &(KViewName()));
+ MDBTransaction* dbTrans = iDbAccessor->PrepareTransactionL ( sqlStmt );
+ CleanupStack::PopAndDestroy (); //sqlStmt
+ CleanupStack::PushL ( TCleanupItem ( CUriListInterface::DestroyTransObj, dbTrans ) );
+ // We are having 8 parameters for this query. First bind the query with parameter position 0
+ // and so on
+ dbTrans->BindIntL ( URILIST::EId, aInetUri.UriId() );
+ TUriC8 uri ( aInetUri.Uri().Uri() );
+ dbTrans->BindTextL ( URILIST::EScheme, uri.IsPresent(EUriScheme) ? uri.Extract ( EUriScheme ) : KNullDesC8() );
+ dbTrans->BindTextL ( URILIST::EUserInfo, uri.IsPresent(EUriUserinfo) ? uri.Extract ( EUriUserinfo ) : KNullDesC8() );
+ dbTrans->BindTextL ( URILIST::EHost, uri.IsPresent(EUriHost) ? uri.Extract ( EUriHost ) : KNullDesC8() );
+ dbTrans->BindTextL ( URILIST::EPort, uri.IsPresent(EUriPort) ? uri.Extract ( EUriPort ) : KNullDesC8() );
+ dbTrans->BindTextL ( URILIST::EPath, uri.IsPresent(EUriPath) ? uri.Extract ( EUriPath ) : KNullDesC8() );
+ dbTrans->BindTextL ( URILIST::EQuery, uri.IsPresent(EUriQuery) ? uri.Extract ( EUriQuery ) : KNullDesC8() );
+ dbTrans->BindTextL ( URILIST::EFragments, uri.IsPresent(EUriFragment) ? uri.Extract ( EUriFragment ) : KNullDesC8() );
+
+ CInetUriProperties& properties = aInetUri.Properties ();
+ dbTrans->BindIntL ( URILIST::EPropId - 1, properties.PropId() );
+ dbTrans->BindIntL ( URILIST::EServiceType - 1, properties.ServiceType() );
+ dbTrans->BindIntL ( URILIST::EListType - 1, properties.ListType() );
+ dbTrans->BindIntL ( URILIST::EPermission - 1, properties.Permission() );
+ dbTrans->BindTextL ( URILIST::EFavouriteName-1, properties.FavouriteName() );
+
+ TInt result = dbTrans->ExecuteL ();
+ CleanupStack::PopAndDestroy (); //dbTrans
+ return result;
+ }
+
+
+/**
+Updates the URI properties
+
+@param aSchemaName Schema name - Could be table or view name
+@param aPropId Property ID
+@param aListType new List type
+@param aFavouritename new favourite name.
+*/
+TInt CUriListInterface::UpdateL ( const TDesC8& aSchemaName, TInt aPropId, InetUriList::TListType aListType, const TDesC8& aFavouriteName )
+ {
+ const TDesC8& propId ( iStringPool.String (URILIST::EPropId,URILIST::Table).DesC() );
+ const TDesC8& listType (iStringPool.String (URILIST::EListType,URILIST::Table).DesC());
+ const TDesC8& favouriteName (iStringPool.String (URILIST::EFavouriteName,URILIST::Table).DesC());
+
+ // Only update List Type & Favourite Name. Other properties are not allowed to update.
+ _LIT8 ( KUpdateStmt, "UPDATE %S SET %S=%d, %S=:V1 where %S=%d" );
+ const TInt KMaxLen = 128;
+ RBuf8 queryBuf;
+ CleanupClosePushL ( queryBuf );
+ queryBuf.CreateL ( KMaxLen );
+ queryBuf.AppendFormat ( KUpdateStmt(), &aSchemaName, &listType, aListType, &favouriteName, &propId, aPropId );
+
+ MDBTransaction* dbTrans = iDbAccessor->PrepareTransactionL ( queryBuf );
+ CleanupStack::PushL ( TCleanupItem ( CUriListInterface::DestroyTransObj, dbTrans ) );
+ dbTrans->BindTextL ( 0, aFavouriteName );
+ TInt result = dbTrans->ExecuteL ();
+ CleanupStack::PopAndDestroy (2); // dbTrans, queryBuf
+ return result;
+ }
+
+/**
+Counts the number of URIs present in the storage for a given service type & list type
+*/
+TInt CUriListInterface::CountUriL ( InetUriList::TServiceType aServiceType, InetUriList::TListType aListType )
+ {
+
+ TQueryArgs args ( aServiceType, aListType );
+ CUriQueryFilter* queryFilter = QueryL ( args );
+ CleanupStack::PushL ( queryFilter );
+ TInt count = queryFilter->MatchRecordCountL();
+ CleanupStack::PopAndDestroy (); // queryFilter
+ return count;
+ }
+
+/**
+Returns the List type associated with the URI and a servicetype
+*/
+InetUriList::TListType CUriListInterface::GetListTypeL ( const TDesC8& aUri, InetUriList::TServiceType aSt )
+ {
+ TUriParser8 uriParser;
+ User::LeaveIfError ( uriParser.Parse ( aUri ) );
+
+ MDBTransaction* dbTrans = DoSearchExactUriLC ( uriParser, aSt );
+
+ if ( !dbTrans->Next() )
+ {
+ User::LeaveIfError ( InetUriList::KErrUriNotFound );
+ }
+ InetUriList::TListType lt = static_cast < InetUriList::TListType > ( dbTrans->ColumnIntL ( URILIST::EListType - 1 ) );
+ CleanupStack::PopAndDestroy (); // dbTrans
+ return lt;
+ }
+
+/**
+Delete the information from the given schema
+
+@param aSchemaName Table or view name
+@param aFieldPos The actual string index in the string table
+@param aid ID
+
+@return
+*/
+void CUriListInterface::DeleteL ( const TDesC8& aSchemaName, TInt aFieldPos, TInt aId )
+ {
+ const TInt KMaxLen = 64;
+ _LIT8 ( KDeleteStmt, "DELETE FROM %S where %S=%d" );
+
+ const TDesC8& fieldName ( iStringPool.String (aFieldPos,URILIST::Table).DesC() );
+
+ RBuf8 queryBuf;
+ CleanupClosePushL ( queryBuf );
+ queryBuf.CreateL ( KMaxLen );
+ queryBuf.AppendFormat ( KDeleteStmt(), &aSchemaName, &fieldName, aId );
+
+ MDBTransaction* dbTrans = iDbAccessor->PrepareTransactionL ( queryBuf );
+ CleanupStack::PushL ( TCleanupItem ( CUriListInterface::DestroyTransObj, dbTrans ) );
+ dbTrans->ExecuteL ();
+ CleanupStack::PopAndDestroy ( 2 ); // queryBuf, dbTrans
+ }
+
+/**
+The URI can be added for different servicetypes. Check if it is exist in the table.
+
+*/
+TBool CUriListInterface::CheckDependencyL ( TInt aId )
+ {
+ const TDesC8& id ( iStringPool.String (URILIST::EId,URILIST::Table).DesC() );
+ const TInt KMaxLen = 64;
+ _LIT8 ( KQueryStmt, "SELECT * FROM %S where %S=%d" );
+ RBuf8 queryBuf;
+ CleanupClosePushL ( queryBuf );
+ queryBuf.CreateL ( KMaxLen );
+ queryBuf.AppendFormat ( KQueryStmt(), &(KUriTblName()), &id, aId );
+ MDBTransaction* dbTrans = iDbAccessor->PrepareTransactionL ( queryBuf );
+ CleanupStack::PushL ( TCleanupItem ( CUriListInterface::DestroyTransObj, dbTrans ) );
+ TBool result = dbTrans->Next();
+ CleanupStack::PopAndDestroy (2); // queryBuf, dbTrans
+ return result;
+ }
+
+
+/**
+Get the Maximum Id value from the table.
+
+*/
+TInt CUriListInterface::GetMaxIdValueL ( const TDesC8& aTblName, const TDesC8& aFieldName )
+ {
+ const TInt KMaxLen = 64;
+ _LIT8 ( KMaxValueQuery, "SELECT MAX(%S) from %S" );
+ RBuf8 queryBuf;
+ CleanupClosePushL ( queryBuf );
+ queryBuf.CreateL ( KMaxLen );
+ queryBuf.AppendFormat ( KMaxValueQuery, &aFieldName, &aTblName );
+ TInt result = iDbAccessor->ExecuteScalarQueryL ( queryBuf );
+ CleanupStack::PopAndDestroy (); //queryBuf
+ return result;
+ }
+
+/**
+Destroys the transaction object
+*/
+void CUriListInterface::DestroyTransObj ( TAny* aPtr )
+ {
+ MDBTransaction* trans = (MDBTransaction*)aPtr;
+ trans->Release();
+ }
+/**
+Rollback the transaction when a leave happens in insert/delete/update operation
+*/
+void CUriListInterface::RollbackTrans ( TAny* aPtr )
+ {
+ MDBAccessor* accessor = (MDBAccessor*)aPtr;
+ accessor->RollbackTransaction();
+ }
+
+/**
+Query for the URI based on service type and listtype. The servicetype and listtype
+will be extracted from aQueryArgs
+*/
+CUriQueryFilter* CUriListInterface::QueryL ( const TQueryArgs& aQueryArgs )
+ {
+ const TDesC8& serviceType (iStringPool.String (URILIST::EServiceType,URILIST::Table).DesC());
+ const TDesC8& listType (iStringPool.String (URILIST::EListType,URILIST::Table).DesC());
+
+ RBuf8 queryBuf;
+ InitViewQueryLC (queryBuf);
+
+ TInt st = aQueryArgs.Get ( TQueryArgs::EServiceType );
+ TInt lt = aQueryArgs.Get ( TQueryArgs::EListType );
+
+ if ( lt == KErrNotFound )
+ {
+ _LIT8 (KFmtStr, "%S=%d" );
+ queryBuf.AppendFormat ( KFmtStr, &serviceType, st );
+
+ }
+ else
+ {
+ _LIT8 (KFmtStr, "%S=%d and %S=%d" );
+ queryBuf.AppendFormat ( KFmtStr, &serviceType, st, &listType, lt );
+ }
+
+
+ // Execute the query
+ MDBTransaction* dbTrans = iDbAccessor->PrepareTransactionL ( queryBuf );
+ CleanupStack::PopAndDestroy (); //queryBuf
+ CleanupStack::PushL ( TCleanupItem ( CUriListInterface::DestroyTransObj, dbTrans ) );
+ CUriQueryFilter* queryFilter = CUriQueryFilter::NewL ( dbTrans );
+ CleanupStack::Pop (); // dbTrans
+
+ return queryFilter; // return the queryFilter
+ }
+
+/**
+Fetches the length of the policy data if exists.
+*/
+TInt CUriListInterface::PolicyDataLengthL ( const TDesC8& aUri, const TPolicyQueryArgs& aQueryArgs )
+ {
+ CUriQueryFilter* queryFilter = QueryWithTldL ( aUri, aQueryArgs );
+ CleanupStack::PushL(queryFilter);
+ MDBTransaction& dbTrans = queryFilter->DBTransaction();
+ TInt resultsLength(0);
+ if ( dbTrans.Next() && queryFilter->MatchRecordL() )
+ {
+ resultsLength = dbTrans.ColumnTextL ( TLDLIST::ECharacterSet ).Length();
+ }
+ else
+ {
+ //Requested Policydata Not available for this TLD
+ CleanupStack::PopAndDestroy(queryFilter);
+ User::Leave(InetUriList::KErrInvalidTLD);
+ }
+ CleanupStack::PopAndDestroy(queryFilter);
+ return resultsLength;
+ }
+
+/**
+Fetches the host type of given uri.
+*/
+InetUriList::TListType CUriListInterface::GetHostTypeL (const TDesC8& aUri )
+ {
+ TBool blackListed( EFalse );
+ TInt err(KErrNone);
+ TRAP(err, blackListed = IsBlackListedUriL(aUri) );
+ if( err == InetUriList::KErrInvalidTLD )
+ {
+ //No Blacklisted policy data avaialble
+ TBool whiteListed( EFalse );
+ whiteListed = IsWhiteListedUriL(aUri);
+ blackListed = whiteListed? EFalse : ETrue;
+ }
+ //Bundle output Args with "blackListed" flag
+ return blackListed ? InetUriList::EBlackList : InetUriList::EWhiteList ;
+ }
+
+HBufC8* CUriListInterface::QueryTldInfoL(const TDesC8& aUri, const TPolicyQueryArgs& aQueryArgs )
+ {
+ HBufC8* charSet(NULL);
+ CUriQueryFilter* queryFilter = QueryWithTldL ( aUri, aQueryArgs );
+ CleanupStack::PushL(queryFilter);
+ MDBTransaction& dbTrans = queryFilter->DBTransaction();
+ if ( dbTrans.Next() && queryFilter->MatchRecordL() )
+ {
+ charSet = dbTrans.ColumnTextL ( TLDLIST::ECharacterSet ).AllocL();
+ }
+ else
+ {
+ //Requested Policydata Not available for this TLD
+ CleanupStack::PopAndDestroy(queryFilter);
+ User::Leave(InetUriList::KErrInvalidTLD);
+ }
+ CleanupStack::PopAndDestroy(queryFilter);
+ return charSet;
+ }
+
+/**
+Query for the Tld based on listtype. The listtype will be extracted from aQueryArgs
+*/
+CUriQueryFilter* CUriListInterface::QueryWithTldL (const TDesC8& aUri, const TPolicyQueryArgs& aQueryArgs )
+ {
+ //Etract Tld
+ HBufC8* tld = ExtractTldL(aUri);
+ CleanupStack::PushL(tld);
+ //execute Query Tld
+ CUriQueryFilter* queryFilter = DoQueryWithTldL ( tld->Des(), aQueryArgs );
+ CleanupStack::PopAndDestroy(); //tld
+ return queryFilter;
+ }
+
+/**
+Query for the Tld based on listtype. The listtype will be extracted from aQueryArgs
+*/
+CUriQueryFilter* CUriListInterface::DoQueryWithTldL ( const TDesC8& aUri, const TPolicyQueryArgs& aQueryArgs )
+ {
+ InetUriList::TTLDQueryType matchType(InetUriList::EPolicyListType);
+ #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
+ if ( aQueryArgs.Get ( TPolicyQueryArgs::ETldQueryType ) != KErrNotFound)
+ {
+ matchType = static_cast < InetUriList::TTLDQueryType > ( aQueryArgs.Get ( TPolicyQueryArgs::ETldQueryType ) );
+ }
+ #else
+ if ( aQueryArgs.IsSet ( TPolicyQueryArgs::ETldQueryType ) )
+ {
+ matchType = static_cast < InetUriList::TTLDQueryType > ( aQueryArgs.Get ( TPolicyQueryArgs::ETldQueryType ) );
+ }
+ #endif //SYMBIAN_ENABLE_SPLIT_HEADERS
+ __ASSERT_ALWAYS( ( matchType == InetUriList::EPolicyListType || matchType == InetUriList::EPolicyCharSet ), User::Invariant() );
+
+ const TDesC8& tldName (iStringPool.String (TLDLIST::ETLDName,TLDLIST::Table).DesC());
+ const TDesC8& listType (iStringPool.String (TLDLIST::EListType,TLDLIST::Table).DesC());
+
+ RBuf8 queryBuf;
+ InitTldQueryLC (queryBuf);
+ //Do not change the order of this query. Index is created on tldname and list type
+ _LIT8(KSql, "( %S=:V1 and %S=:V2 ) or ( %S=:V3 and %S=:V2 )" );
+ queryBuf.AppendFormat( KSql, &tldName, &listType, &tldName, &listType );
+
+ //Prepare the query
+ MDBTransaction* dbTrans = iDbAccessor->PrepareTransactionL ( queryBuf );
+ CleanupStack::PopAndDestroy (); //queryBuf
+ CleanupStack::PushL ( TCleanupItem ( CUriListInterface::DestroyTransObj, dbTrans ) );
+ TInt lt = aQueryArgs.Get ( TPolicyQueryArgs::ETldListType );
+ RBuf8 upperCaseUri;
+ upperCaseUri.Create(aUri);
+ upperCaseUri.UpperCase();
+ dbTrans->BindTextL(0, aUri);
+ dbTrans->BindIntL(1, lt);
+ dbTrans->BindTextL(2, upperCaseUri );
+
+ // Execute the query
+ CUriQueryFilter* queryFilter = CTldPolicyDataFilter::NewL ( dbTrans );
+ upperCaseUri.Close();
+ CleanupStack::Pop (); // dbTrans
+ return queryFilter; // return the queryFilter
+ }
+
+/**
+Query the list with the URI and other specified parameters in the aQueryArgs
+*/
+CUriQueryFilter* CUriListInterface::QueryWithUriL ( const TDesC8& aUri, const TQueryArgs& aQueryArgs )
+ {
+ TUriParser8 uriParser;
+ User::LeaveIfError ( uriParser.Parse ( aUri ) );
+
+ MDBTransaction* dbTrans = NULL;
+ CUriQueryFilter* queryFilter = NULL;
+
+ TInt serviceType = aQueryArgs.Get ( TQueryArgs::EServiceType );
+ TInt listType = aQueryArgs.Get ( TQueryArgs::EListType );
+ InetUriList::TURIMatch matchType = InetUriList::EExact;
+ #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
+ if ( aQueryArgs.Get ( TQueryArgs::EURIMatch ) != KErrNotFound)
+ matchType = static_cast < InetUriList::TURIMatch > ( aQueryArgs.Get ( TQueryArgs::EURIMatch ) );
+ #else
+ if ( aQueryArgs.IsSet ( TQueryArgs::EURIMatch ) )
+ matchType = static_cast < InetUriList::TURIMatch > ( aQueryArgs.Get ( TQueryArgs::EURIMatch ) );
+ #endif //SYMBIAN_ENABLE_SPLIT_HEADERS
+ switch ( matchType )
+ {
+ case InetUriList::EExact:
+ dbTrans = DoSearchExactUriLC ( uriParser, serviceType, listType );
+ queryFilter = CUriQueryFilter::NewL ( dbTrans );
+ break;
+
+ case InetUriList::EDomain:
+ dbTrans = DoSearchUriDomainLC ( uriParser, serviceType, listType );
+ queryFilter = CUriDomainFilter::NewL ( dbTrans, uriParser.Extract( EUriHost ) );
+ break;
+
+ case InetUriList::EExactPath:
+ dbTrans = DoSearchUriPathLC (uriParser, matchType, serviceType, listType );
+ queryFilter = CUriQueryFilter::NewL ( dbTrans );
+ break;
+
+ case InetUriList::EPartialPrefixPath:
+ case InetUriList::EPartialSuffixPath:
+ dbTrans = DoSearchUriPathLC (uriParser, matchType, serviceType, listType );
+ queryFilter = CUriPathFilter::NewL ( dbTrans, matchType, uriParser.Extract ( EUriPath ) );
+ break;
+ default:
+ User::Invariant ();
+ }
+ CleanupStack::Pop (); // dbTrans
+ return queryFilter;
+ }
+
+/**
+Do a exact match in the list for the given uri and servicetype. All URI components
+will be matched
+*/
+MDBTransaction* CUriListInterface::DoSearchExactUriLC ( const TUriC8& aUri, TInt aServiceType, TInt aListType /* = KErrNotFound */ )
+ {
+ const TDesC8& serviceType (iStringPool.String (URILIST::EServiceType,URILIST::Table).DesC());
+ const TDesC8& listType (iStringPool.String (URILIST::EListType,URILIST::Table).DesC());
+
+ RBuf8 queryBuf;
+ InitViewQueryLC(queryBuf);
+
+ AppendFieldName ( queryBuf, URILIST::EScheme, aUri, EUriScheme );
+ AppendFieldName ( queryBuf, URILIST::EUserInfo, aUri, EUriUserinfo );
+ AppendFieldName ( queryBuf, URILIST::EHost, aUri, EUriHost );
+ AppendFieldName ( queryBuf, URILIST::EPort, aUri, EUriPort );
+ AppendFieldName ( queryBuf, URILIST::EPath, aUri, EUriPath );
+ AppendFieldName ( queryBuf, URILIST::EQuery, aUri, EUriQuery );
+ AppendFieldName ( queryBuf, URILIST::EFragments, aUri, EUriFragment );
+ if ( aListType == KErrNotFound )
+ {
+ _LIT8 ( KStr, "%S=%d" );
+ queryBuf.AppendFormat( KStr(), &serviceType, aServiceType );
+ }
+ else
+ {
+ _LIT8 ( KStrWithListType, "%S=%d and %S=%d" );
+ queryBuf.AppendFormat( KStrWithListType(), &serviceType, aServiceType, &listType, aListType );
+ }
+ TInt bindPos = 0;
+
+ // Prepare the transaction.
+ MDBTransaction* dbTrans = iDbAccessor->PrepareTransactionL ( queryBuf );
+ CleanupStack::PopAndDestroy (); // queryBuf
+ CleanupStack::PushL ( TCleanupItem ( CUriListInterface::DestroyTransObj, dbTrans ) );
+
+ if ( aUri.IsPresent(EUriScheme) && aUri.Extract(EUriScheme).Length() )
+ dbTrans->BindTextL ( bindPos++, aUri.Extract(EUriScheme) );
+ if ( aUri.IsPresent(EUriUserinfo) && aUri.Extract(EUriUserinfo).Length() )
+ dbTrans->BindTextL ( bindPos++, aUri.Extract(EUriUserinfo) );
+ if ( aUri.IsPresent(EUriHost) && aUri.Extract(EUriHost).Length() )
+ dbTrans->BindTextL ( bindPos++, aUri.Extract(EUriHost) );
+ if ( aUri.IsPresent(EUriPort) && aUri.Extract(EUriPort).Length() )
+ dbTrans->BindTextL ( bindPos++, aUri.Extract(EUriPort) );
+ if ( aUri.IsPresent(EUriPath) && aUri.Extract(EUriPath).Length() )
+ dbTrans->BindTextL ( bindPos++, aUri.Extract(EUriPath) );
+ if ( aUri.IsPresent(EUriQuery) && aUri.Extract(EUriQuery).Length() )
+ dbTrans->BindTextL ( bindPos++, aUri.Extract(EUriQuery) );
+ if ( aUri.IsPresent(EUriFragment) && aUri.Extract(EUriFragment).Length() )
+ dbTrans->BindTextL ( bindPos++, aUri.Extract(EUriFragment) );
+
+ return dbTrans;
+ }
+
+/**
+Do a path match. Path match can be EExactPath, EPartialSuffixPath or EPartialPrefixPath.
+Only path and scheme components of the URI is considered for this query
+
+Actual filtering of the query results will be done CUriPathFilter class while sending the results.
+*/
+MDBTransaction* CUriListInterface::DoSearchUriPathLC ( const TUriC8& aUri, InetUriList::TURIMatch aMatchType, TInt aServiceType, TInt aListType /* = KErrNotFound */ )
+ {
+ const TDesC8& serviceType (iStringPool.String (URILIST::EServiceType,URILIST::Table).DesC());
+ const TDesC8& listType (iStringPool.String (URILIST::EListType,URILIST::Table).DesC());
+ const TDesC8& path ( iStringPool.String (URILIST::EPath,URILIST::Table).DesC() );
+ const TDesC8& scheme ( iStringPool.String (URILIST::EScheme,URILIST::Table).DesC() );
+
+ RBuf8 queryBuf;
+ InitViewQueryLC(queryBuf);
+
+ if ( aMatchType == InetUriList::EExactPath && aListType == KErrNotFound )
+ {
+ // exact path without listtype
+ _LIT8 ( KFmtStr, "%S=? and %S=%d and %S=?" );
+ queryBuf.AppendFormat ( KFmtStr(), &scheme, &serviceType, aServiceType, &path );
+ }
+ else if ( aMatchType == InetUriList::EExactPath )
+ {
+ // exact path with listtype
+ _LIT8 ( KFmtStr, "%S=? and %S=%d and %S=%d and %S=?" );
+ queryBuf.AppendFormat ( KFmtStr(), &scheme, &serviceType, aServiceType, &listType, aListType, &path );
+ }
+ else if ( aListType == KErrNotFound )
+ {
+ // partial path withoutlisttype
+ _LIT8 ( KFmtStr, "%S=? and %S=%d" );
+ queryBuf.AppendFormat ( KFmtStr(), &scheme, &serviceType, aServiceType );
+ }
+ else
+ {
+ // partial path with listtype
+ _LIT8 ( KFmtStr, "%S=? and %S=%d and %S=%d" );
+ queryBuf.AppendFormat ( KFmtStr(), &scheme, &serviceType, aServiceType, &listType, aListType );
+ }
+
+ // Prepare the transaction.
+ MDBTransaction* dbTrans = iDbAccessor->PrepareTransactionL ( queryBuf );
+ CleanupStack::PopAndDestroy (); // queryBuf
+ CleanupStack::PushL ( TCleanupItem ( CUriListInterface::DestroyTransObj, dbTrans ) );
+ dbTrans->BindTextL ( 0, aUri.Extract ( EUriScheme ) ); // Bind the scheme
+ if ( aMatchType == InetUriList::EExactPath )
+ dbTrans->BindTextL ( 1, aUri.Extract ( EUriPath ) ); // Bind the path
+ return dbTrans;
+ }
+
+/**
+Do a domain search. Actual domain query ersults will be done in the CUriDomainFilter class
+*/
+MDBTransaction* CUriListInterface::DoSearchUriDomainLC ( const TUriC8& aUri, TInt aServiceType, TInt aListType /* = KErrNotFound */ )
+ {
+ const TDesC8& serviceType (iStringPool.String (URILIST::EServiceType,URILIST::Table).DesC());
+ const TDesC8& listType (iStringPool.String (URILIST::EListType,URILIST::Table).DesC());
+ const TDesC8& scheme ( iStringPool.String (URILIST::EScheme,URILIST::Table).DesC() );
+ RBuf8 queryBuf;
+ InitViewQueryLC(queryBuf);
+
+ if ( aListType == KErrNotFound )
+ {
+ _LIT8 ( KStr, "%S=? and %S=%d" );
+ queryBuf.AppendFormat( KStr(), &scheme, &serviceType, aServiceType );
+ }
+ else
+ {
+ _LIT8 ( KStrWithListType, "%S=? and %S=%d and %S=%d" );
+ queryBuf.AppendFormat( KStrWithListType(), &scheme, &serviceType, aServiceType, &listType, aListType );
+ }
+ // Prepare the transaction.
+ MDBTransaction* dbTrans = iDbAccessor->PrepareTransactionL ( queryBuf );
+ CleanupStack::PopAndDestroy (); // queryBuf
+ CleanupStack::PushL ( TCleanupItem ( CUriListInterface::DestroyTransObj, dbTrans ) );
+ dbTrans->BindTextL ( 0, aUri.Extract ( EUriScheme ) ); // Bind the scheme
+
+ return dbTrans;
+ }
+
+
+void CUriListInterface::InitViewQueryLC ( RBuf8& aBuf )
+ {
+ _LIT8 ( KSelectStmt, "SELECT * FROM %S where ");
+ CleanupClosePushL ( aBuf );
+ aBuf.CreateL ( KMaxDbStmtLen );
+ aBuf.AppendFormat ( KSelectStmt(), &(KViewName()) );
+ }
+
+void CUriListInterface::InitTldQueryLC ( RBuf8& aBuf )
+ {
+ _LIT8 ( KSelectStmt, "SELECT * FROM %S where ");
+ CleanupClosePushL ( aBuf );
+ aBuf.CreateL ( KMaxDbStmtLen );
+ aBuf.AppendFormat ( KSelectStmt(), &(KTldTblName()) );
+ }
+
+void CUriListInterface::AppendFieldName ( RBuf8& aBuf, TInt aTableIndex, const TUriC8& aUri, TUriComponent aComponent )
+ {
+ _LIT8 ( KNormalStr, "%S=? and " );
+ _LIT8 ( KIsNullStr, "%S ISNULL and " );
+
+ const TPtrC8 value ( aUri.IsPresent ( aComponent ) ? aUri.Extract ( aComponent ) : KNullDesC8() );
+ if ( value.Length() > 0 )
+ {
+ aBuf.AppendFormat ( KNormalStr(), &(GetFieldName(aTableIndex)) );
+ }
+ else
+ {
+ aBuf.AppendFormat ( KIsNullStr(), &(GetFieldName(aTableIndex)) );
+ }
+ }
+
+const TDesC8& CUriListInterface::GetFieldName ( TInt aTableIndex )
+ {
+ return iStringPool.String ( aTableIndex,URILIST::Table ).DesC();
+ }
+
+void CUriListInterface::BindTextL ( MDBTransaction& aDbTrans, TInt aBindPos, const TUriC8& aUri, TUriComponent aComponent )
+ {
+ TPtrC8 valuePtr ( KNullDesC8() );
+ if ( aUri.IsPresent (aComponent) )
+ valuePtr.Set( aUri.Extract ( aComponent ) );
+
+ aDbTrans.BindTextL ( aBindPos, (valuePtr.Length() == 0) ? KNullDesC8() : valuePtr );
+ }
+
+/**
+Initializes the database(if it is empty) from the pre-configured XML file.
+
+*/
+void CUriListInterface::InitializeDatabaseL ()
+ {
+ const TDesC8& id ( iStringPool.String (URILIST::EId,URILIST::Table).DesC() );
+ if ( GetMaxIdValueL ( KViewName(), id ) != 0 )
+ {
+ // Database already created and thre are some values already added.
+ //Update with Policyfile installed, after rebooting the server.
+ UpgradePolicyDatabaseL();
+ return;
+ }
+ // Otherwise go and read the XML file, if exists and populate the data fields
+ TBuf<KMaxLength> uriListFilePath;
+ uriListFilePath.FillZ();
+ //if uriListFilePath is Null then SIS file is not installed
+ GetInstalledDirectoryL( TUid::Uid(pkgId), KUriListFile(), uriListFilePath );
+ CUriListInitializer* listInitializer = CUriListInitializer::NewL ( *this );
+ CleanupStack::PushL ( listInitializer );
+ TInt err( KErrNone );
+ if(uriListFilePath.CompareF(KNullDesC) != 0)
+ {
+ //File ineturilist.xml exist in external path.
+ TRAP ( err, listInitializer->ParseDocumentL ( uriListFilePath ) );
+ }
+ CleanupStack::PopAndDestroy (); // listInitializer
+ if ( err != KErrNotFound && err != KErrPathNotFound )
+ {
+ // File found and some other error. leave
+ User::LeaveIfError ( err );
+ }
+ //initialise Policy data
+ InitializePolicyDatabaseL();
+ }
+
+
+/**
+Initializes the database to default policy data if it is available in ROM.
+If a valid upgraded policy file exist then, database will be updated to later version.
+*/
+void CUriListInterface::InitializePolicyDatabaseL ()
+ {
+ //Install the file with ROM Policy data if ROM file exists
+ _LIT( KDefaultFilePath, "z:\\private\\20009d70\\tldpolicy.xml");
+ if( FileExist( KDefaultFilePath() ) )
+ {
+ CTldListInitializer* tldlistInitializer = CTldListInitializer::NewL ( *this );
+ CleanupStack::PushL ( tldlistInitializer );
+ TRAPD ( policyfileerr, tldlistInitializer->ParseDocumentL ( KDefaultFilePath() ) );
+ CleanupStack::PopAndDestroy (); //tldlistInitializer
+ if ( policyfileerr != KErrNotFound && policyfileerr != KErrPathNotFound ) // File found and some other error. leave
+ {
+ User::LeaveIfError ( policyfileerr );
+ }
+ }
+
+ UpgradePolicyDatabaseL();
+ }
+
+/**
+Database will be updated with the Policy file installed.
+*/
+void CUriListInterface::UpgradePolicyDatabaseL()
+ {
+ //Upgrade DB if Policy file is installed
+ //Get the Installed file path
+ _LIT(KTldPolicyFile, "c:\\private\\20009d70\\tldpolicy.xml");
+ if(!FileExist( KTldPolicyFile() ))
+ {
+ return;
+ }
+ //Upgrade DB
+ CTldListInitializer* tldListUpgrader = CTldListInitializer::NewL ( *this );
+ CleanupStack::PushL ( tldListUpgrader );
+ TRAPD ( fileerr, tldListUpgrader->ParseDocumentL ( KTldPolicyFile() ) );
+ CleanupStack::PopAndDestroy ();//tldListUpgrader
+ if ( fileerr != KErrNotFound && fileerr != KErrPathNotFound ) // File found and some other error. leave
+ {
+ User::LeaveIfError ( fileerr );
+ }
+ }
+
+/**
+Get the external file path installed out of ROM.
+out parameter -- aFilePath
+*/
+void CUriListInterface::GetInstalledDirectoryL(const TUid aUid, const TDesC& aFile, TDes& aFilePath )
+ {
+ __ASSERT_DEBUG( aFile.CompareF( KNullDesC ) !=0, User::Invariant( ) );
+ Swi::RSisRegistrySession session;
+ if(session.Connect( ) != KErrNone)
+ {
+ //Sis Not Installed
+ session.Close();
+ return;
+ }
+ CleanupClosePushL( session );
+ TBool installed = session.IsInstalledL( aUid );
+ Swi::RSisRegistryEntry registryEntry;
+ TInt error = registryEntry.Open( session, aUid );
+ CleanupClosePushL( registryEntry );
+ TBool available = EFalse;
+ if ( error == KErrNone )
+ {
+ RPointerArray<HBufC> files;
+ // get list of files
+ TRAPD( err, registryEntry.FilesL( files ) );
+ if (err != KErrNone)
+ {
+ files.ResetAndDestroy();
+ CleanupStack::PopAndDestroy(2); // ®istryEntry, &session
+ User::Leave(err);
+ }
+ TInt filesCount = files.Count();
+ for (TInt index = 0; index < filesCount; index++)
+ {
+ TBuf<KMaxLength> fileNameBuf(KNullDesC);
+ fileNameBuf.Copy(files[index]->Des());
+ TInt pos = fileNameBuf.FindF(aFile);
+ if( pos >= 0 && !available && fileNameBuf.Left(pos).CompareF(KRomDirectory)!=0 )
+ {
+ aFilePath.Copy(fileNameBuf);
+ available = ETrue;
+ break;
+ }
+ }
+ files.ResetAndDestroy();
+ }
+ CleanupStack::PopAndDestroy(2); // ®istryEntry, &session
+ }
+
+/**
+Checks if the specified file exists.
+
+@param aFileName File to check
+@return ETrue if the file exists, otherwise EFalse
+*/
+TBool CUriListInterface::FileExist(const TDesC& aFilePath)
+ {
+ RFs iFs;
+ TBool result( EFalse );
+ TInt error = iFs.Connect();
+ if( !error )
+ {
+ result = BaflUtils::FileExists( iFs, aFilePath );
+ }
+ iFs.Close();
+ return result;
+ }
+
+/**
+return ETrue if Uri is BlackListed, else return EFalse
+Leaves with KErrNotSupported if No Policydata is available
+*/
+TBool CUriListInterface::IsBlackListedUriL( const TDesC8& aUri )
+ {
+ TBool blackListed(EFalse);
+ TPolicyQueryArgs blackListArgs ( InetUriList::EBlackList, InetUriList::EPolicyCharSet );
+ CUriQueryFilter* queryFilter = QueryWithTldL ( aUri, blackListArgs );
+ CleanupStack::PushL(queryFilter);
+ MDBTransaction& dbTrans = queryFilter->DBTransaction();
+ if ( dbTrans.Next() && queryFilter->MatchRecordL() )
+ {
+ const TDesC8& charSet = dbTrans.ColumnTextL ( TLDLIST::ECharacterSet );
+ //Policy file contains empty body for Requested white/Black listed data
+ __ASSERT_ALWAYS( charSet.Length() > 0, User::Invariant() );
+ RArray<TChar> policyCharList;
+ CleanupClosePushL(policyCharList);
+ //Tokenize the results
+ TokenizeStringL( charSet, policyCharList);
+ //Get the host and check whether any of these char is in PolicyCharList
+ HBufC8* host = ExtractHostL(aUri);
+ CleanupStack::PushL(host);
+ blackListed = IsBlackListedHost( host->Des(), policyCharList );
+ CleanupStack::PopAndDestroy(2); //host, PolicyCharList
+ }
+ else
+ {
+ //Requested Policydata Not available for this TLD
+ CleanupStack::PopAndDestroy(queryFilter);
+ User::Leave(InetUriList::KErrInvalidTLD);
+ }
+ CleanupStack::PopAndDestroy(queryFilter);
+ return blackListed;
+ }
+
+/**
+return ETrue if Uri is WhiteListed, else return EFalse
+Leaves with KErrNotSupported if No Policydata is available
+*/
+TBool CUriListInterface::IsWhiteListedUriL( const TDesC8& aUri )
+ {
+ TBool whiteListed (EFalse);
+ TPolicyQueryArgs whiteListArgs ( InetUriList::EWhiteList, InetUriList::EPolicyCharSet );
+ CUriQueryFilter* queryFilter = QueryWithTldL ( aUri, whiteListArgs );
+ CleanupStack::PushL(queryFilter);
+ MDBTransaction& dbTrans = queryFilter->DBTransaction();
+ if ( dbTrans.Next() && queryFilter->MatchRecordL() )
+ {
+ const TDesC8& charSet = dbTrans.ColumnTextL ( TLDLIST::ECharacterSet );
+ //Policy file contains empty body for Requested white/Black listed data
+ __ASSERT_ALWAYS( charSet.Length() > 0, User::Invariant() );
+ RArray<TChar> policyCharList;
+ CleanupClosePushL(policyCharList);
+ //Tokenize the results
+ TokenizeStringL(charSet, policyCharList);
+ //Get the host and check whether any of these char is in PolicyCharList
+ HBufC8* host = ExtractHostL(aUri);
+ CleanupStack::PushL(host);
+ whiteListed = IsWhiteListedHostL( host->Des(), policyCharList );
+ CleanupStack::PopAndDestroy(2); // PolicyCharList,host
+ }
+ else
+ {
+ //Requested Policydata Not available for this TLD
+ CleanupStack::PopAndDestroy(queryFilter);
+ User::Leave(InetUriList::KErrInvalidTLD);
+ }
+ CleanupStack::PopAndDestroy(queryFilter);
+ return whiteListed;
+ }
+
+/**
+returns ETrue if aHost is white listed else returns EFalse
+*/
+TBool CUriListInterface::IsWhiteListedHostL( const TDesC8& aHost, RArray<TChar>& aPolicyList )
+ {
+ //Every character in the host must be in the list
+ RArray<TChar> hostCharList;
+ CleanupClosePushL(hostCharList);
+ StringToCharListL(aHost, hostCharList);
+ TBool whiteList(ETrue);
+ for(TInt index(0); index < hostCharList.Count(); index++ )
+ {
+ if(!IsNextCharInList(hostCharList[index], aPolicyList))
+ {
+ whiteList = EFalse;
+ break;
+ }
+ }
+ CleanupStack::PopAndDestroy();//hostCharList
+ return whiteList;
+ }
+
+/**
+Returns ETrue if aChar is in aPolicyList else returns EFalse
+*/
+TBool CUriListInterface::IsNextCharInList(TChar aChar, RArray<TChar>& aPolicyList)
+ {
+ TBool found(EFalse);
+ for (TInt index(0); index < aPolicyList.Count(); index++)
+ {
+ if( aPolicyList[index] == aChar )
+ {
+ found = ETrue;
+ break;
+ }
+ }
+ return found;
+ }
+
+/**
+Tokenizes the policydata into characters list
+*/
+void CUriListInterface::TokenizeStringL(const TDesC8& aString, RArray<TChar>& aList, TChar aSeparator)
+ {
+ TLex8 lexer(aString);
+ while(!lexer.Eos())
+ {
+ TChar charcter = lexer.Get();
+ if ( charcter != aSeparator && charcter != '\n' && charcter != '\t' )
+ {
+ aList.AppendL(charcter);
+ }
+ }
+ }
+
+/**
+Tokenizes the Host into characters list
+*/
+void CUriListInterface::StringToCharListL(const TDesC8& aString, RArray<TChar>& aList, TChar aSeparator)
+ {
+ //Here sepearator is '.'
+ TokenizeStringL( aString, aList, aSeparator );
+ }
+
+/**
+returns ETrue if aHost is Black listed else returns EFalse
+*/
+TBool CUriListInterface::IsBlackListedHost( const TDesC8& aHost, RArray<TChar>& aList )
+ {
+ TBool result( EFalse );
+ for(TInt index(0); index < aList.Count(); index++ )
+ {
+ if ( aHost.Locate(aList[index]) >= 0 )
+ {
+ result = ETrue;
+ break;
+ }
+ }
+ return result;
+ }
+
+/**
+Extracts the TLD from the given uri.
+*/
+HBufC8* CUriListInterface::ExtractTldL( const TDesC8& aUri )
+ {
+ HBufC8* tld = ExtractHostL( aUri );
+ CleanupStack::PushL( tld );
+ TChar dot('.');
+ TInt pos = tld->LocateReverse( dot );
+ __ASSERT_DEBUG( ( pos >= 0 ) , User::Invariant() );
+ HBufC8* tldPtr = tld->Mid( pos + 1 ).AllocL(); //Excluding dot '.'
+ CleanupStack::PopAndDestroy( tld );
+ return tldPtr;
+ }
+
+/**
+Extracts the Host from the given uri.
+*/
+HBufC8* CUriListInterface::ExtractHostL( const TDesC8& aUri )
+ {
+ TUriParser8 tldUri1;
+ RBuf8 tld;
+ RBuf8 customisedUri;
+ HBufC8* tldPtr;
+ User::LeaveIfError ( tldUri1.Parse ( aUri ) );
+ TBool isSchemePresent = tldUri1.IsPresent( EUriScheme );
+ if (!isSchemePresent)
+ {
+ _LIT8(KHttp, "http://");
+ RBuf8 urirbuf;
+ urirbuf.CleanupClosePushL();
+ urirbuf.CreateL(KHttp,aUri.Length()+7);
+ urirbuf.Append(aUri);
+ customisedUri.Create( DoNormalisationLC ( urirbuf ) );
+ TUriParser8 tldUri2;
+ User::LeaveIfError ( tldUri2.Parse ( customisedUri ) );
+ __ASSERT_ALWAYS(tldUri2.IsPresent( EUriHost ), User::Invariant());
+ tld.Create( tldUri2.Extract(EUriHost) );
+ tldPtr = tld.AllocL();
+ CleanupStack::PopAndDestroy(2); //calls aRBuf.Close()and DoNormalisationLC pop
+
+ }
+ else
+ {
+ customisedUri.Create( DoNormalisationLC ( aUri ) );
+ User::LeaveIfError ( tldUri1.Parse ( customisedUri ) );
+ __ASSERT_ALWAYS(tldUri1.IsPresent( EUriHost ), User::Invariant());
+ tld.Create( tldUri1.Extract(EUriHost) );
+ tldPtr = tld.AllocL();
+ CleanupStack::PopAndDestroy ();//objects added in DoNormalisationLC
+ }
+ tld.Close();
+ customisedUri.Close();
+ return tldPtr;
+ }
+
+/**
+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& CUriListInterface::DoNormalisationLC ( const TDesC8& aUri )
+ {
+ // Do a syntax based normalisation
+ TUriParser8 uriParser;
+ User::LeaveIfError ( uriParser.Parse ( aUri ) );
+ CUri8* normalisedUri = UriUtils::NormaliseUriL ( uriParser );
+ CleanupStack::PushL ( normalisedUri );
+ return normalisedUri->Uri().UriDes();
+ }
+