// Copyright (c) 2005-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 <barsread.h>
#include <e32uid.h>
#include <e32modes.h>
#include <startup.hrh>
#include <hal.h>
#include <hal_data.h>
#include <startupproperties.h>
#include "resourcefilereader2.h"
#include "SystemStartupStateInfo.h"
#include "StartupCommand.h"
#include "startuputilprovider.h"
#include "BootModeMapping.h"
#include "appstarter2.h"
#include "DllStarter.h"
#include "StartupSplashScreen.h"
#include "initapparcserver2.h"
#include "SystemStartupDllInfo.h"
#include "multiplewait2.h"
#include "amastarter.h"

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

const TUint KEntryPointIndex = 1;

/** Read splash screen information from the resource file and return an object
that can start/kill it
*/
MStartupCommand* CResourceFileReader::ReadSplashScreenL(TResourceReader& aReader)
	{
	TBool kill = static_cast<TUint16>(aReader.ReadUint16());
	HBufC* path = aReader.ReadTPtrC().AllocLC();
	CStartupSplashScreen* command = CStartupSplashScreen::NewL(!kill, path);
	CleanupStack::Pop(path);	// "command" takes ownership of path
	return command;
	}
		
/** Read app arc server initialisation information from the resource file
and return an object that can start it
*/
MStartupCommand* CResourceFileReader::ReadAppArcInitL()
	{
	return CInitAppArcServer::NewL(*iStartupUtilProvider);
	}

/** Read in the fields of the MULTIPLE_WAIT command in the SSC. 
Create a CMultipleWait object containing the list of deferred commands encountered
since the last MULTIPLE_WAIT command.   
*/ 
MStartupCommand* CResourceFileReader::ReadMultipleWaitInfoL(TResourceReader& aReader, CommandList& aDeferredList)
	{
	// Read values from the SSC
	TInt timeout = aReader.ReadInt32();
	TInt fail = static_cast<TUint16>(aReader.ReadUint16());
	
	// Create a CMultipleWait object to hold the data to be used during 
	// the command execution.
	CMultipleWait* waitCommand = CMultipleWait::NewL(aDeferredList, *iStartupUtilProvider);
	
	// Populate the command with the values just read from the SSC.
	waitCommand->SetTimeout(timeout);
	
	// Check that the fail_on_error value is valid.	
	if ((fail != EIgnoreCommandFailure) && (fail != EPanicOnCommandFailure))   
		{	
		DEBUGPRINT2(_L("SysStart: Invalid fail_on_error value of %d"), fail);
		PanicNow(KPanicResourceFileReader, EInvalidMultipleWaitFailOnError);
		} 
	waitCommand->SetFailOnError(fail);
	 	
 	return waitCommand; 
	}
	
/**
*/
MStartupCommand* CResourceFileReader::ReadAmaInfoL(TResourceReader& aReader)
	{
	TUid id = TUid::Uid(aReader.ReadUint32());

	CAmaStarter *command = CAmaStarter::NewL(id);
	
	return command;	
	}
	
