/*
* Copyright (c) 2002-2004 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:  $Description: $
*
*/



// INCLUDE FILES
#include "TARMDmAdapter.h"
#include <PolicyEngineClient.h>
#include <SettingEnforcementInfo.h>
#include <DMCert.h>
#include <PolicyEngineXACML.h>
#include "debug.h"
#include <smldmadapter.h>


// ============================ MEMBER FUNCTIONS ===============================


///////////////////////////////////////////////////////////////////////////////////////////////////
//
// CTARMDmAdapter
//
///////////////////////////////////////////////////////////////////////////////////////////////////

// -----------------------------------------------------------------------------
// CTARMDmAdapter::
// 
// -----------------------------------------------------------------------------
//
CTARMDmAdapter::CTARMDmAdapter( MSmlDmCallback* aCallback )
	: CSmlDmAdapter( aCallback )
	, iInitialized( EFalse )
	{
	RDEBUG( "CTARMDmAdapter::CTARMDmAdapter" );
	}

// -----------------------------------------------------------------------------
// CTARMDmAdapter::
// 
// -----------------------------------------------------------------------------
//
/*
void CTARMDmAdapter::ConstructL()
	{
    User::LeaveIfError( iPE.Connect() );
    User::LeaveIfError( iPR.Open( iPE ) );
	}
*/

void CTARMDmAdapter::InitializeL()
	{
	RDEBUG( "CTARMDmAdapter::InitializeL >" );
	if ( !iInitialized )
		{
	    User::LeaveIfError( iPE.Connect() );
	    User::LeaveIfError( iPR.Open( iPE ) );
	    iInitialized = ETrue;
		}
    RDEBUG( "CTARMDmAdapter::InitializeL <" );
	}

// -----------------------------------------------------------------------------
// CTARMDmAdapter::
// 
// -----------------------------------------------------------------------------
//
CTARMDmAdapter::~CTARMDmAdapter()
	{
	RDEBUG( "CTARMDmAdapter::~CTARMDmAdapter >" );
	if ( iInitialized )
		{
		iPR.Close();
		iPE.Close();
		}
	RDEBUG( "CTARMDmAdapter::~CTARMDmAdapter <" );
	}

// -----------------------------------------------------------------------------
// CTARMDmAdapter::
// 
// -----------------------------------------------------------------------------
//
void CTARMDmAdapter::UpdateLeafObjectL( const TDesC8& aURI, const TDesC8& aLUID, const TDesC8& aObject, const TDesC8& aType, TInt aStatusRef )
	{
	RDEBUG( "CTARMDmAdapter::UpdateLeafObjectL >" );
	if (CheckPolicyL( aURI ) != KErrNone)
		{
		Callback().SetStatusL( aStatusRef, EError );
		return;
		}
	_UpdateLeafObjectL( aURI, aLUID, aObject, aType, aStatusRef );
	RDEBUG( "CTARMDmAdapter::UpdateLeafObjectL <" );
	}

// -----------------------------------------------------------------------------
// CTARMDmAdapter::
// 
// -----------------------------------------------------------------------------
//
void CTARMDmAdapter::UpdateLeafObjectL( const TDesC8& aURI, const TDesC8& aLUID, RWriteStream*& aStream, const TDesC8& aType, TInt aStatusRef )
	{
	RDEBUG( "CTARMDmAdapter::UpdateLeafObjectL >" );
	if (CheckPolicyL( aURI ) != KErrNone)
		{
		Callback().SetStatusL( aStatusRef, EError );
		return;
		}
	_UpdateLeafObjectL( aURI, aLUID, aStream, aType, aStatusRef );
	RDEBUG( "CTARMDmAdapter::UpdateLeafObjectL <" );
	}

// -----------------------------------------------------------------------------
// CTARMDmAdapter::
// 
// -----------------------------------------------------------------------------
//
void CTARMDmAdapter::DeleteObjectL( const TDesC8& aURI, const TDesC8& aLUID, TInt aStatusRef )
	{
	RDEBUG( "CTARMDmAdapter::DeleteObjectL >" );
	if (CheckPolicyL( aURI ) != KErrNone)
		{
		Callback().SetStatusL( aStatusRef, EError );
		return;
		}
	_DeleteObjectL( aURI, aLUID, aStatusRef );
	RDEBUG( "CTARMDmAdapter::DeleteObjectL <" );
	}

