// Copyright (c) 2006-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 "monitor.h"
#include "startsafe.h"
#include "restartsys.h"
#include "sysmonserver.h"
#include "sysmoncliserv.h"
#include "timerlist.h"
#include "sysmon_patch.h"
#include <startupproperties.h>

#include "SysStartDebug.h"
#include "sysstartpanic.h"

const TInt CMonitor::iOffset = _FOFF(CMonitor, iSglQueLink);

TProcessId CMonitor::ProcessId() const
	{
	return iProcessId;
	}	


CMonitor* CMonitor::NewL(CSysMonServer& aServer, const TProcessId& aId, CStartupProperties* aStartupProperties, TBool aExecuteRecoveryMethodOnFailure)
	{
	ASSERT(aStartupProperties);
	CMonitor *monitor = new(ELeave) CMonitor(aServer, aId);
	CleanupStack::PushL(monitor);
	monitor->ConstructL(aStartupProperties, aExecuteRecoveryMethodOnFailure);
	CleanupStack::Pop(monitor);
	return monitor;
	}


CMonitor::CMonitor(CSysMonServer& aServer, const TProcessId& aId)
	:CActive(EPriorityHigh),
	iSysMonServer(aServer),
	iProcessId(aId),
	iProcess(aId),
	iLoadTime()
	{
	CActiveScheduler::Add(this);
	}


void CMonitor::ConstructL(CStartupProperties* aStartupProperties, TBool aExecuteRecoveryMethodOnFailure)
	{
	iLogonBackoffTimer = CLogonBackoffTimer::NewL( *this );
	
	User::LeaveIfError(iProcess.Open(iProcessId));
	
	// Don't support monitoring of system critical components as they will restart the device on failure anyway
	User::TCritical critical = User::ProcessCritical(iProcess);
	if (critical == User::ESystemCritical || critical == User::ESystemPermanent)
		{
		User::Leave(KErrNotSupported);
		}
	
	//Make sure the process is still running
	if((EExitPending == iProcess.ExitType()))
		{
		//Ensure the the filename in aStartupProperties is the same as in iProcess
		//(not possible to read filename from a dead process).
		TParse nameInProc, nameInProp;
		nameInProc.SetNoWild(iProcess.FileName(),NULL,NULL);
		nameInProp.SetNoWild(aStartupProperties->FileName(),NULL,NULL);
		
		if( nameInProc.Name().CompareF(nameInProp.Name()) )
			{
			User::Leave(KErrArgument);
			}
		}
	else
		{
		//The process is already dead, either leave now or let this monitor recover the process
		if(!aExecuteRecoveryMethodOnFailure)
			User::Leave(KErrDied);
		}	
	
	// Can't leave after taking ownership of aStartupProperties 
	iStartupProperties = aStartupProperties;
	iLoadTime.UniversalTime();		
	}


CMonitor::~CMonitor()
	{
	delete iLogonBackoffTimer;
	
	Cancel();
	delete iStartupProperties;
	iProcess.Close();	
	}


void CMonitor::Start()
	{
	iLogonBackoffTimer->ProcessLogon();
	}



void CMonitor::DoCancel()
	{
#ifdef _DEBUG
	TPtrC fileName = iStartupProperties->FileName();
	DEBUGPRINT2(_L("SysMonMonitor: Monitor Cancelled for %S"), &(fileName));
#endif

	iProcess.LogonCancel(iStatus); // cancels monitoring
	}


void CMonitor::RestartProcessL()
	{
#ifdef _DEBUG
	TPtrC fileName = iStartupProperties->FileName();
#endif
	DEBUGPRINT3(_L("SysMonMonitor: Going to restart %S, old process id=%d"), &fileName, iProcessId.Id());
	
	CStartSafe* startSafe = CStartSafe::NewL();	
	CleanupStack::PushL(startSafe);
	
	__ASSERT_DEBUG(iStartupProperties->StartMethod() == EWaitForStart, PanicNow(KPanicMonitor, EInvalidStartMethod));
	iStartupProperties->SetStartMethod(EWaitForStart);
	
	TInt propRetries = iStartupProperties->NoOfRetries();
	TBool restoreRetries = EFalse;
	
	if(propRetries > 0)
		{
		// In the restart scenario we want StartSafe to make 'NoOfRetries' attempts
		// rather than '1 + NoOfRetries' which it will otherwise do.
		restoreRetries = ETrue;
		iStartupProperties->SetNoOfRetries(--propRetries);	
		}
	
	TInt retried = 0;
	
	// Attempt restart/s. Do not allow a leave until NoOfRetries has been restored.
	TRAPD( err, startSafe->StartL(*iStartupProperties, iProcess, retried) );
	
	if(restoreRetries)
		{
		iStartupProperties->SetNoOfRetries(++propRetries);	
		}
		
	User::LeaveIfError(err);
	CleanupStack::PopAndDestroy(startSafe);	
	DEBUGPRINT3(_L("SysMonMonitor: %S restarted, new iProcessId=%d. Logon to monitor again"), &fileName, iProcess.Id().Id());
	
	iProcessId = iProcess.Id();
	iLogonBackoffTimer->ProcessLogon();
	}