/** Read DLL information from the resource file and store in an object to be 
used during dll function invocation
*/
MStartupCommand* CResourceFileReader::ReadDllInfoL(TResourceReader& aReader)
{ 
	// Read the main START_DLL_INFO fields from the SSC (static start-up 
	// configuration) file.
	TPtrC dllName = aReader.ReadTPtrC();
	TUint8 ordinal = aReader.ReadUint8();
 	TInt fail = static_cast<TBool>(aReader.ReadInt16());
	TUint8 retries = static_cast<TUint8>(aReader.ReadUint8());

	// Additional validation
	if ((fail != EIgnoreCommandFailure) && (fail != EPanicOnCommandFailure))   
		{	
		DEBUGPRINT2(_L("SysStart: Invalid fail_on_error value of %d"), fail);
		PanicNow(KPanicResourceFileReader, EInvalidDLLFailOnError);
		}  
 
 	if (ordinal == 0)
 		{
 		DEBUGPRINT1(_L("Invalid ordinal value of 0"));
		PanicNow(KPanicResourceFileReader, EInvalidOrdinal0);
 		}
 		
	// Store the information to be used later during function invocation
	CSystemStartupDllInfo* dllInfo = CSystemStartupDllInfo::NewLC();	
	dllInfo->SetDllNameL(dllName); 
	dllInfo->SetOrdinal( ordinal);  
	dllInfo->SetFailOnError(fail);
 	dllInfo->SetNoOfRetries(retries); 
  
  	// Read the DLL custom data link from the START_DLL_INFO struct
 	TUint32 dllDataLink = aReader.ReadUint32();
 
 	// Validate data link value
 	if (dllDataLink == 0)
 		{
 		DEBUGPRINT1(_L("Invalid custom_dll_data_link value of 0"));
		PanicNow(KPanicResourceFileReader, EInvalidDataLink0);
 		}
 		
 	// Store the data found under the dllDataLink structure into a buffer
 	// for custom processing by licensee (See CDllStarter::Execute)
  	dllInfo->SetDllBuffer(iResourceFile.AllocReadLC(dllDataLink));
  		
  	// The above read a resource into a heap descriptor and put a pointer 
  	// to that descriptor onto the cleanup stack. Therefore this must now be 
  	// popped off the stack.
	CleanupStack::Pop();
	
	// Create a command using the DLL info retrieved.
	CDllStarter* command = CDllStarter::NewL(dllInfo);
		
	// Pop dllInfo of the stack
	CleanupStack::Pop(dllInfo);

	return command;
	}
 
//
// Standard Symbian factory functions/destructor
//

CResourceFileReader* CResourceFileReader::NewL(TInt aBootMode, RFs& aFs)
	{
	CResourceFileReader* self = CResourceFileReader::NewLC(aBootMode, aFs);
	CleanupStack::Pop(self);
	return self;
	}

CResourceFileReader* CResourceFileReader::NewLC(TInt aBootMode , RFs& aFs)
	{
	TFileName resourceFile;
	TBootModeMapping mapping;
	
	mapping.GetResourceFileName(aBootMode, resourceFile, aFs);
	
	DEBUGPRINT2(_L("SysStart: using resource file %S"), &resourceFile);

	CResourceFileReader* self = new (ELeave) CResourceFileReader(aBootMode, aFs);
	CleanupStack::PushL(self);
	self->ConstructL(resourceFile);
	return self;
	}

CResourceFileReader::~CResourceFileReader()
	{
	iResourceFile.Close();
	delete iStartupUtilProvider;	
	}

//
// Public functions.
//

/** Gets information about the next start-up state. This involves reading the state information
and constructing the command list for this state.
*/
MStartupStateInfo* CResourceFileReader::GetStateInfoL()
	{
	return ((iState < NULL) ? NULL : ReadStateInformationL());
	}


//
// Private functions
//

CResourceFileReader::CResourceFileReader(TInt aBootMode, RFs& aFs)
	: iFs(aFs), iBootMode(aBootMode)
	{
	iMaxStartupMode = -1;
	}

void CResourceFileReader::ConstructL(const TDesC& aResourceFile)
	{
    iResourceFile.OpenL(iFs, aResourceFile);
    iStartupUtilProvider = CStartupUtilProvider::NewL();    
	}
 
void CResourceFileReader::FindFirstStateEntryL()
	{
	HBufC8* dataBuffer = iResourceFile.AllocReadLC(KEntryPointIndex);
	TResourceReader reader;
	reader.SetBuffer(dataBuffer);
	iState = reader.ReadInt32();
	CleanupStack::PopAndDestroy(dataBuffer);
	}

