/**

* Copyright (c) 2008-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:

*

*/

/**

 @file t_process_crash.h

 @internalTechnology

 @prototype

*/

#ifndef __CPROCESSCRASHWRAPPER_H__

#define __CPROCESSCRASHWRAPPER_H__

#include <e32property.h>

#include <datawrapper.h>

#include <e32base.h>

#include <f32file.h>

#include <bafindf.h >

#include <e32btrace.h>

#include <e32std.h>

#include <hal.h>

#include <coredumpinterface.h> //core dump interface API

#include <optionconfig.h>

#include <coredumpserverapi.h>

#include <crashdatasave.h>

#include <scmdatatypes.h>

#include <symbianelfdefs.h>

#include <scmconfigitem.h>

#include "t_common_defs.h"

const TInt MAXNUMBEROFDHDR = 200;

enum TValidateString {EValExecutable, EValThread};

class CProcessCrashWrapper;

/**

 * This class implements an Active Object to test the asynchronous ProcessCrashLog

 */

class CAsyncProcessCrash : public CActive

	{

public:

	static CAsyncProcessCrash* NewL(CProcessCrashWrapper* );

	~CAsyncProcessCrash( );

	void IssueProcessCrashRequest(TUint aCrashId);

private:

	void ConstructL();

	CAsyncProcessCrash(CProcessCrashWrapper* );

  // from CActive

	void RunL();

	TInt RunError(TInt aError);

	void DoCancel();

	CProcessCrashWrapper* iProcessCrashWrapper;

	TUint iCrashId;

  	} ;

/**

 * This class is responsible for processing the crash information

 */

class CProcessCrashWrapper : public CDataWrapper

	{

public:

	~CProcessCrashWrapper();

	static CProcessCrashWrapper* NewL();

	virtual TBool DoCommandL(const TTEFFunction& aCommand,

			const TTEFSectionName& aSection, const TInt aAsyncErrorIndex);

	virtual TAny* GetObject()

		{

		}

	virtual void SetObjectL(TAny* aObject);

protected:

	void ConstructL();

private:

	/** Constructor */

	CProcessCrashWrapper();

	void PrepareTestL();

	void DoCmdNewL();

	void DoCmdReadCrashInfoL();

	void DoCmdCheckMultipleCrashesL();

	void DoCmdDeleteAllCrashL();

	void DoCmdLoadPluginsL();

	void DoCmdUnLoadPluginsL();

	void DoCmdProcessCrashL(const TDesC&);

	void DoCmdConfigurePluginsL(const TDesC& );

	void DoCmdConfigureSCMZeroPriorityL();

	void DoConfigureL(const TUint32& aIndex, const TUint32& aUID,

			const COptionConfig::TParameterSource& aSource,

			const COptionConfig::TOptionType& aType, const TDesC& aPrompt,

			const TUint32& aNumOptions, const TDesC& aOptions,

			const TInt32& aVal, const TDesC& aStrValue, const TUint aInstance);

	void DoCmdValidateSingleELFFileL();

	void DoCmdValidateAsyncProcessCrashLogL();

	void DoCmdValidateAsyncProcessAndLiveCrashCrashLogL(const TDesC& );

	void GenerateLiveCrashL(const TDesC& );

	void ProcessSELFFileCreatedL();

	void DoProcessSELFLiveandKernelL();

    void DoCmdValidateMultipleELFFileL();

    void DoCmdValidateCpuIDL();

    void DoCmdValidateHeapSELFFileL();

    void DoCmdValidateTraceSELFFileL();

    void DoCmdPerformanceMeasureSELFFileL();

    void DoCmdValidateCorruptCrashL();

	void DoCmdConfigureSELFPluginWithInvalidnessL();

	void ValidateHeaderELFFileL();

	void ValidateProgramHeaderELFFileL();

    void ValidateSymInfoSectionELFFileL();

    void ValidateThreadInfoSectionELFFileL(TBool aValidateCpuId, const TDesC& aThreadCrashed, TBool aCheck);

    void ValidateRegisterInfoSectionELFFileL();

    void ValidateHeapSectionELFFileL(TBool );

    void ValidateTraceSectionELFFileL(TBool );

    void ValidateExceptionL(TInt ,TInt , TBool );

	void ValidateStringL(TValidateString , TInt , const TDesC& , TBool );

	void ValidateTraceBufferL(const TDesC8&  );

	void ValidatePerformanceELFFile();

    void GenerateElfFileL(TUint aCrashId, TBool aTiming = EFalse);

    void MonitorProgressL();

	void ConfigureSELF(TBool , TInt );

	void CleanupMethod(const TDesC& );

	void HelpStartTestTimer(void) { iStartTick = User::NTickCount(); iStopTick = 0; };

	void HelpStopTestTimer(void) { iStopTick = User::NTickCount(); };

	TInt HelpGetTestTicks(void) { return (iStopTick - iStartTick); };

	TInt HelpTicksPerSecond();

	void PrintErrorCondition(TInt );

private:

	/** Object to be tested */

	//session object to the Core Dump Server

	RCoreDumpSession iCoreDumpSession;

	//TCrashInfo structure for crash info

	RCrashInfoPointerList iCrashList;

	//Active Object to handle async processing

	CAsyncProcessCrash* iProcessCrash;

	//File Server session

	RFs iFsSession;

	//File Handle for the ELF File

	RFile iSELFFile;

	//SELF File name

	TBufC<KMaxFileName> iSELFFileName;

	//stores the SELF Program Header

	TUint8* iSELFPHHeader;

	//Number of Program Header Entries

	TInt iPHEntries;

	//Program Header Offset

	TInt iPHOffset;

	//storing crashed thread id

	TInt64 iCrashedThreadId;

	//storing the thread Heap base address

	TUint32	iHeapBase;

	//thread heap size

	TUint32	iHeapSize;

	//thread name that crashed

	RBuf iThreadCrashed;

	//type of crash User/System

	TBool iSystemCrash;

	//stores the DHDR Buffers

	TUint8* iDHDRBuffer[MAXNUMBEROFDHDR];

	//actual SELF DHDR strcuture Sym32_dhdr

	Sym32_dhdr* idhdr[MAXNUMBEROFDHDR];

	//offset to the String section

	TInt iOffsetStringSection;

	//size of String section

	TInt iSizeofStringSection;

	enum TSELFSegment {EHeap, ETrace, ECode, EThread};

	//start and stop tick counts

	TInt iStartTick;

	TInt iStopTick;

	friend class CAsyncProcessCrash;

	};

#endif // __CPROCESSCRASHWRAPPER_H__