// -----------------------------------------------------------------------------
// CTARMDmAdapter::
// 
// -----------------------------------------------------------------------------
//
void CTARMDmAdapter::FetchLeafObjectL( const TDesC8& aURI, const TDesC8& aLUID, const TDesC8& aType, TInt aResultsRef, TInt aStatusRef )
	{
	RDEBUG( "CTARMDmAdapter::FetchLeafObjectL >" );
	if (CheckPolicyL( aURI ) != KErrNone)
		{
		Callback().SetStatusL( aStatusRef, EError );
		return;
		}
	_FetchLeafObjectL( aURI, aLUID, aType, aResultsRef, aStatusRef );
	RDEBUG( "CTARMDmAdapter::FetchLeafObjectL <" );
	}

// -----------------------------------------------------------------------------
// CTARMDmAdapter::
// 
// -----------------------------------------------------------------------------
//
void CTARMDmAdapter::FetchLeafObjectSizeL( const TDesC8& aURI, const TDesC8& aLUID, const TDesC8& aType, TInt aResultsRef, TInt aStatusRef )
	{
	RDEBUG( "CTARMDmAdapter::FetchLeafObjectSizeL >" );
	if (CheckPolicyL( aURI ) != KErrNone)
		{
		Callback().SetStatusL( aStatusRef, EError );
		return;
		}
	_FetchLeafObjectSizeL( aURI, aLUID, aType, aResultsRef, aStatusRef );
	RDEBUG( "CTARMDmAdapter::FetchLeafObjectSizeL <" );
	}

// -----------------------------------------------------------------------------
// CTARMDmAdapter::
// 
// -----------------------------------------------------------------------------
//
void CTARMDmAdapter::ChildURIListL( const TDesC8& aURI, const TDesC8& aLUID, const CArrayFix<TSmlDmMappingInfo>& aPreviousURISegmentList, TInt aResultsRef, TInt aStatusRef )
	{
	RDEBUG( "CTARMDmAdapter::ChildURIListL >" );
	if (CheckPolicyL( aURI ) != KErrNone)
		{
		Callback().SetStatusL( aStatusRef, EError );
		return;
		}
	_ChildURIListL( aURI, aLUID, aPreviousURISegmentList, aResultsRef, aStatusRef );
	RDEBUG( "CTARMDmAdapter::ChildURIListL <" );
	}

// -----------------------------------------------------------------------------
// CTARMDmAdapter::
// 
// -----------------------------------------------------------------------------
//
void CTARMDmAdapter::AddNodeObjectL( const TDesC8& aURI, const TDesC8& aParentLUID, TInt aStatusRef )
	{
	RDEBUG( "CTARMDmAdapter::AddNodeObjectL >" );
	if (CheckPolicyL( aURI ) != KErrNone)
		{
		Callback().SetStatusL( aStatusRef, EError );
		return;
		}
	_AddNodeObjectL( aURI, aParentLUID, aStatusRef );
	RDEBUG( "CTARMDmAdapter::AddNodeObjectL <" );
	}

// -----------------------------------------------------------------------------
// CTARMDmAdapter::
// 
// -----------------------------------------------------------------------------
//
void CTARMDmAdapter::ExecuteCommandL( const TDesC8& aURI, const TDesC8& aLUID, const TDesC8& aArgument, const TDesC8& aType, TInt aStatusRef )
	{
	RDEBUG( "CTARMDmAdapter::ExecuteCommandL >" );
	if (CheckPolicyL( aURI ) != KErrNone)
		{
		Callback().SetStatusL( aStatusRef, EError );
		return;
		}
	_ExecuteCommandL( aURI, aLUID, aArgument, aType, aStatusRef );
	RDEBUG( "CTARMDmAdapter::ExecuteCommandL <" );
	}

