/*
* 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 <e32svr.h>
#include <featmgr.h>
#include <bldvariant.hrh>

#include "CentRepToolClientServer.h"
#include "CentRepToolClient.h"


#include "debug.h"


// Standard server startup code
// 
static TInt StartServer()
	{
	RDEBUG("CentRepToolServer: Starting server...");
	
	const TUidType serverUid(KNullUid,KNullUid,KCentRepToolServerUid);

	// 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(KCentRepToolServerImg,KNullDesC);

	if (r!=KErrNone)
		{
		RDEBUG_2("CenrRepToolClient: 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("CentRepToolClient: 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 RCentRepTool::Connect()
	{
	TRAPD( err, FeatureManager::InitializeLibL() );
	if( err != KErrNone )
		{
		return err;
		}
				
	TBool iSupported = FeatureManager::FeatureSupported( KFeatureIdSapPolicyManagement);
	FeatureManager::UnInitializeLib();	    
	
	if( !iSupported )
		{
		return KErrNotSupported;
		}	
	
	TInt retry=2;
	for (;;)
		{
		TInt r=CreateSession(KCentRepToolServerName,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 RCentRepTool::Close()
	{
	RSessionBase::Close();  //basecall
	}
	
EXPORT_C TInt RCentRepTool::CheckCommitState()
{
	return SendReceive( ECheckCommitState, TIpcArgs());	
}

EXPORT_C TInt RCentRepTool::PerformRFS()
{
	return SendReceive( EPerformCentRepToolRFS);	
}


EXPORT_C RSettingManagement::RSettingManagement()
	: iConnected( EFalse)
{
}

EXPORT_C TInt RSettingManagement::Open( TUid aRepositoryId, RCentRepTool &aServer)
{
	TPckg<TUid> uidPack( aRepositoryId);
	TInt err = CreateSubSession( aServer, ECreateRepositorySubSession, TIpcArgs( &uidPack, NULL));
	
	if ( err == KErrNone )
	{
		iConnected = ETrue;
	}
	
	return err;
}
		
EXPORT_C void RSettingManagement::Close()
{
	RSubSessionBase::CloseSubSession(ECloseRepositorySubSession);
}

EXPORT_C void RSettingManagement::InitSession( TRequestStatus& iRequestStatus)
{
	SendReceive( EInitRepositorySession, iRequestStatus);	
}

		
		
EXPORT_C TInt RSettingManagement::SetSIDWRForSetting( TUint32 aSettingId, TUid aSecurityId)
{
	TPckg<TUint32> settingPack( aSettingId);
	TPckg<TUid> securityIdPack( aSecurityId);
	return SendReceive( ESetSIDWRForSetting, TIpcArgs(&settingPack, &securityIdPack));	
}

EXPORT_C TInt RSettingManagement::SetSIDWRForMask( TUint32 aCompareValue, TUint32 aMask, TUid aSecurityId)
{
	TPckg<TUint32> comparePack( aCompareValue);
	TPckg<TUint32> maskPack( aMask);
	TPckg<TUid> securityIdPack( aSecurityId);
	return SendReceive( ESetSIDWRForMask, TIpcArgs(&comparePack, &maskPack, &securityIdPack));	
}

EXPORT_C TInt RSettingManagement::RestoreSetting( TUint32 aSettingId)
{
	TPckg<TUint32> settingPack( aSettingId);
	return SendReceive( ERestoreSetting, TIpcArgs(&settingPack));	
}

EXPORT_C TInt RSettingManagement::RestoreMask( TUint32 aCompareValue, TUint32 aMask)
{
	TPckg<TUint32> comparePack( aCompareValue);
	TPckg<TUint32> maskPack( aMask);;
	return SendReceive( ERestoreMask, TIpcArgs(&comparePack, &maskPack));	
}

EXPORT_C TInt RSettingManagement::AddSIDWRForDefaults( TUid aSecurityId)
{
	TPckg<TUid> securityIdPack( aSecurityId);
	return SendReceive( EAddSIDWRForDefaults, TIpcArgs(&securityIdPack));	
}

EXPORT_C TInt RSettingManagement::RestoreDefaults()
{
	return SendReceive( ERestoreDefaults, TIpcArgs());	
}

EXPORT_C TInt RSettingManagement::Flush()
{
	return SendReceive( EFlushRepository, TIpcArgs());	
}


EXPORT_C TInt RSettingManagement::SetSIDWRForRange( TUint32 aRangeStart, TUint32 aRangeEnd, TUid aSecurityId)
{
	TPckg<TUint32> rangeStartPack( aRangeStart);
	TPckg<TUint32> rangeEndPack( aRangeEnd);
	TPckg<TUid> securityIdPack( aSecurityId);
	return SendReceive( ESetSIDWRForRange, TIpcArgs(& rangeStartPack, &rangeEndPack, &securityIdPack));	
}


EXPORT_C TInt RSettingManagement::RestoreRange( TUint32 aRangeStart, TUint32 aRangeEnd)
{
	TPckg<TUint32> rangeStartPack( aRangeStart);
	TPckg<TUint32> rangeEndPack( aRangeEnd);
	return SendReceive( ERestoreRange, TIpcArgs(& rangeStartPack, &rangeEndPack));	
}


EXPORT_C TInt RSettingManagement::RemoveBackupFlagForMask( TUint32 aCompareValue, TUint32 aMask)
{
	TPckg<TUint32> comparePack( aCompareValue);
	TPckg<TUint32> maskPack( aMask);;
	return SendReceive( ERemoveBackupFlagForMask, TIpcArgs(&comparePack, &maskPack));	
}

EXPORT_C TInt RSettingManagement::RestoreBackupFlagForMask( TUint32 aCompareValue, TUint32 aMask)
{
	TPckg<TUint32> comparePack( aCompareValue);
	TPckg<TUint32> maskPack( aMask);;
	return SendReceive( ERestoreBackupFlagForMask, TIpcArgs(&comparePack, &maskPack));	
}

EXPORT_C TInt RSettingManagement::RemoveBackupFlagForRange( TUint32 aRangeStart, TUint32 aRangeEnd)
{
	TPckg<TUint32> rangeStartPack( aRangeStart);
	TPckg<TUint32> rangeEndPack( aRangeEnd);
	return SendReceive( ERemoveBackupFlagForRange, TIpcArgs( &rangeStartPack, &rangeEndPack));	
}

EXPORT_C TInt RSettingManagement::RestoreBackupFlagForRange( TUint32 aRangeStart, TUint32 aRangeEnd)
{
	TPckg<TUint32> rangeStartPack( aRangeStart);
	TPckg<TUint32> rangeEndPack( aRangeEnd);
	return SendReceive( ERestoreBackupFlagForRange, TIpcArgs( &rangeStartPack, &rangeEndPack));	
}


EXPORT_C TInt RSettingManagement::RemoveBackupFlagForDefaults()
{
	return SendReceive( ERemoveBackupFlagForDefaults, TIpcArgs());	
}

EXPORT_C TInt RSettingManagement::RestoreBackupFlagForDefaults()
{
	return SendReceive( ERestoreBackupFlagForDefaults, TIpcArgs());	
}

EXPORT_C TInt RAccessCheck::Open( TUid aRepositoryId, RCentRepTool &aServer)
{
	TPckg<TUid> uidPack( aRepositoryId);
	TInt err = CreateSubSession( aServer, ECreateCheckAccessSession, TIpcArgs( &uidPack, NULL));
	
	return err;
}
		
EXPORT_C void RAccessCheck::Close()
{
	RSubSessionBase::CloseSubSession(ECloseCheckAcceessSession);
}


EXPORT_C TInt RAccessCheck::CheckAccess( TUint32 aSettingId, TAccessType aAccessType, TBool& aAccessValue)
{
	TPckg<TUint32> idPack( aSettingId);
	TPckg<TAccessType> atPack( aAccessType);
	TPckg<TBool> boolPack( aAccessValue);

	return SendReceive( ECheckAccess, TIpcArgs( &idPack, &atPack, &boolPack));		
}