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

#include <barsc2.h>
#include <barsread2.h>
#include <e32property.h>
#include <e32uid.h>
#include <e32std.h>
#include <bautils.h>

#include <ssm/ssmcmd.hrh>
#include <ssm/ssmsubstates.hrh>
#ifdef SYMBIAN_SSM_GRACEFUL_SHUTDOWN
#include <ssm/ssmpatchableconstants.h>
#include <ssm/conditiontypes.hrh>
#endif

#include <ssm/ssmstatetransition.h>
#include <ssm/ssmcommandlistresourcereader.h>
#include <ssm/ssmmaxbootattempts_patch.h>

#include "gsastatepolicystartup.h"
#include "ssmdebug.h"
#include "ssmpanic.h" 
#include "s32file.h" 

_LIT(KBootUpFile, ":\\private\\2000d75b\\bootupinfo\\bootupcount.bin");

/**
 Attempt to reboot the device (forever) on boot failure. Used when KSsmMaxBootAttempts is set to '0xFFFFFFFF'.
*/
const TInt KSsmAttemptRebootForever = 0xFFFFFFFF;

/**
Panic used by Startup policy plug-in when resource reader is invalid.
Strings must not be longer than 16 characters or they will be truncated by User::Panic()
*/
_LIT(KPanicGsaStartupState, "StartupPolicy");

/**
 Start-up state policy resource file path format : "z:/private/<SID of SSM>/startup/<Value of KSystemStartupModeKey>/"
*/
_LIT(KCommandListPath, "z:\\private\\2000D75B\\startup\\%d\\");

/**
 Commandlist path to launch 'sysstart.exe' when a resource file for 'start-up' is not found.
 fallback to 'sysstart.exe' resource file path format : "z:/private/<SID of SSM>/startup/fallback/"
*/
_LIT(KFallbackCmdListPath, "z:\\private\\2000D75B\\startup\\fallback\\");

