/*

* Copyright (c) 2000 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

*

*/

// INCLUDES

#include <e32svr.h>

#include <centralrepository.h>

#ifdef __TARM_SYMBIAN_CONVERGENCY

const TUid KUidSmlSyncAgentCategory = { 0x10009F46 }; // temporary

const TUint KHttpsServerCertificateKey = 1234; // temporary

#else

// nothing

#endif

#include <SyncMLClient.h>

#include <SyncMLClientDM.h>

#include "ACLStorage.h"

#include "DMUtilServer.h"

#include "DMUtilSession.h"

#include "debug.h"

// CONSTANTS

/**

    Ranges of policies

*/

const TInt   CDMUtilServer::tcRanges[DMUTILSERVER_NUMBER_OF_POLICIES] = {0, EPerformDMUtilRFS, ERemoveACL};

/**

    Number of elements

*/

const TUint8 CDMUtilServer::tcElementsIndex[DMUTILSERVER_NUMBER_OF_POLICIES] = {0, 1, 2};

/**

    Elements for each range

*/    

const CPolicyServer::TPolicyElement CDMUtilServer::tcElements[DMUTILSERVER_NUMBER_OF_POLICIES] =

	    {

        { _INIT_SECURITY_POLICY_PASS },

        { _INIT_SECURITY_POLICY_S0(0x102073EA) },	// RFs SID

        { _INIT_SECURITY_POLICY_S0(0x10207814) }

	    };

/**

    The policy 

*/

CPolicyServer::TPolicy CDMUtilServer::iTcConnectionPolicy =

    {

        CPolicyServer::ECustomCheck, // On connection, check for policies

        1,

        tcRanges,

        tcElementsIndex,

        tcElements

    };

// MACROS

#define __INCLUDE_CAPABILITY_NAMES__

// DATA TYPES

// FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

CACLStorage* CDMUtilServer::iACLs = 0;

TBool CDMUtilServer::iManagementActive = EFalse;

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

// Server startup code

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

static void RunServerL()

	{

	// naming the server thread after the server helps to debug panics

	//User::LeaveIfError(RThread().Rename(KDMUtilServerName));   //Deprecated! Replace this with the line below as soon as possible

	User::LeaveIfError(User::RenameThread(KDMUtilServerName)); //Correct PlatSec function, not available until week 2004_32

	// create and install the active scheduler

	CActiveScheduler* s=new(ELeave) CActiveScheduler;

	CleanupStack::PushL(s);

	CActiveScheduler::Install(s);

	// create the server (leave it on the cleanup stack)

	CDMUtilServer::NewLC();

	// Initialisation complete, now signal the client

	RProcess::Rendezvous(KErrNone);

	// Ready to run

	RDEBUG("DMUtilServer is running");

	CActiveScheduler::Start();

	RDEBUG("DMUtilServer has stopped");

	// Cleanup the server and scheduler

	CleanupStack::PopAndDestroy(2);

	}

// Server process entry-point

TInt E32Main()

	{

	__UHEAP_MARK;

	RDEBUG("DMUtilServer: E32Main");

	CTrapCleanup* cleanup=CTrapCleanup::New();

	TInt r=KErrNoMemory;

	if (cleanup)

		{

		TRAP(r,RunServerL());

		RDEBUG_2("DMUtilServer closed with code: %d", r);

		delete cleanup;

		}

	__UHEAP_MARKEND;

	return r;

	}

// RMessagePtr2::Panic() also completes the message. This is:

// (a) important for efficient cleanup within the kernel

// (b) a problem if the message is completed a second time

void PanicClient(const RMessagePtr2& aMessage,TDMUtilPanic aPanic)

	{

	_LIT(KPanic,"DMUtilServer");

	aMessage.Panic(KPanic,aPanic);

	}

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

// CDMUtilServer

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

