/*

* 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 "DMUtilSession.h"

#include "ACLStorage.h"

#include "DMUtilServer.h"

#include "policymnginternalpskeys.h"

#include "debug.h"

#include "CentRepToolClient.h"

#include <e32svr.h>

#include <centralrepository.h>

#include <coreapplicationuisdomainpskeys.h>

#include <e32property.h>

#include <f32file.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif //RD_MULTIPLE_DRIVEs

// CONSTANTS

#ifndef RD_MULTIPLE_DRIVE

const TUint8 KMMCDriveLetter = 'e';

#endif

_LIT( MDriveColon, ":");

_LIT( KMMCEraseFlagFileName, "fmmc.dat");

// MACROS

// DATA TYPES

// FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// DMUtilSession.cpp

//

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

// CDMUtilSession::CDMUtilSession

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

CDMUtilSession::CDMUtilSession()

	{

	RDEBUG("CDMUtilSession::CDMUtilSession");

	}

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

// CDMUtilSession::Server

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

CDMUtilServer& CDMUtilSession::Server()

	{

	return *static_cast<CDMUtilServer*>(const_cast<CServer2*>(CSession2::Server()));

	}

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

// CDMUtilSession::CreateL

// 2nd phase construct for sessions - called by the CServer framework

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

void CDMUtilSession::CreateL()

{

	RDEBUG("CDMUtilSession::CreateL");

	iACLStorage = CDMUtilServer::ACLStorage();

}

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

// CDMUtilSession::~CDMUtilSession

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

CDMUtilSession::~CDMUtilSession()

{

	RDEBUG("CDMUtilSession::~CDMUtilSession");

}

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

// CDMUtilSession::PerformRFS

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

TInt CDMUtilSession::PerformRFSL()

{

	RDEBUG("CDMUtilSession: Restory factory setting operation started");

	//RFS tasks in DMUtilServer

	// 1. Update RFS flag status

	// 2. Reset policy management state flags

	//update RFS flag

	CRepository* cenrep = CRepository::NewLC( KCRUidPolicyManagementUtilInternalKeys);

	TInt currentValue = 0;

	TInt err = cenrep->Get( KRFSCounterKey, currentValue);

	if ( err == KErrNone)

	{

		cenrep->Set( KRFSCounterKey, ++currentValue);

		RProperty::Set( KPolicyMngProperty, KFactoryResetCounter, currentValue);

	}

	//reset policy management state flags

	cenrep->Set( KPolicyChangeCounter, 0);

	RProperty::Set( KPolicyMngProperty, KPolicyChangedCounter, 0);

	cenrep->Set( KTerminalSecurityStateKey, 0);

	SetIndicatorStateL( cenrep);

	CleanupStack::PopAndDestroy( cenrep);

	RDEBUG("CDMUtilSession: Restory factory setting operation finished");

	return KErrNone;

}

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

// CDMUtilSession::ServiceL

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

void CDMUtilSession::ServiceL(const RMessage2& aMessage)

{

    TRAPD(err,DispatchMessageL(aMessage));

	aMessage.Complete(err);

}

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

// CDMUtilSession::DispatchMessageL

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

void CDMUtilSession::DispatchMessageL(const RMessage2& aMessage)

{

	RDEBUG_2("CDMUtilSession::ServiceL; %d",aMessage.Function());

	switch ( aMessage.Function())

	{

		case ERemoveACL:

		case ESetACL:

		case EAddACL:

		{

			//read URI... 

			//check for aMessage Length if message length is negative

			//then leave the Dispatch MessageL with KErrUnderFlow

			TInt minlength = aMessage.GetDesLength(0);

			if(minlength < 0)

			User::Leave(KErrUnderflow);

			HBufC8* uri = HBufC8::NewLC( aMessage.GetDesLength(0));

			TPtr8 uriPtr = uri->Des();

			aMessage.ReadL(0, uriPtr, 0);

			if ( aMessage.Function() == ERemoveACL )

			{

				RDEBUG("	DispatchMessageL case ERemoveACL");

				TBool restoreDefaults;

				TPckg<TBool> restoreDefaultsPack( restoreDefaults);

				aMessage.ReadL( 1, restoreDefaultsPack, 0);

				iACLStorage->RemoveACL( *uri, restoreDefaults);

			}

			else

			{

				//destination

				TACLDestination dest;

				TPckg<TACLDestination> destPack( dest);

				aMessage.ReadL(1, destPack, 0);

				//ACL commands

				TAclCommands command;

				TPckg<TAclCommands> commandPack( command);

				aMessage.ReadL(2, commandPack, 0);

				if ( aMessage.Function() == ESetACL)

				{

					RDEBUG("	DispatchMessageL case ESetACL");

					iACLStorage->SetACLForNodeL( *uri, dest, command);

				}

				else

				{

					RDEBUG("	DispatchMessageL case EAddACL");

					iACLStorage->AddACLForNodeL( *uri, dest, command);

				}

			}

			CleanupStack::PopAndDestroy( uri);

		}

		break;

		case EMngSessionCertificate:

		{

			RDEBUG("	DispatchMessageL case EMngSessionCertificate");

			//certificate information

			TCertInfo certInfo;

			TPckg<TCertInfo> certInfoPack( iACLStorage->MngSessionCertificate());

			aMessage.ReadL(0, certInfoPack, 0);	

		}

		break;

		case ENewDMSession:

		{

			TInt minlength = aMessage.GetDesLength(1);

			if(minlength < 0)

			User::Leave(KErrUnderflow);

			RDEBUG("	DispatchMessageL case ENewDMSession");

			//certificate information

			TCertInfo certInfo;

			TPckg<TCertInfo> certInfoPack( certInfo);

			aMessage.ReadL(0, certInfoPack, 0);

			//certificate information

			TPtr8 serverid = HBufC8::NewLC( aMessage.GetDesLength(1))->Des();

			aMessage.ReadL(1, serverid, 0);

			iACLStorage->NewSessionL( certInfo, serverid);

			CleanupStack::PopAndDestroy();	//HBufC8

		}

		break;

		case EFlush:

			{

			RDEBUG("	DispatchMessageL case EFlush");

			iACLStorage->SaveACLL();

			}

		break;

	    case EGetDMSessionCertInfo:

        {

        	RDEBUG("	DispatchMessageL case EGetDMSessionCertInfo");

        	//get cert info

	        TCertInfo certInfo;

	        User::LeaveIfError( Server().ACLStorage()->CertInfo( certInfo ) );

			//write cert info to client side

			TPckg<TCertInfo> certInfoPack( certInfo );

			aMessage.WriteL(0, certInfoPack );

        }

	    break;

		case EGetDMSessionServerId:

		{

			RDEBUG("	DispatchMessageL case EGetDMSessionServerId");

			//get server id

			HBufC8 * serverid = Server().GetServerIDL();

			CleanupStack::PushL(  serverid);

			//write server id to client side

			aMessage.WriteL(0, *serverid);

			CleanupStack::PopAndDestroy( serverid);

		} 	 

		break;   

		case EUpdatePolicyMngStatusFlags:

	    {

	    	RDEBUG("	DispatchMessageL case EUpdatePolicyMngStatusFlags");

			KPolicyMngStatusFlags policyMngStatus;

			TPckg<KPolicyMngStatusFlags> policyMngStatusPack( policyMngStatus);

			aMessage.ReadL(0, policyMngStatusPack, 0);

	    	UpdateStatusFlagsL( policyMngStatus);

	    }

	    break;	    

		case EPerformDMUtilRFS:

		{

			RDEBUG("	DispatchMessageL case EPerformDMUtilRFS");

			PerformRFSL();

		}

	    break;

		case EMarkMMCWipe:

				{

				MarkMMCWipeL();

				}

		default:

		break;

    }

}

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

// CDMUtilServer::UpdateStatusFlagsL

// Define publish&subscribe properties

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

void CDMUtilSession::UpdateStatusFlagsL( KPolicyMngStatusFlags aUpdateCommand)

{

	RDEBUG("CDMUtilSession::UpdateStatusFlagsL()");

	//set initial values for properties

	CRepository* cenrep = CRepository::NewLC( KCRUidPolicyManagementUtilInternalKeys);

	switch ( aUpdateCommand )

	{

		case EPolicyChanged:

		{

			RDEBUG("		UpdateStatusFlagsL() case EPolicyChanged");

			TInt currentValue = 0;

			User::LeaveIfError( cenrep->Get( KPolicyChangeCounter, currentValue));

			User::LeaveIfError( cenrep->Set( KPolicyChangeCounter, ++currentValue));

			User::LeaveIfError( RProperty::Set( KPolicyMngProperty, KPolicyChangedCounter, currentValue));

		}

		break;	

		case ETerminalSecurityActive:

			RDEBUG("		UpdateStatusFlagsL() case ETerminalSecurityActive");

			User::LeaveIfError( cenrep->Set( KTerminalSecurityStateKey, 1));

			SetIndicatorStateL( cenrep);

		break;

		case ETerminalSecurityDeactive:

			RDEBUG("		UpdateStatusFlagsL() case ETerminalSecurityDeactive");

			User::LeaveIfError( cenrep->Set( KTerminalSecurityStateKey, 0));

			SetIndicatorStateL( cenrep);

		break;

		default:

		break;

	}

	CleanupStack::PopAndDestroy( cenrep);

}

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

// CDMUtilServer::UpdateSessionInfoL

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

void CDMUtilSession::SetIndicatorStateL( CRepository * aCenRep)

{

	RDEBUG8_2("CDMUtilSession::SetIndicatorStateL() 0x%x", aCenRep);

	//get terminal security and management state from centrep

	TInt terminalSecurity = 0;

	TInt err( KErrNone );

	if ( !aCenRep)

		{

		CRepository* rep = CRepository::NewLC( KCRUidPolicyManagementUtilInternalKeys);				

		err = rep->Get( KTerminalSecurityStateKey, terminalSecurity);

		RDEBUG8_2("CDMUtilSession::SetIndicatorStateL aCenRep not found ERROR: %d",err);

		CleanupStack::PopAndDestroy( rep);

		}

	else

		{

		err = aCenRep->Get( KTerminalSecurityStateKey, terminalSecurity);

		RDEBUG8_2("CDMUtilSession::SetIndicatorStateL aCenRep ERROR: %d",err);

		}

	//set indicator state...

	if ( CDMUtilServer::iManagementActive )			

		{

		RDEBUG(" iManagementActive is ETrue -> ECoreAppUIsTarmMngActiveIndicatorOn");

		err = RProperty::Set( KPSUidCoreApplicationUIs, KCoreAppUIsTarmIndicator, ECoreAppUIsTarmMngActiveIndicatorOn);	

		}

	else if ( terminalSecurity )

		{

		RDEBUG(" terminalSecurity is ETrue -> ECoreAppUIsTarmTerminalSecurityOnIndicatorOn");

		err = RProperty::Set( KPSUidCoreApplicationUIs, KCoreAppUIsTarmIndicator, ECoreAppUIsTarmTerminalSecurityOnIndicatorOn);	

		}

	else

		{

		RDEBUG(" terminalSecurity is EFalse -> ECoreAppUIsTarmIndicatorsOff");

		err = RProperty::Set( KPSUidCoreApplicationUIs, KCoreAppUIsTarmIndicator, ECoreAppUIsTarmIndicatorsOff);	

		}	

	if( err != KErrNone )

		{

		RDEBUG8_2("CDMUtilSession::SetIndicatorStateL ERROR: %d",err);

		}

	RDEBUG("CDMUtilSession::SetIndicatorStateL() - END");

}

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

// CDMUtilServer::DefineProperties

// Define publish&subscribe properties

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

void CDMUtilSession::DefinePropertiesL()

{

	RDEBUG("CDMUtilSession::DefinePropertiesL()");

	//define properties...

	TInt err = RProperty::Define( KPolicyMngProperty, KPolicyChangedCounter, RProperty::EInt);

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

	{

		User::Leave( err);

	}

	err = RProperty::Define( KPolicyMngProperty, KFactoryResetCounter, RProperty::EInt);

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

	{

		User::Leave( err);

	}

	//set initial values for properties

	CRepository* cenrep = CRepository::NewLC( KCRUidPolicyManagementUtilInternalKeys);

	//policy change counter

	TInt value = 0;

	err = cenrep->Get( KPolicyChangeCounter, value);

	if ( err == KErrNotFound)

	{

		User::LeaveIfError( cenrep->Create( KPolicyChangeCounter, value));

	}

	User::LeaveIfError( RProperty::Set( KPolicyMngProperty, KPolicyChangedCounter, 0));

	//policy change counter

	value = 0;

	err = cenrep->Get( KRFSCounterKey, value);

	if ( err == KErrNotFound)

	{

		User::LeaveIfError( cenrep->Create( KRFSCounterKey, value));

	}

	User::LeaveIfError( RProperty::Set( KPolicyMngProperty, KFactoryResetCounter, 0));

	//terminal security active

	err = cenrep->Get( KTerminalSecurityStateKey, value);

	if ( err == KErrNotFound)

	{

		User::LeaveIfError( cenrep->Create( KTerminalSecurityStateKey, 0));

	}

	CDMUtilSession::SetIndicatorStateL( cenrep);

	CleanupStack::PopAndDestroy( cenrep);

}

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

// CDMUtilSession::ServiceError

// Handle an error from CDMUtilSession::ServiceL()

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

void CDMUtilSession::ServiceError(const RMessage2& aMessage,TInt aError)

	{

	RDEBUG_2("CDMUtilSession::ServiceError %d",aError);

	CSession2::ServiceError(aMessage,aError);

	}

void CDMUtilSession::MarkMMCWipeL()

	{

	RDEBUG("CDMUtilSession::MarkMMCWipeL()");

	RFs rfs;

	User::LeaveIfError( rfs.Connect() );

	CleanupClosePushL( rfs );	

	// create private directory to MMC

#ifndef RD_MULTIPLE_DRIVE

	TInt err = rfs.CreatePrivatePath( EDriveE );

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

		{

		RDEBUG_2("	**** ERROR, can not create private path on MMC drive: %d", err );

		User::Leave( err );

		}

	TFileName fullPath;

	fullPath.Append( KMMCDriveLetter );

	fullPath.Append( MDriveColon );

	TFileName privatePath;

	User::LeaveIfError( rfs.PrivatePath( privatePath ) );

	fullPath.Append( privatePath );

	fullPath.Append( KMMCEraseFlagFileName );

	RFile file;

	// it is ok to leave if the file already exists

	User::LeaveIfError( file.Create( rfs, fullPath, EFileWrite ) );

	file.Close();

#else

	TDriveList driveList;

	TInt driveCount;

	//Get all removeable drive, both physically and logically

	User::LeaveIfError(DriveInfo::GetUserVisibleDrives(

            rfs,  driveList,  driveCount, KDriveAttRemovable ));

    TInt max(driveList.Length());

    for(TInt i=0; i<max;++i)

    {

    	if (driveList[i])

    	{

    		TUint status;

    		DriveInfo::GetDriveStatus(rfs, i, status);

    		//To make sure the drive is physically removeable not logically removeable	

    		//need to format internal mass memory also. So no need to check the below condition

    	//	if (status & DriveInfo::EDriveRemovable)

    		{

    			TInt err = rfs.CreatePrivatePath( i );

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

				{

					RDEBUG_2("	**** ERROR, can not create private path on MMC drive: %d", err );

					User::Leave( err );

				}

    			TChar driveLetter;

    			rfs.DriveToChar(i,driveLetter);

    			TFileName fullPath;

				fullPath.Append( driveLetter );

				fullPath.Append( MDriveColon );

				TFileName privatePath;

				User::LeaveIfError( rfs.PrivatePath( privatePath ) );

				fullPath.Append( privatePath );

				fullPath.Append( KMMCEraseFlagFileName );

				RFile file;

				// it is ok to leave if the file already exists

				User::LeaveIfError( file.Create( rfs, fullPath, EFileWrite ) );

				file.Close();

    		}

    	}

     }

#endif //RD_MULTIPLE_DRIVE	

	RDEBUG("	MMC format marker file created successfully! MMC wipe enabled.");

	CleanupStack::PopAndDestroy( &rfs );

	}