/**
 This function is inherited from MLogonCallback and is called from CLogonBackoffTimer
*/
TInt CMonitor::DoProcessLogon()
	{

	iProcess.Logon( iStatus );
	return ( (iStatus == KRequestPending) ? KErrNone : iStatus.Int() );
	}



/**
 This function is inherited from MLogonCallback and is called from CLogonBackoffTimer
*/
void CMonitor::ActivateSelf()
	{
	
	iLoadTime.UniversalTime();
	SetActive();		
	}
	
	
	
TInt CMonitor::Callback(TAny* aParent)
	{		
	CMonitor* monitor = reinterpret_cast<CMonitor*> (aParent);
	DEBUGPRINT2(_L("SysMonMonitor: Finished waiting for throttle time, try to restart failed processId=%d"), monitor->iProcessId.Id());

	TRAPD(err, monitor->RestartProcessL());

	if (err != KErrNone)
		{
		// process failed to be started, cancel monitoring of this process
		DEBUGPRINT2(_L("SysMonMonitor::RestartProcessL failed with err=%d, cancelling"), err);
		monitor->CancelMonitor();
		}

	return KErrNone;
	}
	
	
/*
CMonitor::RunL() gets called when a monitor process terminates.
*/
void CMonitor::RunL()
	{
	DEBUGPRINT1(_L("SysMonMonitor: CMonitor::RunL() called"));
	
	iProcess.Close();	// closing the current handle
	
	if (iStartupProperties->NoOfRetries() == 0 ||
		iStartupProperties->StartMethod() == EFireAndForget)
		{
		// 1. If NoOfRetries() == 0, execute recovery method immediately.
		// 2. If StartMethod() == EFireAndForget, the retry value is ignored during monitoring because 
		//	  restarting the process can result in a forever loop that make SysMon keep restarting the 
		//	  process. This is because in EFireAndForget, we don't need to check the successful start 
		//	  of the process, so as soon as the process fail again, this monitoring function would get 
		//	  called again. So for EFireAndForget we execute the recovery action if a process failed.
		TRecoveryMethod recoveryMethod = iStartupProperties->RecoveryMethod();
		TInt err = KErrNone;
		DEBUGPRINT2(_L("SysMonMonitor: Process failed RecoveryMethod=%d"), recoveryMethod);
		if (recoveryMethod == ERestartOS)
			{
			err = RestartSys::RestartSystem() ;	// restart the system

			if (KErrNone != err)
				{
				DEBUGPRINT2(_L("Sysstart: RestartSystem error %d"), err);
				PanicNow(KPanicMonitor, ERestartSystemCallFailed);
				}

			User::After(5000000); // required by RestartSys API, see comments in RestartSys::RestartSystem()
			}			
		else if (recoveryMethod == ERestartOSWithMode)
			{
			err = RestartSys::RestartSystem(iStartupProperties->RestartMode()) ;	// restart system in a mode

			if (KErrNone != err)
				{
				DEBUGPRINT2(_L("Sysstart: RestartSystem with mode error %d"), err);
				PanicNow(KPanicMonitor, ERestartSystemCallWithMode);
				}

			User::After(5000000); // required by RestartSys API, see comments in RestartSys::RestartSystem()
			}
		else
			{
			// ignore on failure, cancel monitoring of this process
			CancelMonitor();
			}
		}
	else
		{
		TTime curTime;
		curTime.UniversalTime(); // current time, can be considered as the time of termination for the process
		
		TTime thresholdTime = (iLoadTime + TTimeIntervalMicroSeconds32(KWaitTime)); // time, till when no restart should take place
		
		if (curTime < thresholdTime)
			{	
			// Implies process terminated less than KWaitTime since the last launch of the process
			// So to reduce Denial of Service we wait the remaining time of KWaitTime.
#ifdef _DEBUG
			TPtrC fileName = iStartupProperties->FileName();
			DEBUGPRINT2(_L("SysMonMonitor: Wait for throttle time before restarting process %S"), &(fileName));
#endif
			iSysMonServer.TimerListL().AddL(thresholdTime, TCallBack(Callback, this));
			}
		else
			{
			RestartProcessL();
			}
		}
	}


#ifdef _DEBUG
TInt CMonitor::RunError(TInt aError)
#else
TInt CMonitor::RunError(TInt /*aError*/)
#endif
	{
	DEBUGPRINT2(_L("SysMonMonitor: RunError called with error=%d, cancelling"), aError);
	// process failed to be started, cancel monitoring of this process
	CancelMonitor();
	
	return KErrNone;
	}


void CMonitor::CancelMonitor()
	{
	DEBUGPRINT2(_L("SysMonMonitor: CMonitor cancelling monitor with iProcessId=%d"), iProcessId.Id());
	iSysMonServer.CancelMonitor(iProcessId);
	}