// Copyright (c) 2010 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:

// Implements backup and restore support for the Bluetooth Manager server.

//

#include <e32std.h>

#include <e32base.h>

#include <e32property.h>

#include <f32file.h>

#include <s32file.h>

#include <bluetooth/hci/hciconsts.h>

#include "btmanserverutil.h"

#include "btmanserverburmgr.h"

#include "BTManServer.h"

#include "btmanclient.h"

#include "btdevice.h"

#include <bluetooth/hci/hcitypes.h>

#include <bluetooth/logger.h>

#include "BTSec.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_BT_MANAGER_SERVER);

#endif

/**

Raises an EBTBURMgrInvalidState panic with state information encoded within the panic code.

The first digit denotes the panic code (EBTBURMgrInvalidState).

The second digit is a delimiter and is always 1.

The next two digits represent the expected state

The next digit again is a delimiter and is always 1.

The final two digits represent the actual state. 

For example, the panic code 7101100 indicates an EBTBURMgrInvalidState panic raised because the state

machine is in the EBTBURStateNormal state when it was expected to be in the EBTBURStateBackupRequest state.

**/

void InvalidStatePanic(TBTBURState aExpectedState, TBTBURState aActualState)

	{

	LOG_STATIC_FUNC

	User::Panic(KBTBackupPanicCat, (EBTBURMgrInvalidState*KBTBackupStatePanicMultiplier) + KBTBackupStatePanicMajorDelimiter + (aExpectedState * KBTBackupStateMultiplier) + KBTBackupStatePanicMinorDelimiter + aActualState);

	}

/**

Raises an EBTBURMgrInvalidStateTransition panic with state information encoded within the panic code.

The first digit denotes the panic code (EBTBURMgrInvalidStateTransition).

The second digit is a delimiter and is always 1.

The next two digits represent the expected state

The next digit again is a delimiter and is always 1.

The final two digits represent the actual state. 

For example, the panic code 6101100 indicates an EBTBURMgrInvalidStateTransition panic raised because the state

machine is in the EBTBURStateNormal state when it was expected to be in the EBTBURStateBackupRequest state.

**/

void InvalidStateTransitionPanic(TBTBURState aCurrentState, TBTBUREvent aEvent)

	{

	LOG_STATIC_FUNC

	User::Panic(KBTBackupPanicCat, (EBTBURMgrInvalidStateTransition*KBTBackupStatePanicMultiplier) + KBTBackupStatePanicMajorDelimiter + (aCurrentState * KBTBackupStateMultiplier) + KBTBackupStatePanicMinorDelimiter + aEvent);

	}

/**

CBTManServerBURMgr - Manages backup and restore support for the Bluetooth Manager server.

**/

/**

Constructs a new instance of a CBTManServerBURMgr.

An MBTBURNotify instance may be registered here for notifications. Ownership of the MBTBURNotify instance is not transferred.

@see CBTManServerBURMgr::RequestBURNotification()

**/

