/*

* Copyright (c) 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: Implementation of policymanagement components

*

*/

/* PolicyEngineClient.cpp

*/

#include <eikenv.h>

#include <eikappui.h>

#include <e32svr.h>

#include <featmgr.h>

#include <bldvariant.hrh>

#include "PolicyEngineClientServer.h"

#include "PolicyEngineClientServerDefs.h"

#include "PolicyEngineClient.h"

#include "ErrorCodes.h"

#include "debug.h"

// Standard server startup code

// 

static TInt StartServer()

	{

	RDEBUG("PolicyEngineServer: Starting server...");

	const TUidType serverUid(KNullUid,KNullUid,KPolicyEngineServerUid);

	// EPOC and EKA 2 is easy, we just create a new server process. Simultaneous

	// launching of two such processes should be detected when the second one

	// attempts to create the server object, failing with KErrAlreadyExists.

	RProcess server;

	//TInt r=server.Create(KHelloWorldServerImg,KNullDesC,serverUid);

	TInt r=server.Create(KPolicyEngineServerImg,KNullDesC);

	if (r!=KErrNone)

		{

		RDEBUG_2("PolicyEngineClient: server start failed %d",r);

		return r;

		}

	TRequestStatus stat;

	server.Rendezvous(stat);

	if (stat!=KRequestPending)

		server.Kill(0);		// abort startup

	else

		server.Resume();	// logon OK - start the server

	RDEBUG("PolicyEngineClient: Started");

	User::WaitForRequest(stat);		// wait for start or death

	// we can't use the 'exit reason' if the server panicked as this

	// is the panic 'reason' and may be '0' which cannot be distinguished

	// from KErrNone

	r=(server.ExitType()==EExitPanic) ? KErrGeneral : stat.Int();

	server.Close();

	return r;

	}

// This is the standard retry pattern for server connection

EXPORT_C TInt RPolicyEngine::Connect()

	{

	TRAPD( e, FeatureManager::InitializeLibL() );

	if( e != KErrNone )

		{

		return e;

		}

	TBool iSupported = FeatureManager::FeatureSupported( KFeatureIdSapPolicyManagement);

	FeatureManager::UnInitializeLib();	    

	if( !iSupported )

		{

		return KErrNotSupported;

		}	

	TInt retry=2;

	for (;;)

		{

		TInt r=CreateSession(KPolicyEngineServerName,TVersion(0,0,0),1);

		if (r!=KErrNotFound && r!=KErrServerTerminated)

			return r;

		if (--retry==0)

			return r;

		r=StartServer();

		if (r!=KErrNone && r!=KErrAlreadyExists)

			return r;

		}

	}

EXPORT_C void RPolicyEngine::Close()

	{

	RSessionBase::Close();  //basecall

	}

EXPORT_C TInt RPolicyEngine::PerformRFS()

{

   	RDEBUG("PolicyEngineClient: Perform RFS");

	return SendReceive( EPerformPMRFS);		

}

// ----------------------------------------------------------------------------------------

// RPolicyManagement subsessions

// ----------------------------------------------------------------------------------------

//  create new subsession

EXPORT_C TInt RPolicyManagement::Open(RPolicyEngine &aServer )

    {

	RDEBUG("PolicyEngineClient: Create new managemenet subsession");

	return CreateSubSession(aServer,ECreateManagementSubSession,TIpcArgs(NULL,NULL));

	}

// close a subsession

EXPORT_C void RPolicyManagement::Close()

	{

	RDEBUG("PolicyEngineClient: Close managemenet subsession");

	RSubSessionBase::CloseSubSession(ECloseManagementSubSession);

	}

EXPORT_C TInt RPolicyManagement::ExecuteOperation( const TDesC8& aOperationDescription, 

		          					  	TParserResponse &aResponse)

{

	RDEBUG("PolicyEngineClient: Execute operation");

	TPckg<TParserResponse> pack(aResponse);

	TInt err = SendReceive( EExecuteOperation, TIpcArgs(&aOperationDescription, &pack));	

	return err;	

}

EXPORT_C TInt RPolicyManagement::ExecuteOperation( const TDesC8& aOperationDescription )

{

	TParserResponse response;

	TInt err = ExecuteOperation( aOperationDescription, response);

	if ( err == KErrNone )

	{

		if ( response.GetReturnMessage().Compare( ManagementErrors::OperationOk) != 0)

		{

			err = KErrAbort;

		}

	}

	return err;

}

EXPORT_C TInt RPolicyManagement::GetElementL( TElementInfo& aElementInfo)

