/*

* Copyright (c) 2002-2005 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 <s32strm.h>

#include <f32file.h>

#include "senserviceconnectionimpl.h"

#include "sendebug.h"                 // internal Utils\inc - logging MACROs

#include "senlogger.h"

#include "senservicemanagerdefines.h" // internal Core\inc  - IPC enumerations, plus 

                                      // to include KServerUid3 for SEN.EXE SecureID 

                                      // (UID3) that can be nicely used as Property 

                                      // Category UID

#include "senservicedispatcher.h"

namespace

    {

    _LIT(KSenServiceDispatcherThreadName, "SenServiceDispatcher");

    const TInt KTransactionResetValue = 1000;

    }

CSenServiceDispatcher* CSenServiceDispatcher::NewL( RSenServiceConnection&  aConnection,

                                                                        TInt aConnectionID)

    {

    CSenServiceDispatcher* pNew = NewLC(aConnection,aConnectionID);

    CleanupStack::Pop();

    return(pNew) ;

    }

CSenServiceDispatcher* CSenServiceDispatcher::NewLC(RSenServiceConnection&  aConnection,

                                                                        TInt aConnectionID)

    {

    CSenServiceDispatcher* pNew = new (ELeave) CSenServiceDispatcher(aConnection);

    CleanupStack::PushL(pNew);

    pNew->ConstructL(aConnectionID);

    return pNew;

    }

CSenServiceDispatcher::CSenServiceDispatcher(RSenServiceConnection&  aConnection)

    :iConnection(aConnection)

    {

    }

void CSenServiceDispatcher::ConstructL(TInt aConnectionID)

    {

    iConnectionID = aConnectionID;

    ipTransactionsMap = new (ELeave) RTransactionsMap(ETrue, ETrue);

    User::LeaveIfError(iCsMessageQueue.CreateLocal());

    User::LeaveIfError(iCsSynchronizer.CreateLocal());

    User::LeaveIfError(iCsTransctnsMap.CreateLocal());

    RProcess process;

    TFileName threadName;

    threadName.Append( KSenServiceDispatcherThreadName);

    threadName.AppendNum( aConnectionID );

    threadName.Append( KSenUnderline );

    threadName.Append( process.Name().Left(32));

    RAllocator& heap = User::Allocator(); 

    User::LeaveIfError(iDispatcherThread.Create(threadName,

        TThreadFunction(DispatcherThreadL), KDefaultStackSize, &heap, this));

    //Resume the thread so that it should start waiting for any request.

    iDispatcherThread.Resume();

    //set iDispatchMessages = TRUE so that it should start dispacthing the messages

    //when thread gets signaled.

    iDispatchMessages = ETrue;

    }

CSenServiceDispatcher::~CSenServiceDispatcher()

    {

    //Set iDispatchMessages = FALSE to stop dispacthing messages if it already 

    //dispacthing and also to stop the thread which is waiting for any request.

    iDispatchMessages = EFalse;

    if(iCsSynchronizer.IsBlocked())

        {

        iCsSynchronizer.Wait();

        }

    TRequestStatus requestStatus;

    iDispatcherThread.Logon(requestStatus);

    iDispatcherThread.RequestSignal();

    //Wait until dispatcher thread exits

    User::WaitForRequest(requestStatus);

    if(ipTransactionsMap)

        {

        ipTransactionsMap->Reset();

        delete ipTransactionsMap;

         }

    iCsMessageQueue.Close();

    iCsSynchronizer.Close();

    iCsTransctnsMap.Close();

    iDispatcherThread.Close();

    iMessageQueue.Close();

    }

TInt CSenServiceDispatcher::DispatcherThreadL(CSenServiceDispatcher* aThis)

    {

    CTrapCleanup* pCleanup = CTrapCleanup::New();

    CActiveScheduler::Install(NULL); // remove one

    CActiveScheduler* pScheduler = new (ELeave) CActiveScheduler();

    CActiveScheduler::Install(pScheduler);

    RSenDocument::ManualXmlEngineTlsAttachL();

    TInt leaveCode(KErrNone);

    TRAP(leaveCode, CSenServiceDispatcher::ExecuteL(aThis));

    RSenDocument::ManualXmlEngineTlsCleanup();

    CActiveScheduler::Install(NULL); // uninstall scheduler

    delete pScheduler;

    delete pCleanup;

    return leaveCode;

    }

TInt CSenServiceDispatcher::ExecuteL(CSenServiceDispatcher* aThis)

    {

    aThis->OpenDispatcherLogL();

    TLSLOG_L(KSenDispatcherLogChannel, KSenDispatcherLogLevel, "CSenServiceDispatcher::ExecuteL - Resumed.");

    for(;;)

        {

        User::WaitForAnyRequest();

        //If iDispatchMessages = FALSE then stop dispacthing messages.

        //Is called from the destructor and thread will end in cleaner way

        //by deleting the allocated objects on it's heap.

        if(!aThis->iDispatchMessages)

            {

            TLSLOG_L(KSenDispatcherLogChannel, KSenDispatcherLogLevel, "CSenServiceDispatcher::ExecuteL- Called from owner thread's destructor");

            break;

            }

        //Wait on this critical section until all the messages gets dispacthed or 

        //iDispatchMessages = FALSE is set from the destructor.

        aThis->iCsSynchronizer.Wait();

        TLSLOG_L(KSenDispatcherLogChannel, KSenDispatcherLogLevel, "CSenServiceDispatcher::ExecuteL- Dispacthing messages..");

        while(aThis->iMessageQueue.Count() && aThis->iDispatchMessages)

            {

            TThreadMessage thrMessage = aThis->iMessageQueue[0];

            //Send message and get the actual transaction id.

            TInt retVal = 

            aThis->iConnection.SendMsgAndReceiveTxnId(*(thrMessage.iMessage.iSenConnectionChunk));

            TLSLOG_FORMAT((KSenDispatcherLogChannel, KSenDispatcherLogLevel, 

                            _L("- SendMsgAndReceiveTxnId Returned: (%d)"), retVal));

            //Check if remove failed, possible in scenario where transaction has

            //been cancled by client using CancleTransaction(aTransactionID) API,

            //then cancel the request instaed of adding to the transaction map.

            if(aThis->RemoveFromQueue(thrMessage.iVrtalTrnsnID))

                {

                //If RemoveFromQueue is sucess and also SendMsgAndReceiveTxnId 

                //returns actual transaction ID then add to the transaction MAP.    

                TInt* pVrtlaTxnId = new (ELeave) TInt(0);

                *pVrtlaTxnId = thrMessage.iVrtalTrnsnID;

                CleanupStack::PushL(pVrtlaTxnId);

                TInt* pActlTxnId = new (ELeave) TInt(0);

                if (retVal>0)

                    {

                    *pActlTxnId = retVal;

                    }

                CleanupStack::PushL(pActlTxnId);

                //Add the to map as key=virtual transaction ID and 

                //value = actual transaction ID.

                TInt transRetVal = KErrNone;

                transRetVal  = aThis->AddToTheTransMap(pVrtlaTxnId,pActlTxnId);

                TLSLOG_FORMAT((KSenDispatcherLogChannel, KSenDispatcherLogLevel, 

                                _L("- AddToTheTransMap Returned: (%d)"), transRetVal));

                if (transRetVal == KErrNone)

                    {

                    TLSLOG_FORMAT((KSenDispatcherLogChannel, KSenDispatcherLogLevel, 

                                    _L("- Virtual Transaction ID: (%d)"), pVrtlaTxnId));

                    TLSLOG_FORMAT((KSenDispatcherLogChannel, KSenDispatcherLogLevel, 

                                    _L("- Actual Transaction ID: (%d)"), pActlTxnId));

                    CleanupStack::Pop(2);   //pVrtlaTxnId,pActlTxnId

                    }

                else

                    {

                    CleanupStack::PopAndDestroy(2); //pVrtlaTxnId,pActlTxnId

                    }

                }

            else

                {

                    //Mean time if the transaction has been canceled by client

                    //using CancelTransaction(aTranscationID) and then cancel the

                    //same using CancelRequest(aVirtualTransactionID)

                    aThis->iConnection.CancelRequest(thrMessage.iVrtalTrnsnID);

                }

            }   // End of while

        TLSLOG_L(KSenDispatcherLogChannel, KSenDispatcherLogLevel, "CSenServiceDispatcher::ExecuteL- All the message has been dispacthed");

        //Signal the critical section that message dispacthing is over so that it

        // can wait for the another request.

        aThis->iCsSynchronizer.Signal();

        }

    TLSLOG_L(KSenDispatcherLogChannel, KSenDispatcherLogLevel, "CSenServiceDispatcher::ExecuteL - Closing.");

    aThis->CloseDispatcherLogL();

    return KErrNone;

    }

void CSenServiceDispatcher::OpenDispatcherLogL()

    {

#ifdef _SENDEBUG

    RThread thread;

    RProcess process;

    TFileName logFile;

    logFile.Append( KSenDispactherThreadLog().Left(KSenDispactherThreadLog().Length()-4) ); // exclude ".log" file extension

    logFile.AppendNum( iConnectionID );

    logFile.Append( KSenUnderline );

    logFile.Append( process.Name().Left(32));

    logFile.Append( KSenUnderline );

    logFile.Append( thread.Name().Left(20));

    logFile.Append( KSenDispactherThreadLog().Right(4) ); // postfix with ".log" file extension

    // Open connection to the file logger server

    TLSLOG_OPEN( KSenDispatcherLogChannel, KSenDispatcherLogLevel, KSenDispactherThread, logFile );

    TLSLOG_L(KSenDispatcherLogChannel, KSenDispatcherLogLevel, "CSenServiceDispatcher::ExecuteL - About to create new dispatcher thread..");

    TLSLOG_FORMAT((KSenDispatcherLogChannel, KSenDispatcherLogLevel, 

                                _L("- Connection ID: (%d)"), iConnectionID));

#endif

    }

void CSenServiceDispatcher::CloseDispatcherLogL()

    {

    TLSLOG_L(KSenDispatcherLogChannel, KSenDispatcherLogLevel, "Log file closed.");

    TLSLOG_CLOSE( KSenDispatcherLogChannel );

    }

TInt CSenServiceDispatcher::GetDispactherThreadId()

    {

    return iDispatcherThread.Id();

    }

TInt CSenServiceDispatcher::AddToTheQueue(TThreadMessage aThreadMessage)

    {

    TInt appendRetVal(KErrNone);

    //Wait on message queue critical section if it is locked, and then add to 

    //the queue.

    //Critical section is required as RemoveFromQueue(aTrasnactionID) is called

    //from child thread(dispacther thread) also. To avoid crash as iMessageQueue

    //is used by two threads to append as well as to delete from the queue.

    iCsMessageQueue.Wait();

    appendRetVal = iMessageQueue.Append(aThreadMessage);

    iCsMessageQueue.Signal();

    if (appendRetVal == KErrNone)

        {

        //If dispatcher thread already dispatching the messages then no need to signal the 

        //thread as it is already working that is dispacthing the messages from queue.

        if(!iCsSynchronizer.IsBlocked())

            {

            //Signal the thread as it free and waiting for the reqest.

            iDispatcherThread.RequestSignal();

            }

        }  

    return appendRetVal;

    }

TBool CSenServiceDispatcher::RemoveFromQueue(TInt aTransactionID)

    {

    //This method gets called from two places 1)main thread from

    //CancelTransaction(aTransactionID) method and 2)child thread from

    //ExecuteL method once message has been dispacthed.

    TBool found = EFalse;

    iCsMessageQueue.Wait();

    for(TInt i=0;i<iMessageQueue.Count();i++)

        {

        TThreadMessage threadMessage = iMessageQueue[i];

        if(threadMessage.iVrtalTrnsnID == aTransactionID)

            {   

            found = ETrue;

            iMessageQueue.Remove(i);

            if ((++iMessagesQueueCounter) >= KTransactionResetValue)

                {

                iMessageQueue.Compress();

                iMessagesQueueCounter = 0;

                }

            }

        }      

    iCsMessageQueue.Signal();    

    return found;

    }    

TMessage CSenServiceDispatcher::GetMessageFromQueue(TInt aTransactionID)

    {

    TMessage message;

    message.iSenAsyncOperation = NULL;

    message.iSenConnectionChunk = NULL;

    iCsMessageQueue.Wait();

    for(TInt i=0;i<iMessageQueue.Count();i++)

        {

        TThreadMessage threadMessage = iMessageQueue[i];

        if(threadMessage.iVrtalTrnsnID == aTransactionID)

            {

            message.iSenAsyncOperation = threadMessage.iMessage.iSenAsyncOperation;

            message.iSenConnectionChunk = threadMessage.iMessage.iSenConnectionChunk;

            }

        }      

    iCsMessageQueue.Signal();    

    return message;

    }

void CSenServiceDispatcher::ResetQueue()

    {

    iCsMessageQueue.Wait();

    iMessageQueue.Reset();

    iCsMessageQueue.Signal();     

    }    

RTransactionsMap& CSenServiceDispatcher::TransactionMap()

    {

        return *ipTransactionsMap;

    }

TInt CSenServiceDispatcher::AddToTheTransMap(TInt* pVrtlaTxnId,TInt* pActlTxnId)

    {

    TInt returnValue = KErrNone;

    //Wait on transaction map critical section if it is locked, and then add to 

    //the map.

    //Critical section is required as RemoveFromTransMap(aTrasnactionID) is called

    //from main thread also. To avoid crash as ipTransactionsMap

    //is used by two threads to append as well as to delete from the map.

    iCsTransctnsMap.Wait();

    returnValue = TransactionMap().Append(pVrtlaTxnId,pActlTxnId);

    iCsTransctnsMap.Signal(); 

    return returnValue;

    }

TInt CSenServiceDispatcher::RemoveFromTransMap(TInt* pVrtlaTxnId)

    {

    TInt returnValue = KErrNone;

    //Is called from the main thread after we recieve the response.

    returnValue = TransactionMap().Find(*pVrtlaTxnId);

    if( returnValue != KErrNotFound )

        {

        iCsTransctnsMap.Wait();

        returnValue = TransactionMap().RemoveByKey(*pVrtlaTxnId);

        iCsTransctnsMap.Signal(); 

        }

    return returnValue;

    }

TInt CSenServiceDispatcher::UpdateTransMap(TInt* pVrtlaTxnId,TInt* pActlTxnId)

    {

    TInt returnValue = KErrNone;

    //Is called from the main thread from HandleMessageChildAOL method.

    //Typically gets called when ESenReAuthAndResendNeeded and ESenResendNeeded

    //is required.

    returnValue = TransactionMap().Find(*pVrtlaTxnId);

    if( returnValue != KErrNotFound )

        {

        iCsTransctnsMap.Wait();

        returnValue = TransactionMap().UpdateValue(pVrtlaTxnId,pActlTxnId);

        iCsTransctnsMap.Signal(); 

        }

    return returnValue;

    }

TInt CSenServiceDispatcher::GetActualTransactionID(TInt* pVrtlaTxnId)

    {

    //Getter for getting actual transaction ID

    TInt indexValue = TransactionMap().Find(*pVrtlaTxnId);

    if( indexValue != KErrNotFound )

        {

            const TInt* pValueAt = TransactionMap().ValueAt(indexValue);

            return *pValueAt;

        }

    return KErrNotFound;

    }

TInt CSenServiceDispatcher::GetVirtualTransactionID(TInt* pActlTxnId)

    {

    //Getter for getting virtual transaction ID

    TInt indexValue = TransactionMap().FindValue(*pActlTxnId);

    if( indexValue != KErrNotFound )

        {

        const TInt* pKeyAt = TransactionMap().KeyAt(indexValue);

        return *pKeyAt;

        }

    return KErrNotFound;

    }

void CSenServiceDispatcher::SetOwnerThreadId(TInt aOwnerThreadID)

    {

    iOwnerThreadId = aOwnerThreadID;

    }

CSenUnderTakerWaiter* CSenUnderTakerWaiter::NewL(

                            CSenServiceConnectionImpl* aSenServiceConnectionImpl,

                            TInt aDispatcherThreadID )

    {

    CSenUnderTakerWaiter* pNew = NewLC(aSenServiceConnectionImpl,aDispatcherThreadID);

    CleanupStack::Pop();

    return(pNew) ;

    }

CSenUnderTakerWaiter* CSenUnderTakerWaiter::NewLC(

                            CSenServiceConnectionImpl* aSenServiceConnectionImpl,

                            TInt aDispatcherThreadID )

    {

    CSenUnderTakerWaiter* pNew = new (ELeave) CSenUnderTakerWaiter();

    CleanupStack::PushL(pNew);

    pNew->ConstructL(aSenServiceConnectionImpl,aDispatcherThreadID);

    return pNew;

    }

CSenUnderTakerWaiter::~CSenUnderTakerWaiter()

    {

    iSenServiceConnectionImpl = NULL;

    Cancel();

    iUnderTaker.Close();

    }

CSenUnderTakerWaiter::CSenUnderTakerWaiter()

    :CActive(EPriorityNormal)

    {

    CActiveScheduler::Add(this);

    }

void CSenUnderTakerWaiter::ConstructL(CSenServiceConnectionImpl* aSenServiceConnectionImpl,

                                      TInt aDispatcherThreadID )

    {

    iSenServiceConnectionImpl = aSenServiceConnectionImpl;

    iDispatcherThreadID = aDispatcherThreadID;

    User::LeaveIfError(iUnderTaker.Create());

    }

void CSenUnderTakerWaiter::StartWaiter()

    {

    if(!IsActive())

        {

        iUnderTaker.Logon(iStatus,iDyingThreadNumber);

        SetActive();

        }

    }

void CSenUnderTakerWaiter::StopWaiter()

    {

    Cancel();

    }

void CSenUnderTakerWaiter::RunL()

    {

    if(iStatus == KErrDied)

        {

        RThread th;

        th.SetHandle(iDyingThreadNumber);

        TFullName name = th.FullName();

        TExitType type = th.ExitType();

        if(iDispatcherThreadID == th.Id())

            {

            //Notifies client that thread is died. Client has to restart the 

            //connection here.In this case client has to create new SC object.

            if(type == EExitKill)

                {

                if(iSenServiceConnectionImpl)

                    {

                    iSenServiceConnectionImpl->iErrorNumber = EExitKill;

                    iSenServiceConnectionImpl->iTxnId = -1;    

                    iSenServiceConnectionImpl->HandleMessageFromChildAOL(iStatus.Int());

                    }

                }

            else    // panic

                {

                TExitCategoryName categ = th.ExitCategory();

                if(iSenServiceConnectionImpl)

                    {