// 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:
//



/**
 @file
 @internalTechnology
 @released
*/

#ifndef CORE_DUMP_SESSION_H
#define CORE_DUMP_SESSION_H

#include <e32std.h>
#include <e32base.h>
#include <s32file.h>
#include <e32property.h>
#include <bsul\inifile.h>
#include <scmdatatypes.h>

#include <rm_debug_api.h>

// Project inclues
#include <crashdata.h>
#include "coredumpserver.h"
#include <coredumpserverapi.h>
#include <optionconfig.h>
#include <crashdatasave.h>
#include "servercrashdatasource.h"
#include "flashdatasource.h"
#include "coretargetobserver.h"

using namespace Debug;
using namespace BSUL;

        enum TPreProcessingActionType {ENoPreAction = 0, ESuspendThread = 0x1, ESuspendProcess = 0x2};
        enum TPostProcessingActionType {ENoPostAction = 0, EResumeThread = 0x1, EResumeProcess = 0x2, EKillProcess = 0x4, EDeleteCrashLog = 0x5};

/**
Core dump server session that handles messages from core dump clients.
@see CCoreDumpServer
@see RCoreDumpSession
*/
class CCoreDumpSession : public CSession2
	{	
	public:		// Construction
		IMPORT_C static CCoreDumpSession* NewL( RSecuritySvrSession &aSecSess );

	public:		// Destruction
		IMPORT_C ~CCoreDumpSession();
		
	public:		// CCoreDumpSession
		IMPORT_C virtual void ServiceL (const RMessage2& aMessage);

	private:
		CCoreDumpSession( RSecuritySvrSession &aSecSess );

    protected:
		void ConstructL();
		
	private:	// CCoreDumpSession
		void PanicClient(const RMessage2& aMessage, TInt aPanic);
		void DispatchMessageL(const RMessage2& aMessage);

		HBufC8 * MarshalListL( TListRequest & req, TAny * list );
		void GetListL( const RMessage2& aMessage );
		void ListInfoL( const RMessage2& aMessage );

        //make sure that those calls leave
		void GetPluginListL(const RMessage2& aMessage);
		void PluginRequestL(const RMessage2& aMessage);

	//	TInt StartDebugSessionL(const RMessage2& aMessage);

		void RefreshPluginListL();

        void ObservationRequestL( const RMessage2 &aMessage );
        void AttachTargetL( const TDesC &aTargetName, const TDesC &aTargetOwnerName );
        void DetachTargetL( const TDesC &aTargetName, const TDesC &aTargetOwnerName );

		TInt GetByPId( const TUint aPid );

		void CreateFormatterL( const TUid loadRequestUid );
		void CreateWriterL( const TUid loadRequestUid );
        void DeleteFormatterL( const TUid freeRequestUid, const TUint index );
        void DeleteWriterL( const TUid freeRequestUid, const TUint index );

        void BindPluginsL(const TUint aIndex, TUint aPair);
		void SetPluginsL( const TUid aFormatterUID, 
							const TUid aWriterUID, 
							const TBool aLoad );

		void GetNumberConfigParametersL( const RMessage2& aMessage );
		void GetConfigParameterL( const RMessage2& aMessage );
		void SetConfigParameterL( const RMessage2& aMessage );
		void SetConfigParameterL( const TInt aIndex, 
								 const TInt32 & aValue, 
								 const TDesC & aDescValue );

		void UpdateConfigParametersL( );


		void LoadConfigFileL( const RMessage2* aMessage = NULL );
		void SaveConfigFileL( const RMessage2* aMessage = NULL );

		
		enum TCoreDumpIniKey
			{
			EIniKeyType,
			EIniKeyIndex,
			EIniKeyValue
			};

		HBufC * GenerateKeyStringLC( TUint aIndex, 
									 TCoreDumpIniKey aKey );

		void RecreateConfigurationL( BSUL::CIniDocument16 * aPersistConfigData );

		void ChangeConfigParamsL( const COptionConfig::TParameterSource aSource,
								  BSUL::CIniDocument16	*	aPersistConfigData,
                                  const TInt aIndex = -1);

		void SaveConfigParamL(  const COptionConfig	 *	aParam, 
								const TPtrC			 &	aSectName,
								const TInt				aSaveIndex,
								BSUL::CIniDocument16 *	aPersistConfigData );

		void OpenIniFileLC( const RMessage2		  *	aMessage, 
							const TBool				aSaving,
							RFs					  & aFsSession,
							HBufC				 *&	aFileName,
							BSUL::CIniDocument16 *&	aPersistConfigData );

		void OpenIniFileLC( const TBool				aSaving,
							RFs					  & aFsSession,
							HBufC				 *&	aFileName,
							BSUL::CIniDocument16 *&	aPersistConfigData );

		void ReadPluginUidFilesL( );
		
//		void ReadSCMConfigListL();
//		void WriteSCMConfigListL();
		//void UpdateSCMConfigParameterL( TConfigItem::TSCMDataType aDataType, const TInt32 & aPriority );
		
		void ValidatePluginL( const TUid aPluginUid ) const;
        void SetCrashEventsL(CTargetObserver &aObserver, TKernelEventAction aAction);
        
        void RefreshCrashListFromFlashL();
        void GetCrashInfoL(TInt aCrashId, TCrashInfo& aCrashInfo);
        void DeleteCrashLogL(const RMessage2& aMessage);
        void DeleteCrashPartitionL();
        void ProcessCrashLogL(const RMessage2& aMessage);
        void ProcessCrashLogAsyncL(const RMessage2& aMessage);
        void CancelProcessCrashLogAsync(const RMessage2& aMessage);
        void UpdateProgressL(const TDesC &aProgress) const;

    public:
        CCrashDataSource* DataSource() const {return iDataSource;};
        CFlashDataSource* FlashDataSource() const {return iFlashDataSource;};
        CCoreDumpFormatter* GetValidFormatter(const TUint aCount);
        TInt32 PreProcessingAction() const;
        TInt32 PostProcessingAction() const;
        void SuspendProcessL(TUint64 aPid);
        void KillProcessL(TUint64 aPid);
        void ResumeProcessL(TUint64 aPid);
        void ResumeThreadL(TUint64 aTid);
        CCoreDumpServer& Server() const;
        virtual void CreateL();

	private:	// Data members
        RSecuritySvrSession &iSecSess;
		
		TUint					iKeyEvent;
		
        /** keeps list of ECOM plugin types */
		RPluginList				iPluginList;

		TUint					iTotalThreadListDescSize;
		RThreadPointerList      iThreadPointerList; 
		HBufC8*					iMarshalledThreadList;
        
		TUint					iTotalProcessListDescSize;
		RProcessPointerList		iProcessPointerList;
		HBufC8*					iMarshalledProcessList;

		TUint					iTotalExecutableListDescSize;
		RExecutablePointerList	iExecutablePointerList;
		HBufC8*					iMarshalledExecutableList;
		
		//this stores the crashes that are in the flash partition
		TUint					iTotalCrashInfoDescSize;
		RCrashInfoPointerList	iCrashList;
		HBufC8*					iMarshalledCrashList;
		
        typedef RPointerArray<CCoreDumpFormatter> RFormatterPointerList;
        
        /** list of formatter plugin instances */
		RFormatterPointerList	iFormatterPlugins;
		
        /** list of formatter plugin info objects coresponding to actual instances*/
        RPluginPointerList      iFormatterInfos;
		HBufC8*					iMarshalledFormatterList;
		TUint					iTotalFormatterListDescSize;

        typedef RPointerArray<CCrashDataSave> RWriterPointerList;
        
        /** list of writer plugin instances */
		RWriterPointerList		iWriterPlugins;
		
        /** list of writer plugin info objects coresponding to actual instances*/
        RPluginPointerList      iWriterInfos;
		HBufC8*					iMarshalledWriterList;
		TUint					iTotalWriterListDescSize;

		CServerCrashDataSource* iDataSource;
		CFlashDataSource* iFlashDataSource;
        CCrashHandler*			iCrashHandler;

        enum TCrashEventTypes 
			{
			ECrashHwExc = 0x1, 
			ECrashKillThread = 0x2, 
			ECrashHwExcAndKillThread = 0x3
			};

		typedef RPointerArray<CTargetObserver>		RObservationList;
		
		RObservationList iObservationList;

    private:
        TInt32 iPreCrashEventAction;
        TInt32 iPostCrashEventAction;
        TInt32 iCrashEventTypes;


		// Configuration parameters for current system. It is the collection
		// of config params from CDS and currently loaded plugins
		typedef RPointerArray<COptionConfig>	RConfigParameterList;
		RConfigParameterList	  iTotalConfigList; //no need to destroy the content

		/** The maximum size of the configuration parameter that was found 
		when the entire list iTotalConfigList was last updated. It is useful
		when allocating descriptor for client/server transfer */
		TInt					iMaxConfigParamSize;

		/** Configuration parameters for CDS. */
		RConfigParameterList     iConfigList;
		
		/** configuration parameters for SCM configuration */
		RConfigParameterList	 iScmConfigList;
		
		

		TUid					iOurSecureID;
		RArray<TUid>			iAllowedPlugins;

		TUint32					iSpare0;
		TUint32					iSpare1;
		TUint32					iSpare2;
		TUint32					iSpare3;
		TUint32					iSpare4;
		TUint32					iSpare5;
		
    private:
    	void PrintScmConfigL();
    	
    	static void CleanupSCMConfiguration(TAny* );
};

#endif	// CORE_DUMP_SESSION_H