{

	RDEBUG("PolicyEngineClient: Get element");

	TElementInfoHelpPack helper;

	helper.iDescriptionLength = 0;

	helper.iChildListLength = 0;

	TPckg<TElementInfoHelpPack> helperPack(helper);

	TInt err = SendReceive( EGetElementDescriptionAndChildListLength, TIpcArgs( &aElementInfo.iElementId, &helperPack));	

	if ( err == KErrNone)

	{

		HBufC8 * childs = HBufC8::NewLC( helper.iChildListLength);	

		aElementInfo.iDescription = HBufC8::NewL( helper.iDescriptionLength);	

		TPtr8 descriptionArgs = aElementInfo.iDescription->Des();

		TPtr8 childsArgs = childs->Des();

		err =	SendReceive( EReadElementAndChildList, 

		   		TIpcArgs( &descriptionArgs, &childsArgs));	

		if ( err == KErrNone )

		{

			aElementInfo.iChildElements.SetListL( *childs); 

		}

		CleanupStack::PopAndDestroy();

	}

	return err;

}

EXPORT_C TInt RPolicyManagement::GetXACMLDescriptionL( TElementInfo& aElementInfo)

{

	RDEBUG("PolicyEngineClient: Get XACML description");

	TInt XACMLLength;

	TPckg<TInt> lengthPack(XACMLLength);

	TInt err = SendReceive( EGetElementXACMLLength, TIpcArgs( &aElementInfo.iElementId, &lengthPack));	

	if ( err == KErrNone)

	{

		aElementInfo.iXACMLContent = HBufC8::NewL( XACMLLength);	

		TPtr8 contentArgs = aElementInfo.iXACMLContent->Des();

		err = SendReceive( EReadElementXACML, 

			   TIpcArgs( &contentArgs));	

	}

	return err;	

}

EXPORT_C TInt RPolicyManagement::GetElementListL( const TElementType& aElementType, RElementIdArray& aElementIdArray)

{

	RDEBUG("PolicyEngineClient: Get element list");

	//Create packages for data

	TInt listLength;

	TPckg<TInt> lengthPack(listLength);

	TPckg<TElementType> typePack(aElementType);

	//get element list length from server side

	TInt err = SendReceive( EGetElementListLength, TIpcArgs( &typePack, &lengthPack));	

	//and if operation ok, get also element list

	if ( err == KErrNone)

	{

		//create buffer for list

		TPtr8 ptr = HBufC8::NewLC( listLength)->Des();	

		//get element list descriptor

		err = SendReceive( EReadElementList, TIpcArgs( &ptr));	

		//feed list descriptor for IDArray element, which decode descriptor to list format

		if ( err == KErrNone)

		{

			aElementIdArray.SetListL( ptr);

		}

		//HBufC8

		CleanupStack::PopAndDestroy();		

	}

	return err;	

}

EXPORT_C TInt RPolicyManagement::AddSessionTrust( TCertInfo& aCertInfo)

{

	RDEBUG("PolicyEngineClient: Add session trust");

	//Create package for data

	TPckg<TCertInfo> certInfoPck( aCertInfo);

	//Send CertInfo to server

	return SendReceive( EAddSessionTrust, TIpcArgs( &certInfoPck));	

}

EXPORT_C TInt RPolicyManagement::IsAllowedServerId( const TDesC& aServerID)

{

	RDEBUG_2("RPolicyManagement::IsAllowedServerId( %S )", &aServerID );

	//Create package for data

	TBool response;

	TPckg<TBool> respPck( response);

	//make 8-bit descriptor

	HBufC8* buf = NULL;

	TRAPD( e, buf = HBufC8::NewL( aServerID.Length()) );

	if( e != KErrNone )

		{

		return e;

		}

	buf->Des().Append( aServerID);

	//Send parameters to server

	TInt err = SendReceive( EIsServerIdValid, TIpcArgs( buf, &respPck));	

	if ( err == KErrNone )

	{

		if ( !response )

		{

			err = KErrAccessDenied;

		}

	}

	delete buf;

	buf = NULL;

	return err;

}

EXPORT_C TInt RPolicyManagement::CertificateRole( TCertInfo& aCertInfo, TRole& aRole)

{

	RDEBUG("PolicyEngineClient: Certificate role");

	//Create package for data

	TPckg<TCertInfo> certInfoPck( aCertInfo);

	TPckg<TRole> rolePck( aRole);

	//Send parameters to server

	return SendReceive( ECertificateRole, TIpcArgs( &certInfoPck, &rolePck));	

}

// ----------------------------------------------------------------------------------------

// RPolicyRequest subsessions

// ----------------------------------------------------------------------------------------

//  create new subsession 

EXPORT_C TInt RPolicyRequest::Open(RPolicyEngine &aServer )

    {

   	RDEBUG("PolicyEngineClient: Open policy request subsession");

	return CreateSubSession(aServer,ECreateRequestSubSession,TIpcArgs(NULL,NULL));

	}

// close a subsession

EXPORT_C void RPolicyRequest::Close()

	{

   	RDEBUG("PolicyEngineClient: Close policy request subsession");

	RSubSessionBase::CloseSubSession(ECloseRequestSubSessio);

	}

EXPORT_C TInt RPolicyRequest::MakeRequest( TRequestContext& aRequestContext, TResponse& aResponse)

{

   	RDEBUG("PolicyEngineClient: Make policy request");

	TPckg<TResponse> pack( aResponse);

	return SendReceive( EPolicyRequest, TIpcArgs( &aRequestContext.RequestDescription(), &pack));		

}