CDMUtilServer::CDMUtilServer()

	:CPolicyServer(0, 

    iTcConnectionPolicy,

	ESharableSessions),

	iServerID(0)

	{

	}

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

// CDMUtilServer::CertificateChangedL

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

void CDMUtilServer::CertificateChangedL()

    {

    RDEBUG("DMUtilServer: CDMUtilServer::CertificateChangedL");

    TRAPD( reason, UpdateSessionInfoL() );

    if( KErrNone != reason )

        {

        RDEBUG("DMUtilServer: ERROR Failed to update certificate!");

        iACLs->CloseSession();

		iManagementActive = EFalse;

        CDMUtilSession::SetIndicatorStateL( 0 );

        }

    else

        {

        RDEBUG("DMUtilServer: Starting new session, updating ACLs");

        UpdateACLsL();

        }

    }

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

// CDMUtilServer::NotifierErrorL

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

void CDMUtilServer::NotifierErrorL( TInt aCode )

    {

    RDEBUG_2("CDMUtilServer::NotifierErrorL Certificate notifier error %d", aCode);

    if( KErrAbort == aCode )

        {

        RDEBUG("**** DMUtilServer::NotifierErrorL KErrAbort == aCode");

        iNotifier.StartL( this );

        }

    }

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

// CDMUtilServer::NewLC

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

CServer2* CDMUtilServer::NewLC()

	{    

	RDEBUG("CDMUtilServer::NewLC - start");

	CDMUtilServer* self=new(ELeave) CDMUtilServer;

	CleanupStack::PushL(self);

	self->ConstructL();

	RDEBUG("CDMUtilServer::NewLC - end");

	return self;

	}

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

// CDMUtilServer::~CDMUtilServer

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

CDMUtilServer::~CDMUtilServer()

	{

	RDEBUG("CDMUtilServer::~CDMUtilServer()");

    delete iServerID; iServerID=0;

    delete iACLs;

	}

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

// CDMUtilServer::ConstructL

// 2nd phase construction - ensure the timer and server objects are running

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

void CDMUtilServer::ConstructL()

	{

	RDEBUG("CDMUtilServer::ConstructL");

	StartL(KDMUtilServerName);

	CDMUtilSession::DefinePropertiesL();

    iACLs = CACLStorage::NewL();

    TRAPD( reason, UpdateSessionInfoL() );

    if( KErrNone != reason )

        {

        RDEBUG("DMUtilServer: Failed to update certificate");

        }

    else

        {

        RDEBUG("	CDMUtilServer::ConstructL	UPDATING ACLs ....");

        UpdateACLsL();

        RDEBUG("	CDMUtilServer::ConstructL	UPDATING ACLs ....DONE!");

        }

    iNotifier.StartL( this );

    }

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

// CDMUtilServer::UpdateSessionInfoL

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

void CDMUtilServer::UpdateSessionInfoL()

    {

	RDEBUG("CDMUtilServer::UpdateSessionInfoL");

    TPckg<TCertInfo> certp( iCertInfo );

    certp.Fill( TChar(0) );

    delete iServerID; iServerID=0;

    iServerID = GetServerIDL();

    if( iServerID != 0 )

        {

        if( KErrNone != GetCertFromCentRep() )

            {

            RDEBUG("**** CDMUtilServer::UpdateSessionInfoL - unable to get certificate from cenrep");

            delete iServerID; iServerID=0;

            }

        else

        	{

        	if ( IsSilentModeAllowed() )

            	{

            	iManagementActive = ETrue;

            	}

			CDMUtilSession::SetIndicatorStateL(0);

            }

        }

    }

CACLStorage * CDMUtilServer::ACLStorage()

	{

	return iACLs;

	}

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

// CDMUtilServer::GetServerIDL

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

