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

	}