/** Read state information from the resource file
*/
CSystemStartupStateInfo* CResourceFileReader::ReadStateInformationL()
	{
	if (iState == 0)
		{
		FindFirstStateEntryL();
		}
		
	CSystemStartupStateInfo* stateInfo = CSystemStartupStateInfo::NewLC();

	HBufC8* dataBuffer = iResourceFile.AllocReadLC(iState);
	TResourceReader reader;
	reader.SetBuffer(dataBuffer);

	TUint8 id = reader.ReadUint8();
	
	// Validate state id field. State id can be any int except for the 
	// currently reserved values.
	if ((id == EReservedStartUpState1) || (id == EReservedStartUpState2) ||
	    (id == EReservedStartUpState4) || (id == EReservedStartUpState5)) 
		{
 		DEBUGPRINT2(_L("Invalid state id of %d"), id);
		PanicNow(KPanicResourceFileReader, EInvalidStateId);
		}  	

	// Store the state id value.
	stateInfo->SetStateId(id);

	TPtrC stateName = reader.ReadTPtrC();
	stateInfo->SetName(stateName);

	TUint32 commandListId = reader.ReadUint32();
	
    iState = reader.ReadInt32();	// Link to next state.
 
 	// The retries field specifies how many times to re-attempt 
 	// state transition in the case of failure
	TNoOfRetries noOfRetries = static_cast<TNoOfRetries>(reader.ReadUint16()); 

	// Validate field and store
	if ((noOfRetries != ERetry0) && (noOfRetries != ERetry1))
		{
 		DEBUGPRINT2(_L("Invalid no_of_retries_on_failure value of %d"), noOfRetries);
		PanicNow(KPanicResourceFileReader, EInvalidNoOfRetries);
		}  
	stateInfo->SetNoOfRetries(noOfRetries);
	 
	// The next field specifies what should be done on a state transition 
	// failure - ignore or panic  
	TActionOnStateTransitionFailure actionOnStateTransitionFailure = 
	        static_cast<TActionOnStateTransitionFailure>(reader.ReadUint16());  

	// Validate field and store.
	if ((actionOnStateTransitionFailure != EIgnoreFailure) && (actionOnStateTransitionFailure != EPanicOnFailure))
		{
 		DEBUGPRINT2(_L("Invalid action_on_failure value of %d"), actionOnStateTransitionFailure);
		PanicNow(KPanicResourceFileReader, EInvalidActionOnFailure);
		}  
	stateInfo->SetActionOnStateTransitionFailure(actionOnStateTransitionFailure);
    
    CleanupStack::PopAndDestroy(dataBuffer);

    if (iState == 0)
    	{
    	// Just read the last state info - make sure that we don't try to
    	// read any more.
    	iState = -1;
    	}
     
 	CommandList commandList = ReadCommandListL(commandListId);
	stateInfo->SetCommandList(commandList);
	CleanupStack::Pop(stateInfo);

    return stateInfo;
	}
	