// -----------------------------------------------------------------------------
// CTARMDmAdapter::
// 
// -----------------------------------------------------------------------------
//
void CTARMDmAdapter::ExecuteCommandL( const TDesC8& aURI, const TDesC8& aLUID, RWriteStream*& aStream, const TDesC8& aType, TInt aStatusRef )
	{
	RDEBUG( "CTARMDmAdapter::ExecuteCommandL (stream) >" );
	if (CheckPolicyL( aURI ) != KErrNone)
		{
		Callback().SetStatusL( aStatusRef, EError );
		return;
		}
	_ExecuteCommandL( aURI, aLUID, aStream, aType, aStatusRef );
	RDEBUG( "CTARMDmAdapter::ExecuteCommandL (stream) <" );
	}

// -----------------------------------------------------------------------------
// CTARMDmAdapter::
// 
// -----------------------------------------------------------------------------
//
void CTARMDmAdapter::CopyCommandL( const TDesC8& aTargetURI, const TDesC8& aTargetLUID, const TDesC8& aSourceURI, const TDesC8& aSourceLUID, const TDesC8& aType, TInt aStatusRef )
	{
	RDEBUG( "CTARMDmAdapter::CopyCommandL >" );
	if (CheckPolicyL( aTargetURI ) != KErrNone)
		{
		Callback().SetStatusL( aStatusRef, EError );
		return;
		}
	_CopyCommandL( aTargetURI, aTargetLUID, aSourceURI, aSourceLUID, aType, aStatusRef );
	RDEBUG( "CTARMDmAdapter::CopyCommandL <" );
	}

// -----------------------------------------------------------------------------
// CTARMDmAdapter::
// 
// -----------------------------------------------------------------------------
//
TInt CTARMDmAdapter::CheckPolicyL( const TDesC8& aURI )
	{
	RDEBUG( "CTARMDmAdapter::CheckPolicyL >" );
	InitializeL();
	TPtrC8 resource = PolicyRequestResourceL( aURI );

//sf	TPolicyRequestParams params = iAdapter->CreatePolicyRequestParamsL( aURI );
	TInt ret = CheckPolicy2L( resource );
	RDEBUG_2( "CTARMDmAdapter::CheckPolicyL < %d", ret );
	return ret;
	}

// -----------------------------------------------------------------------------
// CTARMDmAdapter::
// 
// -----------------------------------------------------------------------------
//
TInt CTARMDmAdapter::CheckPolicy2L( const TDesC8& aResource )
	{
	RDEBUG( "CTARMDmAdapter::CheckPolicy2L >" );
	TInt ret = KErrNone;
	
    TRequestContext context;
    TResponse response;

	// Get Certificate
    RDMCert dmcert;
    TCertInfo ci;
    ret = dmcert.Get( ci );

    // If got certificate then put is as subject to policy request
	if (ret == KErrNone)
		{
	    context.AddSubjectAttributeL( PolicyEngineXACML::KTrustedSubject, ci );
		}
	else if (ret == KErrNotFound)
		{
		ret = KErrNone;
		}
//sf-    User::LeaveIfError( ret );

	// Check Policy
	if (ret == KErrNone)
		{
	    context.AddResourceAttributeL( 
	        PolicyEngineXACML::KResourceId, 
	        aResource,
	        PolicyEngineXACML::KStringDataType );
		ret = iPR.MakeRequest( context, response );
		}
//sf-    User::LeaveIfError( ret );

	// Check Policy request result
	if (ret == KErrNone)
		{
    	TResponseValue resp = response.GetResponseValue();
	    switch( resp )
	        {
		    case EResponsePermit:
	        	ret = KErrNone;
		        break;
	        case EResponseDeny:
		    case EResponseNotApplicable:
		    case EResponseIndeterminate:
		    default:
	    	    ret = KErrAccessDenied;
	    	    break;
			}
		}

    RDEBUG_2( "CTARMDmAdapter::CheckPolicy2L < %d", ret );
	return ret;
	}

// -----------------------------------------------------------------------------
// xxx::
// 
// -----------------------------------------------------------------------------
//

// ========================== OTHER EXPORTED FUNCTIONS =========================

// -----------------------------------------------------------------------------
// ?function_name implements...
// ?implementation_description.
// Returns: ?value_1: ?description
//          ?value_n: ?description
//                    ?description
// -----------------------------------------------------------------------------
//
//?type  ?function_name(
//    ?arg_type arg,  // ?description
//    ?arg_type arg )  // ?description
//    {
//
//    ?code
//
//    }

// End of File