CBTManServerBURMgr* CBTManServerBURMgr::NewL(CBTManServer& aBTManServer, MBTBURNotify* aBURNotify, TInt aPriority)

	{

	LOG_STATIC_FUNC

	CBTManServerBURMgr* self = new(ELeave) CBTManServerBURMgr(aBTManServer, aBURNotify, aPriority);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CBTManServerBURMgr::CBTManServerBURMgr(CBTManServer& aBTManServer, MBTBURNotify* aBURNotify, TInt aPriority) 

	: CActive(aPriority), 

	iBTManServer(aBTManServer),  

	iBUROperationStartNotified(EFalse)

	{

	LOG_FUNC

	RequestBURNotification(aBURNotify);

	CActiveScheduler::Add(this);

	}

CBTManServerBURMgr::~CBTManServerBURMgr()

	{

	LOG_FUNC

	Cancel();

	iProperty.Close();

	// Close any open session on BT Manager

	NotifyAnyBUROperationStopped();

	// Members which either hold data or are NULL

	delete iActiveBackupClient;

	delete iActiveBackupDataClient;

	delete iBackupHandler;

	delete iRestoreHandler;

	delete iLocalAddrFetcher;

	// Member that is instantiated for entire lifetime of CBTManServerBURMgr

	delete iStateMachine;

	}

void CBTManServerBURMgr::ConstructL()

	{

	LOG_FUNC

	// Construct state machine

	iStateMachine = CBTManServerBURMgrStateFactory::NewL(*this);

	// Construction counts as a transition into the default state (EBTBURStateNormal) of the state machine.

	// However, since this does nothing if no backup/restore cleanup is required, we do not need to execute the 

	// state action.

	// Setup iProperty to catch BUR flag from Secure Backup Engine

	LEAVEIFERRORL(iProperty.Attach(KUidSystemCategory, KUidBackupRestoreKey));

	// Subscribe to BUR P&S key to catch transitions

	SubscribeToBackupRestoreKey();

	// Also check flag now (it may have already transitioned)

	TInt backupKeyValue = 0;

	LEAVEIFERRORL(iProperty.Get(backupKeyValue));

	TBURPartType backupState = GetBURPartType(backupKeyValue);	

	// If we're not about to perform a restore, check if a restore file exists. If so, try to process restore file.

	// The restore operation may not affect us, or may be postponed. In either case, we try to process the restore file

	// again next time we start.

	if (backupState != EBURRestoreFull && backupState != EBURRestorePartial)

		{

		// Delete any stale backup files

		DeleteBackupFile();

		// See if a restore file needs processing

		CheckForRestoreFileL();

		}

	// Process flag

	ProcessBackupState(backupState);

	}

/**

Translates a given integer obtained from the KUidBackupRestoreKey P&S key to a TBURPartType value.

This will validate the masked value to ensure that it falls within the range of the TBURPartType enum.

In debug builds, a panic will be raised if this value is out of range.

In release builds, EBURUnset is returned if the value is out of range.

**/

TBURPartType CBTManServerBURMgr::GetBURPartType(TInt aValue)

	{

	LOG_FUNC

	switch (aValue & KBURPartTypeMask)

		{

	case EBURUnset:

		return EBURUnset;

	case EBURNormal:

		return EBURNormal;

	case EBURBackupFull:

		return EBURBackupFull;

	case EBURBackupPartial:

		return EBURBackupPartial;

	case EBURRestoreFull:

		return EBURRestoreFull;

	case EBURRestorePartial:

		return EBURRestorePartial;

	default:

		__ASSERT_DEBUG(EFalse, PANIC(KBTBackupPanicCat, EBTBURMgrInvalidBackupRestoreState));

		return EBURUnset;

		}

	}

/**

Attempts to locate a restore file in the private directory of this server.

@return ETrue if the file can be found, EFalse otherwise.

**/

TBool CBTManServerBURMgr::RestoreFilePresent()

	{

	LOG_FUNC

	RFs fsSession;

	TInt err = fsSession.Connect();

	if (err == KErrNone)

		{

		err = fsSession.SetSessionToPrivate(fsSession.GetSystemDrive());

		if (err ==KErrNone)

			{

			TEntry entry;

			err = fsSession.Entry(KBTManServerRestoreFileName, entry);

			}

		fsSession.Close();

		}

	// If restore file was found, err will be KErrNone

	return (err == KErrNone);

	}

/**

Checks for the existence of a restore file. If a restore file is found, then the local device address

is feteched and processing of that restore file is initiated.

**/

void CBTManServerBURMgr::CheckForRestoreFileL()

	{

	LOG_FUNC

	if (RestoreFilePresent())

		{

		// Fetch local address. When this is received, restore file processing will begin.

		iLocalAddrFetcher = CBTLocalAddressFetcher::NewL(*this, iBTManServer.Registry());

		iLocalAddrFetcher->FetchLocalAddress();

		}

	}

/**

Subscribes to the P&S flag provided by the Secure Backup Engine (to receive notification of backup/restore state changes).

**/

void CBTManServerBURMgr::SubscribeToBackupRestoreKey()

	{

	LOG_FUNC

	iProperty.Subscribe(iStatus);

	SetActive();	

	}

/**

Processes a change in the backup/restore state of the device. 

@param aBackupStateValue A value expressing the backup/restore state of the device. 

**/

void CBTManServerBURMgr::ProcessBackupState(TBURPartType aBURStateValue)

	{

	LOG_FUNC

	iBURState = aBURStateValue;

	switch (aBURStateValue)

		{

	case EBURBackupFull:

		// Fall-through

	case EBURBackupPartial:

		iStateMachine->TransitionState(EBTBUREventBackup);

		break;

	case EBURRestoreFull:

		// Fall-through

	case EBURRestorePartial:

		iStateMachine->TransitionState(EBTBUREventRestore);

		break;

	case EBURNormal:

		iStateMachine->TransitionState(EBTBUREventNormal);

		break;

	default:	// EBURUnset

		__ASSERT_DEBUG(aBURStateValue == EBURUnset, PANIC(KBTBackupPanicCat, EBTBURMgrUnknownBUREvent));

		iStateMachine->TransitionState(EBTBUREventUnset);

		}

	}

/**

Registers an MBTBURNotify instance to receive notification of backup/restore operations starting and stopping.

Ownership of this MBTBURNotify instance is not transferred.

Any previous MBTBURNotify instance is deregistered on this method call.

Supplying a NULL pointer will deregister the previously registered instance (if present).

**/

void CBTManServerBURMgr::RequestBURNotification(MBTBURNotify* aBURNotify)

	{

	LOG_FUNC

	iBURNotify = aBURNotify;

	}

/**

Receives a local address from a CBTLocalAddressFetcher instance.

This will trigger processing of a pending restore file.

**/

void CBTManServerBURMgr::SetLocalAddress(TBTDevAddr& aLocalAddr)

	{

	LOG_FUNC

	__ASSERT_DEBUG(aLocalAddr != TBTDevAddr(), PANIC(KBTBackupPanicCat, EBTBURMgrMissingLocalAddress));

	// Use address only if it is non-zero.

	if (aLocalAddr != TBTDevAddr())

		{

		// Take a copy

		iLocalAddr = aLocalAddr;

		// Attempt to start restore file processing.

		// Note that this will fail if we are not in the normal state.

		iStateMachine->TransitionState(EBTBUREventProcessRestoreFile);

		}

	}

/**

Receives notification that a restore file has been provided by the Secure Backup Engine.

Upon receiving this notification, the restore file is renamed to have the appropriate extension 

The actual restore to the registry is postponed until the next time BTManServer starts, 

so any ongoing BT connections are not affected.

**/

void CBTManServerBURMgr::RestoreFileReady()

	{

	LOG_FUNC

	__ASSERT_DEBUG(iStateMachine->GetCurrentState() == EBTBURStateRestoreOngoing, InvalidStatePanic(EBTBURStateRestoreOngoing, iStateMachine->GetCurrentState()));

	// Rename restore file

	RenameBackupFileForRestore();

	}

void CBTManServerBURMgr::HandleStateNormal()

	{

	LOG_FUNC

	__ASSERT_DEBUG(iStateMachine->GetCurrentState() == EBTBURStateNormal, InvalidStatePanic(EBTBURStateNormal, iStateMachine->GetCurrentState()));

	if (iActiveBackupClient)

		{

		// Backup or restore finished

		if (iBackupHandler)

			{

			// Backup operation finished

			// Delete backup file and destroy backup handler

			DeleteBackupFile();

			delete iBackupHandler;

			iBackupHandler = NULL;

			}

		else

			{

			// Restore operation finished

			delete iActiveBackupDataClient;

			iActiveBackupDataClient = NULL;

			}

		// Destroy active backup client

		delete iActiveBackupClient;

		iActiveBackupClient = NULL;

		// Notify that backup/restore operation has finished

		NotifyBUROperationStopped();

		}

	}

/**

Determines if a BUR operation affects the Bluetooth Manager server.

@return ETrue if a full backup or restore is ongoing, otherwise the return value

given by CActiveBackupClient::DoesPartialBURAffectMeL()

**/

TBool CBTManServerBURMgr::DoesBURAffectMeL(CActiveBackupClient& aClient)

	{

	LOG_FUNC

	if (iBURState == EBURBackupFull || iBURState == EBURRestoreFull)

		{

		return ETrue;

		}

	else

		{

		return aClient.DoesPartialBURAffectMeL();

		}

	}

void CBTManServerBURMgr::HandleStateBackupRequestL()

	{

	LOG_FUNC

	__ASSERT_DEBUG(iStateMachine->GetCurrentState() == EBTBURStateBackupRequest, InvalidStatePanic(EBTBURStateBackupRequest, iStateMachine->GetCurrentState()));

	// Determine if this backup operation affects us and transition to next state based on this outcome.

	iActiveBackupClient = CActiveBackupClient::NewL();

	if (DoesBURAffectMeL(*iActiveBackupClient))

		{

		// We're affected, proceed with backup

		iStateMachine->TransitionState(EBTBUREventBackupProceed);

		}

	else

		{

		// We're not effected, don't do any backup handling

		iStateMachine->TransitionState(EBTBUREventBackupReject);

		}

	}

void CBTManServerBURMgr::HandleStateBackupRequestError()

	{

	LOG_FUNC

	__ASSERT_DEBUG(iStateMachine->GetCurrentState() == EBTBURStateBackupRequest, InvalidStatePanic(EBTBURStateBackupRequest, iStateMachine->GetCurrentState()));

	// Transition to normal state

	iStateMachine->TransitionState(EBTBUREventAbortStateAction);

	}

void CBTManServerBURMgr::HandleStateBackupOngoingL()

	{

	LOG_FUNC

	__ASSERT_DEBUG(iStateMachine->GetCurrentState() == EBTBURStateBackupOngoing, InvalidStatePanic(EBTBURStateBackupOngoing, iStateMachine->GetCurrentState()));

	__ASSERT_DEBUG(iActiveBackupClient, PANIC(KBTBackupPanicCat, EBTBURMgrActiveBackupClientNull));

	// Provide notification that a BUR operation has started.

	NotifyBUROperationStarted();

	// Construct backup handler and prepare for backup

	iBackupHandler = CBTBackupHandler::NewL(*this, iBTManServer.Registry());

	iBackupHandler->CreateBackupFileL();

	// Signal that we're ready for (passive) backup of prepared file

	iActiveBackupClient->ConfirmReadyForBURL(KErrNone);

	// Next state transition will be invoked when BUR P&S key changes

	}

void CBTManServerBURMgr::HandleStateBackupOngoingError()

	{

	LOG_FUNC

	__ASSERT_DEBUG(iStateMachine->GetCurrentState() == EBTBURStateBackupOngoing, InvalidStatePanic(EBTBURStateBackupOngoing, iStateMachine->GetCurrentState()));

	// Transition to normal state

	iStateMachine->TransitionState(EBTBUREventAbortStateAction);

	}

void CBTManServerBURMgr::HandleStateBackupIgnore()

	{

	LOG_FUNC

	__ASSERT_DEBUG(iStateMachine->GetCurrentState() == EBTBURStateBackupIgnore, InvalidStatePanic(EBTBURStateBackupIgnore, iStateMachine->GetCurrentState()));

	// Destroy active backup client

	delete iActiveBackupClient;

	iActiveBackupClient = NULL;

	// Next state transition will be invoked when BUR P&S key changes

	}

void CBTManServerBURMgr::HandleStateRestoreRequestL()

	{

	LOG_FUNC

	__ASSERT_DEBUG(iStateMachine->GetCurrentState() == EBTBURStateRestoreRequest, InvalidStatePanic(EBTBURStateRestoreRequest, iStateMachine->GetCurrentState()));

	// We do want a callback here. Even though the actual restore operation has been handled passively, we

	// still need notificaton that the passive restore has completed (so we can then deal with the file).

	iActiveBackupDataClient = CBTActiveBackupDataClient::NewL(*this);

	iActiveBackupClient = CActiveBackupClient::NewL(iActiveBackupDataClient);

	// Determine if this restore operation affects us and transition to next state based on this outcome

	if (DoesBURAffectMeL(*iActiveBackupClient))

		{

		// We're affected, proceed with restore

		iStateMachine->TransitionState(EBTBUREventRestoreProceed);

		}

	else

		{

		// We're not effected, don't do any restore handling

		iStateMachine->TransitionState(EBTBUREventRestoreReject);

		}

	}

void CBTManServerBURMgr::HandleStateRestoreRequestError()

	{

	LOG_FUNC

	__ASSERT_DEBUG(iStateMachine->GetCurrentState() == EBTBURStateRestoreRequest, InvalidStatePanic(EBTBURStateRestoreRequest, iStateMachine->GetCurrentState()));

	// Transition to normal state

	iStateMachine->TransitionState(EBTBUREventAbortStateAction);

	}

void CBTManServerBURMgr::HandleStateRestoreOngoingL()

	{

	LOG_FUNC

	__ASSERT_DEBUG(iStateMachine->GetCurrentState() == EBTBURStateRestoreOngoing, InvalidStatePanic(EBTBURStateRestoreOngoing, iStateMachine->GetCurrentState()));

	// Cancel any local address requests

	if (iLocalAddrFetcher)

		{

		iLocalAddrFetcher->Cancel();

		}

	// Provide notification that a BUR operation has started.

	NotifyBUROperationStarted();

	// Signal that we're ready for active restore of prepared file

	// (note that no data is actively restored, but we still need to invoke this method)

	iActiveBackupClient->ConfirmReadyForBURL(KErrNone);

	// Next state transition will be invoked when BUR P&S key changes

	}

void CBTManServerBURMgr::HandleStateRestoreOngoingError()

	{

	LOG_FUNC

	__ASSERT_DEBUG(iStateMachine->GetCurrentState() == EBTBURStateRestoreOngoing, InvalidStatePanic(EBTBURStateRestoreOngoing, iStateMachine->GetCurrentState()));

	// Transition to normal state

	iStateMachine->TransitionState(EBTBUREventAbortStateAction);

	}

void CBTManServerBURMgr::HandleStateRestoreIgnore()

	{

	LOG_FUNC

	__ASSERT_DEBUG(iStateMachine->GetCurrentState() == EBTBURStateRestoreIgnore, InvalidStatePanic(EBTBURStateRestoreIgnore, iStateMachine->GetCurrentState()));

	// Destroy active backup client

	delete iActiveBackupClient;

	delete iActiveBackupDataClient;

	iActiveBackupClient = NULL;

	iActiveBackupDataClient = NULL;

	// Next state transition will be invoked when BUR P&S key changes

	}

void CBTManServerBURMgr::HandleStateProcessRestoreFileL()

	{

	LOG_FUNC

	__ASSERT_DEBUG(iStateMachine->GetCurrentState() == EBTBURStateProcessRestoreFile, InvalidStatePanic(EBTBURStateProcessRestoreFile, iStateMachine->GetCurrentState()));

	// Start restore file processing

	iRestoreHandler = CBTRestoreHandler::NewL(*this, iBTManServer);

	iRestoreHandler->RestoreRegistryL(iLocalAddr);