// 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
 @internalComponent
*/

#include "coretargetobserver.h"

CTargetObserver::CTargetObserver(RSecuritySvrSession &aSecSession, CCrashHandler &aHandler)
    : CActive(CActive::EPriorityStandard),
    iSecSess(aSecSession),
    iHandler(aHandler),
    iEventInfoPtr( (TUint8*)&iCrashEventInfo, 0, sizeof(TEventInfo) ) 
	{
	CActiveScheduler::Add(this);
	}

CTargetObserver* CTargetObserver::NewL(RSecuritySvrSession &aSecSession, CCrashHandler &aHandler, const TDesC &aProcessName)
{
    LOG_MSG("->CTargetObserver::NewL()\n");
	CTargetObserver* self = CTargetObserver::NewLC(aSecSession, aHandler, aProcessName);
	CleanupStack::Pop(self);
    return self;
}

CTargetObserver* CTargetObserver::NewLC(RSecuritySvrSession &aSession, CCrashHandler &aHandler, const TDesC& aProcessName)
	{
    LOG_MSG("->CTargetObserver::NewLC()\n");
	CTargetObserver *self = new (ELeave) CTargetObserver(aSession, aHandler);
	CleanupStack::PushL(self);
	self->ConstructL(aProcessName);
	return self;
	}

void CTargetObserver::ConstructL(const TDesC& aTargetName)
	{
    LOG_MSG("->CTargetObserver::ConstructL()\n");

	iTargetName.CreateL(aTargetName.Length());
	iTargetName.Copy(aTargetName);
    
	LOG_MSG("CTargetObserver::Observe -> AttachExecutable\n");
    User::LeaveIfError(iSecSess.AttachExecutable( iTargetName, EFalse));
	}

void CTargetObserver::SetCrashEventL(TEventType aType, TKernelEventAction aAction)
{
	LOG_MSG3("->CTargetObserver::SetCrashEventL(type=%d, action=%d)\n", aType, aAction );
    User::LeaveIfError( iSecSess.SetEventAction( iTargetName, aType, aAction ));
}

CTargetObserver::~CTargetObserver()
	{
    LOG_MSG("->CTargetObserver::~CTargetObserver()\n");
	Cancel();
	iTargetName.Close();
    iThreadList.ResetAndDestroy();
	}

void CTargetObserver::DoCancel()
	{
	LOG_MSG( "CTargetObserver::DoCancel -> CancelGetEvent\n");
    TInt err = iSecSess.CancelGetEvent( iTargetName );
    if(err != KErrNone)
        {
        LOG_MSG2( "CTargetObserver::DoCancel - iSecSess.DetachExecutable returned:%d!", err);
        //panic client?? close DSS session?? 
        }

	LOG_MSG("CTargetObserver::DoCancel -> iSecSess.DetachExecutable\n");
    err = iSecSess.DetachExecutable( iTargetName );
    if(err != KErrNone)
        {
        LOG_MSG2( "CTargetObserver::DoCancel iSecSess.DetachExecutable returned:%d!\n", err);
        //panic client?? close DSS session?? 
        }
	}

const TDesC& CTargetObserver::TargetName() const
{
    return iTargetName;
}

TInt CTargetObserver::ThreadCount() const
{
    return iThreadList.Count();
}

const TDesC& CTargetObserver::Thread(TInt aIndex) const
{
    LOG_MSG2("CTargetObserver::Thread(%d)\n", aIndex);
    return *iThreadList[aIndex];
}

void CTargetObserver::AddThreadL(const TDesC &aThreadName)
{
    LOG_MSG("->CTargetObserver::AddThreadL()\n");

    if(HasThread(aThreadName))
    {
        LOG_MSG("->CTargetObserver::AddThreadL() - already exists!\n");
        User::Leave(KErrAlreadyExists);
    }
    
    HBufC *thread;
    thread = HBufC::NewL(aThreadName.Length());
    *thread = aThreadName;
    iThreadList.AppendL(thread);
    LOG_MSG("CTargetObserver::AddThreadL - thread added\n");
}

TBool CTargetObserver::HasThread(const TDesC &aThreadName) const
{
    LOG_MSG("->CTargetObserver::HasThread()");
    TInt count = iThreadList.Count();
    for(TInt i = 0; i < count; ++i)
    {
        if(iThreadList[i]->Des() == aThreadName)
        {
            LOG_MSG("CTargetObserver::HasThreadL - thread found");
            return ETrue;
        }
    }
    LOG_MSG("CTargetObserver::HasThreadL - thread not found");
    return EFalse;
}

void CTargetObserver::DelThreadL(const TDesC &aThreadName)
{
    LOG_MSG("->CTargetObserver::DelThreadL()");

    TInt count = iThreadList.Count();
    for(TInt i = 0; i < count; ++i)
    {
        if(iThreadList[i]->Des() == aThreadName)
        {
            delete iThreadList[i];
            iThreadList.Remove(i);
            LOG_MSG("CTargetObserver::DelThreadL - thread deleted");
            return;
        }
    }

    LOG_MSG("CTargetObserver::DelThreadL - thread not found!");
    User::Leave(KErrNotFound);
}

void CTargetObserver::ClearThreads()
{
    LOG_MSG("->CTargetObserver::ClearThreadsL()\n");
    iThreadList.ResetAndDestroy();
}

// RunL() completes a previously issued Observe call 
void CTargetObserver::RunL()
	{
    LOG_MSG2("->CTargetObserver::RunL(status:%d)", iStatus.Int());
	User::LeaveIfError(iStatus.Int()); //something bad happened

    iCrashEventInfo.iEventTime.UniversalTime(); //not 100% exact time of the crash, but as soon as we are notified about it

    Observe(); 

    RThread thread;
    LOG_MSG2("CTargetObserver::RunL() - opening handle to crashed thread:%Lu\n", iCrashEventInfo.iThreadId);
    TInt err = thread.Open(iCrashEventInfo.iThreadId);
    if(err != KErrNone)
        {
        LOG_MSG2("CTargetObserver::RunL - unable to open thread handle! err:%d\n", err); 
        User::Leave(err);
        }
    CleanupClosePushL(thread); 
    
    if( (iThreadList.Count() == 0) || (HasThread(thread.FullName())) )
        {
        //crash event of the whole process or thread that we observe
        LOG_MSG("CTargetObserver::RunL() -> HandleCrashEventL()");
        iHandler.HandleCrashEventL(iCrashEventInfo);
        }
    else //crash event of thread that we don't care about
        {
        LOG_MSG("CTargetObserver::RunL() - resuming crashed thread");
        iSecSess.ResumeThread(iCrashEventInfo.iThreadId);
        }
    CleanupStack::PopAndDestroy(); //thread

	}


// Report any leave to the client if possible.
TInt CTargetObserver::RunError(TInt aError)
	{
	return KErrNone;
	}

void CTargetObserver::Observe()
	{
	LOG_MSG("->CTargetObserver::Observe()\n");
	iSecSess.GetEvent( iTargetName, iStatus, iEventInfoPtr );
    SetActive(); //wait for crash event
	}