HBufC8* CDMUtilServer::GetServerIDL()

    {

    HBufC8* serverId = NULL;

	TRAPD( err, serverId = GetServerIDFromSyncMLSessionL() );

	if( err == KErrNone )

		{

		return serverId;

		}

	serverId = GetServerIDFromLocalCacheL();

	if( serverId == NULL )

		{

		User::Leave( KErrNotFound );

		}

	return serverId;

    }

HBufC8* CDMUtilServer::GetServerIDFromSyncMLSessionL()

	{

#ifdef __TARM_SYMBIAN_CONVERGENCY

	RDEBUG("CDMUtilServer::GetServerIDFromSyncMLSessionL() ......");

    HBufC8* serverIdStr = 0;

	RSyncMLSession ses;

	ses.OpenL();

	CleanupClosePushL( ses );

	TSmlJobId jid;

	TSmlUsageType jtype;

    ses.CurrentJobL( jid, jtype );

    RSyncMLDevManJob job;

    job.OpenL( ses, jid );

    CleanupClosePushL( job );

	TSmlProfileId pid( job.Profile() );

	RSyncMLDevManProfile profile;

	profile.OpenL( ses, pid );

	CleanupClosePushL( profile );

	serverIdStr = profile.ServerId().AllocL();

	CleanupStack::PopAndDestroy( &profile );

	CleanupStack::PopAndDestroy( &job );

	CleanupStack::PopAndDestroy( &ses );

	RDEBUG("CDMUtilServer::GetServerIDFromSyncMLSessionL ......DONE!");

	return serverIdStr;

#else

RDEBUG("CDMUtilServer::GetServerIDFromSyncMLSessionL ......");

    HBufC8* serverIdStr = 0;

	RSyncMLSession ses;

	ses.OpenL();

	CleanupClosePushL( ses );

	TSmlJobId jid;

	TSmlUsageType jtype;

    ses.CurrentJobL(jid, jtype );

    RSyncMLDevManJob job;

    job.OpenL( ses, jid );

    CleanupClosePushL( job );

    TSmlProfileId pid( job.Profile() );

    RSyncMLDevManProfile prof;

    prof.OpenL( ses, pid, ESmlOpenRead );

    CleanupClosePushL( prof );

	serverIdStr = prof.ServerId().AllocL();

	CleanupStack::PopAndDestroy( &prof );

	CleanupStack::PopAndDestroy( &job );

	CleanupStack::PopAndDestroy( &ses );

	RDEBUG("CDMUtilServer::GetServerIDFromSyncMLSessionL ......DONE!");

	return serverIdStr;

#endif

	}

HBufC8* CDMUtilServer::GetServerIDFromLocalCacheL()

	{

	RDEBUG("CDMUtilServer::GetServerIDFromLocalCacheL ......");

	if( iServerID )

		{

		RDEBUG("CDMUtilServer::GetServerIDFromLocalCacheL ......DONE!");

		return iServerID->AllocL();

		}

	RDEBUG("CDMUtilServer::GetServerIDFromLocalCacheL ...... **** NOT FOUND!");

	return NULL;

	}

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

// CDMUtilServer::GetCertFromCentRep

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

TInt CDMUtilServer::GetCertFromCentRep()

    {

	RDEBUG("CDMUtilServer::GetCertFromCentRep");

	TInt result = KErrNone;

#ifdef __TARM_SYMBIAN_CONVERGENCY

	result = iNotifier.GetCert( iCertInfo );

	if ( result != KErrNone ) 

		{

		RDEBUG_2("**** CDMUtilServer::GetCertFromCentRep ... NOT FOUND: %d", result );

		result = KErrNotFound;

		}

#else	

    TCertInfo info;

	CRepository *rep = NULL;

	TRAP( result, rep = CRepository::NewL ( KCRUidPolicyManagementUtilInternalKeys ) );

	if (result == KErrNone )

		{

		TPckg<TCertInfo> pcert( iCertInfo );

		TInt len( 0 );

		result = rep->Get( KSyncMLSessionCertificate, pcert, len );

		delete rep;

		if ( len == 0 ) 

			{

			RDEBUG("**** CDMUtilServer::GetCertFromCentRep ... NOT FOUND");

			result = KErrNotFound;

			}

		}

#endif	

	return result;

    }

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