/** Read the command list from the resource file
*/
CommandList CResourceFileReader::ReadCommandListL(TUint32 aCommandListId)
	{
	CommandList commandList; 
	
	// Some of the commands will be deferred apps or processes (i.e. it is not 
	// checked that they have completed until a MULTIPLE_WAIT command is issued). 
	// Create a list of these commands so they can be referred to from a 
	// CMultipleWait object.
	CommandList deferredList;
		
	HBufC8* dataBuffer = iResourceFile.AllocReadLC(aCommandListId);
	TResourceReader reader;
	reader.SetBuffer(dataBuffer);

	TUint16 commandListCount = reader.ReadUint16();

	for(TUint i = 0; i < commandListCount; ++i)
		{
		const TStartupCommandType type = static_cast<TStartupCommandType>(reader.ReadUint16());	
		MStartupCommand* command = NULL;
		switch (type)
			{
		case EStartupApp:					
		case EStartupProcess:
		case EStartupApp2:					
		case EStartupProcess2:			
			{
			reader.Rewind(sizeof(TUint16)); //CStartupProperties need to read the struct from start
			CStartupProperties* appInfo = CStartupProperties::NewLC(reader);
			if (appInfo->RecoveryMethod() == ERestartOSWithMode)
				{
				ValidateRestartMode(appInfo->RestartMode());
				}
			command = CAppStarter::NewL(appInfo, *iStartupUtilProvider);
			CleanupStack::Pop(appInfo); // ownership passed above
			CleanupStack::PushL(command);
			 
			// If the command has a start_method of EDeferredWaitForStart
			// in the SSC then it needs to be added to the current deferred
			// list. This will be passed to a CMultipleWait object once a 
			// MULTIPLE_WAIT command is encountered.
			if (command && (appInfo->StartMethod() == EDeferredWaitForStart))
				{  
				User::LeaveIfError(deferredList.Append(command)); 				
				}
			break;
			}
 		
		case EStartupSplashScreen:
			command = ReadSplashScreenL(reader);
			CleanupStack::PushL(command);
			break;

		case EInitAppArcServer:
			command = ReadAppArcInitL();
			CleanupStack::PushL(command);
			break;

		case EStartupDLL:
			command = ReadDllInfoL(reader);
			CleanupStack::PushL(command);
			break;
			
		case EMultipleWait:
		
			// A MULTIPLE_WAIT command should only be provisioned in the SSC
			// if there are preceeding deferred commands.
			if (deferredList.Count() == 0)
				{		
		 		DEBUGPRINT1(_L("SysStart: Resource File Reader extra multiple wait command in SSC"));
				PanicNow(KPanicResourceFileReader, EExtraMultipleWaitCommand);
				}
			// A list has been built up of any processes/apps with a start_method of
			// EDeferredWaitForStart. Pass this list as parameter so that a 
			// CMultipleWait object can be created which has access to this list.			  
			command = ReadMultipleWaitInfoL(reader, deferredList);
			CleanupStack::PushL(command);
			
			// As processing continues more deferred command may be encountered
			// along with a subsequent MULTIPLE_WAIT struct. Reset the deferred list
			// so that the next set of deferred commands can be stored.
			deferredList.Reset();   
			break;
			
		case EStartupAMAStarter:
			command = ReadAmaInfoL(reader);
			CleanupStack::PushL(command);
			break;
		
		default:
	 		DEBUGPRINT2(_L("SysStart: Resource File Reader unknown command type %d"), type);
			PanicNow(KPanicResourceFileReader, EInvalidCommandType);
			break;
			}
			
		if (command)
			{
			User::LeaveIfError(commandList.Append(command));
			CleanupStack::Pop(command);
			}
		}
	
	// Any deferred commands must be followed by a MULTIPLE_WAIT command within
	// the same state. Therefore at this stage all commands in the state have been 
	// processed so the deferred list should be empty.
	
	if (deferredList.Count() != 0)
		{		
		PanicNow(KPanicResourceFileReader, EMissingMultipleWaitCommand);
		}

	deferredList.Reset();	
    CleanupStack::PopAndDestroy(dataBuffer);
	return commandList;
	}

void CResourceFileReader::ValidateRestartMode(TInt aStartupMode)
	{
#ifndef __WINSCW__ // HAL::Get(EMaximumRestartStartupModes...) is only supported in H4	
	// check that the startup mode is valid, first retrieve max startup mode if not retrieved yet
	if (iMaxStartupMode == -1)
		{
		TInt err = HAL::Get(HALData::EMaximumRestartStartupModes, iMaxStartupMode);
		if (err != KErrNone)
			{
	 		DEBUGPRINT2(_L("SysStart: Failed to get max startup mode err = %d"), err);
			PanicNow(KPanicResourceFileReader, EMissingMaxStartupMode);
			}
		DEBUGPRINT2(_L("SysStart: HAL max startup mode = %d"), iMaxStartupMode);
		}

	if (aStartupMode > iMaxStartupMode)
		{
 		DEBUGPRINT2(_L("SysStart: Invalid failure_recovery_startup_mode %d"), aStartupMode);
		PanicNow(KPanicResourceFileReader, EInvalidStartupMode);
		}
#else
	(void)aStartupMode;
#endif
	}