/**
Used to create an instance of MSsmStatePolicy class.

@return A pointer to an instance of MSsmStatePolicy
*/
EXPORT_C MSsmStatePolicy* CGsaStatePolicyStartup::NewL()
	{
	CGsaStatePolicyStartup* self = new (ELeave) CGsaStatePolicyStartup;
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

/**
Gets the hardware reason for KSystemStartupModeKey and makes a RFs connection.
Creates Command list path and the resource reader for startup.

@leave One of the error value returned by 
	    RProperty::Get() 
	    RFs::Connect() 
	    RArray::AppendL() 
	    NewL()
@see RProperty::Get
*/
void CGsaStatePolicyStartup::ConstructL()
	{
	// Read the hardware reason
	User::LeaveIfError(RProperty::Get(KUidSystemCategory, KSystemStartupModeKey, iHardwareReason));
	User::LeaveIfError(iFs.Connect());
	
	// Add supported transitions from Startup 'ESsmStartup'
	iCurrentlySupportedTransitions.AppendL(TSsmState(ESsmFail, KSsmAnySubState));
	iCurrentlySupportedTransitions.AppendL(TSsmState(ESsmShutdown, KSsmAnySubState));
	iCurrentlySupportedTransitions.AppendL(TSsmState(ESsmShutdown, ESsmShutdownSubStateCritical));

	TFileName cmdListPath;
	GetCommandListPath(iHardwareReason, cmdListPath);
	DEBUGPRINT2(_L("Startup Policy : Startup command list path : %S"), &cmdListPath);

	// create resource reader
	iCommandListResourceReader = CSsmCommandListResourceReader::NewL(iFs, cmdListPath, *this);	
	}

/**
default CTOR
*/
CGsaStatePolicyStartup::CGsaStatePolicyStartup()
	{
	}

/**
DTOR
*/
CGsaStatePolicyStartup::~CGsaStatePolicyStartup()
	{
	delete iCommandListResourceReader;
	iSubStates.Close();
	iFs.Close();
	iCurrentlySupportedTransitions.Close();
	}

/**
Initializes command list resource reader.

@param aStatus to complete when the initialization operation has finished
@panic EInvalidResourceReader if the command list resource reader is invalid

@see MSsmStatePolicy::Initialize
*/
void CGsaStatePolicyStartup::Initialize(TRequestStatus& aStatus)
	{
	__ASSERT_DEBUG(iCommandListResourceReader, PanicNow(KPanicGsaStartupState, EInvalidResourceReader));
	
	// initialise command list resource reader.
	iCommandListResourceReader->Initialise(aStatus);
	}

/**
Cancels an asynchronous Initialize operation.

@see MSsmStatePolicy::InitializeCancel
*/
void CGsaStatePolicyStartup::InitializeCancel()
	{
	iCommandListResourceReader->InitialiseCancel();
	}

/** 
Deletes all resources and frees itself.

@see MSsmStatePolicy::Release
*/
void CGsaStatePolicyStartup::Release()
	{
	delete this;
	}

/** 
Determines if an incoming startup state transition request should be accepted or rejected.
Clients calling this API should posess 'ECapabilityPowerMgmt', else the API will return ENotAllowed.

@param aRequest Contains information about the new request
@param aCurrent Contains NULL or the first accepted but not yet completed transition request
@param aQueued Contains NULL or a second accepted but not yet started transition request
@param aMessage Message sent by SSM server, used to check if the client has 'ECapabilityPowerMgmt'

@return one of the TResponse value
@see MSsmStatePolicy::TransitionAllowed
@see MSsmStatePolicy::TResponse
*/
MSsmStatePolicy::TResponse CGsaStatePolicyStartup::TransitionAllowed(const TSsmStateTransition& aRequest, TSsmStateTransition const* aCurrent, 
																TSsmStateTransition const* aQueued, const RMessagePtr2& aMessage)
	{
	TResponse response = ENotAllowed;
	if (!aMessage.HasCapability(ECapabilityPowerMgmt))
		{
		DEBUGPRINT1(_L ("Startup Policy : Capability Check Failed."));
		return response;
		}

	//Check if the requested transition is supported from current state
	if(TransitionSupported(aRequest.State()))
		{
		if((NULL == aCurrent) && (NULL == aQueued))
			{
			// SsmServer is idle
			response = EDefinitelyAllowed;
			}
		else if((aRequest.State().MainState() == ESsmFail) || (aRequest.State().MainState() == ESsmShutdown))
			{
			// Going into failed state or shutdown state will override anything currently ongoing or queued
			response = EReplaceCurrentClearQueue;
			}
		}

#ifdef _DEBUG
	TSsmStateName name = aRequest.State().Name();
	if(ENotAllowed == response)
		{
		DEBUGPRINT3(_L("Startup Policy : Transition (Requested State: %S) is not allowed (Response: %d)."), &name, response);
		}
	else
		{
		DEBUGPRINT3(_L("Startup Policy : Transition (Requested State %S) is allowed (Response %d)."), &name, response);		
		}
#endif
	return response;
	}

/** 
Create the command list associated with a sub state transition.

@param aState Contains the state and substate that identifies the command list to create
@param aReason Contains the reason as given by the request
@param aStatus to complete when the operation has finished
@panic EInvalidResourceReader if the command list resource reader is invalid
@see MSsmStatePolicy::PrepareCommandList
*/ 
void CGsaStatePolicyStartup::PrepareCommandList(TSsmState aState, TInt aReason, TRequestStatus& aStatus)
	{
	__ASSERT_DEBUG(iCommandListResourceReader, PanicNow(KPanicGsaStartupState, EInvalidResourceReader));

	iSoftwareReason = aReason;

	//Let's start from the beginning if no specific minor state is selected
	iRequestedSubState = ((aState.SubState() == KSsmAnySubState) ? ESsmStartupSubStateCriticalStatic : aState.SubState());
	TSsmState publishState;
	publishState.Set(aState.MainState(), iRequestedSubState);

	const TInt commandListId = publishState.SubState();

	//Build the commandlist from resource
	iCommandListResourceReader->PrepareCommandList(commandListId, publishState, aStatus);
	} //lint !e1746 Suppress parameter 'aState' could be made const reference

/**
Cancels asynchronous PrepareCommandList operation.

@see MSsmStatePolicy::PrepareCommandListCancel
*/
void CGsaStatePolicyStartup::PrepareCommandListCancel()
	{
	iCommandListResourceReader->PrepareCommandListCancel();
	}

/**	
Return the command list once the  PrepareCommandList has completed.
Ownership of the returned command list is transferred to the caller.
@panic EInvalidResourceReader if the command list resource reader is invalid
@return The command list created during the preceding PrepareCommandList step
*/
CSsmCommandList* CGsaStatePolicyStartup::CommandList()
	{
	__ASSERT_DEBUG(iCommandListResourceReader , PanicNow(KPanicGsaStartupState, EInvalidResourceReader));

	return iCommandListResourceReader->GetCommandList();
	}

/**
Determines the next sub state transition.
@param aCurrentTransition Contains the last executed state
@param aReason Contains the reason as given by the request
@param aError Contains the completion code from the last executed sub-state transition
@param aSeverity Contains the severity of the failed command in case the sub-state transition ended with an error
@param aNextState The next System State to head for, if there is one
@panic EInvalidStartupstate if the current state is not startup
@return 	ETrue if aNextState contains another System State to head for, or 
		EFalse if there is no further transitions to do.
@see MSsmStatePolicy::GetNextState
*/
TBool CGsaStatePolicyStartup::GetNextState(TSsmState aCurrentTransition, TInt /*aReason*/, TInt aError, TInt /*aSeverity*/, TSsmState& aNextState)
	{
	__ASSERT_ALWAYS(aCurrentTransition.MainState() == ESsmStartup, PanicNow(KPanicGsaStartupState, EInvalidStartupState));

	if (KErrNone != aError)	// Handle CLE error here
		{
		if (iLaunchSysStart)	// 'sysstart.exe' was launched unsuccessfully so launch 'sysagt2srv.exe' and 'wserv.exe'
			{
			iLaunchSysStart = EFalse;
			iLaunchSysAgt2SrvAndWServ = ETrue;
			DEBUGPRINT2(_L("Startup Policy : sysstart.exe launched with error : %d"), aError);
			aNextState = TSsmState(ESsmStartup, ESsmStartupSubStateCriticalDynamic);
			return ETrue;
			}

#ifdef __WINS__	// on emulator
			{
			DEBUGPRINT2(_L("Startup Policy : CLE returned with (error : %d), Panic on Emulator"), aError);
			DEBUGPRINT1(_L("Startup Policy : Emulator (__WINS__) does not support a re-start, so Fail Policy is not invoked."));
			PanicNow(KPanicGsaStartupState, EEmulatorPowerOff);
			}
#else	// on hardware/device
			{
			aNextState = TSsmState(ESsmFail, ESsmFailSubStateRestart);
			if (KSsmAttemptRebootForever != KSsmMaxBootAttempts)
				{
				// Get number of boot attempts made till now from bootup log file
				TInt bootCount = -1;
				TRAPD(err, bootCount = GetBootupCountL());	// ignore failure and restart the device, we should get the value next time.
				if (err!=KErrNone)
					{
					DEBUGPRINT2(_L("Startup Policy : GetBootupCountL() failed with (error: %d), error is deliberately ignored."), aError);
					}
				if (bootCount < KSsmMaxBootAttempts)
					{
					aNextState = TSsmState(ESsmFail, ESsmFailSubStateRestart);
					}
				else	// Maximum allowed boot attempts has been made. Device needs a poweroff. Probable candidate for a reset/reflash.
					{
					aNextState = TSsmState(ESsmFail, ESsmFailSubStatePowerOff);
					}
				}
	#ifdef _DEBUG
			TSsmStateName name = aNextState.Name();
			DEBUGPRINT3(_L("Startup Policy : CLE returned with (error : %d) so moving to Fail State : %S."), aError, &name);
	#endif
			return ETrue;
			}
#endif
		}
	else if(iLaunchSysStart || iLaunchSysAgt2SrvAndWServ)	// If either sysstart or sysagt2srv and wserv was launched and CLE did not return an error
		{
		if (iLaunchSysStart)
			{
			iLaunchSysStart = EFalse;
			DEBUGPRINT1(_L("Startup Policy : sysstart.exe launched successfully."));
			}
		if (iLaunchSysAgt2SrvAndWServ)
			{
			iLaunchSysAgt2SrvAndWServ = EFalse;
			DEBUGPRINT1(_L("Startup Policy : sysagt2srv.exe and wserv.exe launched successfully."));
			}
		aNextState = TSsmState(ESsmNormal, KSsmAnySubState);	// move to Normal state
		return ETrue;
		}
	else	// have to move one with the next substates in this state
		{
		// Get the sub states from resource reader only once
		if (!iSubStatesCount)
			{
			// Get sub states list from resource reader
			TRAPD(err, iCommandListResourceReader->GetCommandListIdsL(iSubStates));
			if (err)
				{
				DEBUGPRINT2(_L("Startup Policy : Command list ids prepared with error: %d"), err);
				}
			else
				{
				iSubStatesCount = iSubStates.Count();
				}
			}

		TInt index = iSubStates.Find(iRequestedSubState);

		if (KErrNotFound == index)
			{
			DEBUGPRINT2(_L("Startup Policy : SubState for transition not found: %d"), index);
			PanicNow(KPanicGsaStartupState, ESubStateIndexNotFound);
			}
		else if (index == (iSubStatesCount - 1))	// transition complete, move to Normal state
			{
			TInt retVal = EFalse;
			// moving to next state as the transition is completed for ESsmStartup
			if (iSubStatesCount && (iRequestedSubState == iSubStates[iSubStatesCount-1]))
				{
				aNextState = TSsmState(ESsmNormal, KSsmAnySubState);
				retVal = ETrue;
				}
			return retVal;
			}
		else		// there is a substate available for transition, moved ahead
			{
			iRequestedSubState = iSubStates[++index];
			aNextState = TSsmState(ESsmStartup, iRequestedSubState);
#ifdef _DEBUG
			TSsmStateName name = aNextState.Name();
			DEBUGPRINT2(_L("Startup Policy : Transition to next state is : %S"), &name);
#endif				
			return ETrue;
			}
		}
	return EFalse;
	} //lint !e1746 Suppress parameter 'aCurrentTransition' could be made const reference

/**
Callback used by CSsmCommandListResourceReader when a decision needs to be made
on whether to include a command in a command list or not.

@param aResourceFile Instance of CResourceFile
@param aResourceId Resource id of SSM_SYMBIAN_CONDITIONAL_INFORMATION struct for command
@return ETrue in case the command needs to be included in command list, else EFalse.

@see MSsmConditionalCallback::ConditionalCommandAllowedL
*/
#ifdef SYMBIAN_SSM_GRACEFUL_SHUTDOWN 
TBool CGsaStatePolicyStartup::ConditionalCommandAllowedL(CResourceFile& aResourceFile, TInt aResourceId)
#else
TBool CGsaStatePolicyStartup::ConditionalCommandAllowedL(CResourceFile& /*aResourceFile*/, TInt /*aResourceId*/)
#endif
	{
	TBool isAllowed = EFalse;        
#ifdef SYMBIAN_SSM_GRACEFUL_SHUTDOWN
   	HBufC8* buf = aResourceFile.AllocReadLC(aResourceId);
   	TResourceReader reader; 
	reader.SetBuffer(buf);
	//Read the type of the command from the resource file
	TUint16 type = reader.ReadUint16();
	CleanupStack::PopAndDestroy(buf);
	// check that the type is equal to "EGracefulShutdown"
	if(type == EGracefulShutdown)    
		{
		//Check whether SSM graceful shutdown is enabled or not
		if(IsSsmGracefulShutdown())   
			{
			isAllowed = ETrue;
			}
		}
#else
	// no commands use 'conditional_information' in Startup state command list.
	PanicNow(KPanicGsaStartupState, EConditionalInfoNotImplemented);
#endif
	return isAllowed;
	}

/*
Helper function to check whether requested transition is supported or not.
*/
TBool CGsaStatePolicyStartup::TransitionSupported(const TSsmState& aRequestedState) const
	{
	return (iCurrentlySupportedTransitions.Find(aRequestedState) > KErrNotFound);
	}

/*
Helper function to create command list path for start-up.
Implements fallback mechanism to launch 'sysstart.exe' if static command list for 'start-up' state is not found.
This temporary implementation is required during migration from existing 'sysstart' to 'ssma start-up'.
*/
void CGsaStatePolicyStartup::GetCommandListPath(TUint aBootMode, TDes& aCmdListPath)
	{
	aCmdListPath.Format(KCommandListPath, aBootMode);
	TBool found = BaflUtils::FolderExists(iFs, aCmdListPath);

	// This Fallback mechanism is used internally during migration from 'sysstart' to 'ssma start-up' and is not required otherwise.
	if (!found)
		{
		aCmdListPath.Copy(KFallbackCmdListPath());
		iLaunchSysStart = ETrue;	// launch 'sysstart.exe'
		}
	}

/*
Helper function to get the boot count
*/
TInt CGsaStatePolicyStartup::GetBootupCountL()
	{
	RBuf bootupInfoPath;
	CleanupClosePushL(bootupInfoPath);
	const TChar drive = RFs::GetSystemDriveChar();
	TInt length = KBootUpFile().Length() + 1; /* for RFs::GetSystemDriveChar() */
	bootupInfoPath.CreateL(length);
	bootupInfoPath.Append(drive);
	bootupInfoPath.Append(KBootUpFile());
	TBool found = BaflUtils::FileExists(iFs, bootupInfoPath);
 	if(!found)
 		{
		User::Leave(EBootupCountFileNotFound);
		}

	RFileReadStream file;
	CleanupClosePushL(file);
	User::LeaveIfError(file.Open(iFs, bootupInfoPath, EFileRead));
	TInt bootCount = file.ReadUint8L();
	CleanupStack::PopAndDestroy(&file);
	CleanupStack::PopAndDestroy(&bootupInfoPath);
	return bootCount;
	}