// CDMUtilServer::IsSilentModeAllowed

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

TBool CDMUtilServer::IsSilentModeAllowed()

    {

	RDEBUG("CDMUtilServer::IsSilentModeAllowed()");

	CRepository *rep = NULL;

    TInt result = KErrNone;

	TRAP( result, rep = CRepository::NewL ( KCRUidPolicyManagementUtilInternalKeys ) );

	if (result == KErrNone )

		{

		TInt state( 0 );

		result = rep->Get( KSyncMLForcedCertificateCheckKey, state );

		delete rep;

		if ( state == 1 ) 

			{

			RDEBUG("CDMUtilServer::IsSilentModeAllowed ... allowed");

			return ETrue;

			}

		else

			{

			RDEBUG("CDMUtilServer::IsSilentModeAllowed ... NOT allowed");

			}

		}

	return EFalse;

    }

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

// CDMUtilServer::UpdateACLs

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

TInt CDMUtilServer::UpdateACLsL()

    {

    RDEBUG("CDMUtilServer::UpdateACLsL()");

    if( NULL != iServerID )

        {

        TRAPD( reason, iACLs->NewSessionL( iCertInfo, *iServerID ) );

        RDEBUG8_3("CDMUtilServer::UpdateACLs() ... iACLs->NewSessionL = %S with error: %d", &iServerID, reason);

        return reason;

        }

    else

        {

       	iACLs->CloseSession();

	   	iManagementActive = EFalse;

       	CDMUtilSession::SetIndicatorStateL( 0 );

        }

    return KErrNone;

    }

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

// CDMUtilServer::NewSessionL

// Create a new client session. This should really check the version number.

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

CSession2* CDMUtilServer::NewSessionL(const TVersion&,const RMessage2&) const

	{

	RDEBUG("CDMUtilServer::NewSessionL");

	return new (ELeave) CDMUtilSession();

	}

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

// CDMUtilServer::CustomSecurityCheckL

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

CPolicyServer::TCustomResult CDMUtilServer::CustomSecurityCheckL(const RMessage2& /*aMsg*/, TInt& /*aAction*/, TSecurityInfo& /*aMissing*/)

	{

	RDEBUG("CDMUtilServer::CustomSecurityCheckL");

	return EPass;

	}

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

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

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

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

// CDMCertNotifier::CDMCertNotifier

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

CDMCertNotifier::CDMCertNotifier()

    : CActive( EPriorityStandard )

    , iCallback( 0 )

#ifdef __TARM_SYMBIAN_CONVERGENCY  

// nothing

#else    

    , iRepository(0)

#endif    

    {

	RDEBUG("CDMCertNotifier::CDMCertNotifier - start");

    CActiveScheduler::Add( this );

#ifdef __TARM_SYMBIAN_CONVERGENCY //  

    TInt err = iCertificateProperty.Attach( KUidSmlSyncAgentCategory, KHttpsServerCertificateKey );

    RDEBUG_2("CDMCertNotifier::CDMCertNotifier() - Attached to P&S key with code: %d", err );

    __ASSERT_ALWAYS( err == KErrNone, User::Panic( _L("DMUtilServer P&S attach"), err ) );

#else

// nothing

#endif    

	RDEBUG("CDMCertNotifier::CDMCertNotifier - end");

    }

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

// CDMCertNotifier::~CDMCertNotifier

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

CDMCertNotifier::~CDMCertNotifier()

    {

	RDEBUG("CDMCertNotifier::~CDMCertNotifier");

#ifdef __TARM_SYMBIAN_CONVERGENCY  

	iCertificateProperty.Close();

#else

	delete iRepository; 

    iRepository = 0;