/*

* 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 "senlocaltransportplugin.h"

#include <SenServiceConnection.h>   // errorcode constants, like KErrSenNoEndpoint

#include "msenprovider.h"

#include "senhostletrequest.h"      // internal Provider\inc

#include "senhostletresponse.h"     // internal Provider\inc

#include "senidentifier.h"          // internal Utils\inc

#include "senidentifier.h"          // internal Utils\inc

#include "sendebug.h"               // internal Utils\inc

#include "senprovider.h"            // internal Framework\inc

#include "sensyncrequester.h"       // internal Framework\inc

#include <SenTransportProperties.h> // internal Framework\inc

#include "msentransport.h"

#include "msencoreservicemanager.h" // internal: Core\inc

#include "senlayeredtransportproperties.h"

#include "senhostletrequest.h"      // internal Provider\inc

#include "senguidgen.h"

#include "senlogger.h"

#include <RSenDocument.h>

namespace

    {

//Deleted to fix for compiler warning  #177-D

    //const TInt maxThreadHeapSize(KMinHeapSize*256);

    void threadMainL(TAny* aPtr)

        {

        CSenLocalRequest* pRequest = (CSenLocalRequest*) aPtr;

        pRequest->ExecuteL();

        TRequestStatus* status = &pRequest->iStatus;

        RThread owner;

        TInt error=owner.Open(pRequest->OwnerThreadId());	//CodeScannerWarnings

        if(error != KErrNone)	//CodeScannerWarnings

        {

        }

        owner.RequestComplete(status, CSenLocalRequest::EDeliverResponse ); //iTransactionID );

        // Go safely out of scope (will destroy this thread)

        }

    TInt threadFunction(TAny* aPtr)

        {

        CTrapCleanup* pCleanup = CTrapCleanup::New();

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

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

        CActiveScheduler::Install(pScheduler);

        RSenDocument::ManualXmlEngineTlsAttachL();

        TInt leaveCode(KErrNone);

        TRAP(leaveCode, threadMainL(aPtr));

        RSenDocument::ManualXmlEngineTlsCleanup();

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

        delete pScheduler;

        delete pCleanup;

        return leaveCode;

        }

    }

CSenLocalTransportPlugin* CSenLocalTransportPlugin::NewL(CSenTransportContext* apCtx)

    {

    CSenLocalTransportPlugin* pNew = NewLC(apCtx);

    CleanupStack::Pop(pNew);

    return pNew;

    }

CSenLocalTransportPlugin* CSenLocalTransportPlugin::NewLC(CSenTransportContext* apCtx)

    {

    CSenLocalTransportPlugin* pNew =

        new (ELeave) CSenLocalTransportPlugin(apCtx);

    CleanupStack::PushL(pNew);

    pNew->ConstructL();

    return pNew;

    }

CSenLocalTransportPlugin::CSenLocalTransportPlugin(CSenTransportContext* apCtx)

:   CSenTransport(apCtx),

    ipRequester(NULL),

    iInvokedProvider(NULL),

    iStatusCode(0),

    iTransactionID(0),

    iRequestMap(ETrue, ETrue),

    ipTransportProperties(NULL)

    {

    }

CSenLocalTransportPlugin::~CSenLocalTransportPlugin()

    {

    TLSLOG(KSenLocalTransportLogChannelBase,KMinLogLevel,_L("Log file closed."));

    TLSLOG_CLOSE(KSenLocalTransportLogChannelBase);

    iRequestMap.Reset(); // Cleanup the request queue       

    delete ipRequester;

    delete iInvokedProvider;

    delete ipTransportProperties;

    }

void CSenLocalTransportPlugin::ConstructL()

    {

    // Open connection to the file logger server

    TLSLOG_OPEN(KSenLocalTransportLogChannelBase,KSenLocalTransportLogLevel,KSenLocalTransportLogDir,KSenLocalTransportLogFile);

    TLSLOG_L(KSenLocalTransportLogChannelBase,KMinLogLevel,"CSenLocalTransportPlugin::ConstructL - Log file opened.");

    TLSLOG_L(KSenLocalTransportLogChannelBase,KMinLogLevel,"CSenLocalTransportPlugin::ConstructL - Version 2 [2006-05-09]");    

    MSenCoreServiceManager& core = Context().GetCoreL();

    ipRequester = CSenSyncRequester::NewL(*this, core);

    ipTransportProperties = CSenLayeredTransportProperties::NewL();

    }

TInt CSenLocalTransportPlugin::SubmitL(const TDesC8& aEndpoint,

                                       const TDesC8& aMessage,

                                       const TDesC8& aTransportProperties,

                                       HBufC8*& apResponse,

                                       MSenRemoteServiceConsumer& /*aConsumer*/) 

    {

    TLSLOG_L(KSenLocalTransportLogChannelBase,KMinLogLevel,"CSenLocalTransportPlugin::SubmitL:");

    // Sanity check the endpoint

    if (aEndpoint.Length() <= 0)

        {

        TLSLOG_L(KSenLocalTransportLogChannelBase,KMinLogLevel,"- No endpoint!");

        return KErrSenNoEndpoint; // from SenServiceConnection.h (public API)

        }

    TLSLOG_FORMAT((KSenLocalTransportLogChannelBase,KMinLogLevel, _L8("- Endpoint: %S"), &aEndpoint));

    TLSLOG_L(KSenLocalTransportLogChannelBase,KMaxLogLevel,"- Message:");

    TLSLOG_ALL(KSenLocalTransportLogChannelBase,KMaxLogLevel,( aMessage ));

    TInt leaveCode(KErrNone);

    TInt statusCode(KErrNone);

    /*

    statusCode = ipRequester->SubmitL(aEndpoint,            // endpoint

                                      aMessage,             // request body

                                      aTransportProperties, // request props

                                      apResponse);

    */

    TRAP( leaveCode, statusCode = ipRequester->SubmitL(aEndpoint,            // endpoint

                                                       aMessage,             // request body

                                                       aTransportProperties, // request props

                                                       apResponse); )         // response body

    TLSLOG_FORMAT((KSenLocalTransportLogChannelBase,KMinLogLevel, _L8("CSenLocalTransportPlugin::SubmitL returned: (%d)"), statusCode));

    if(leaveCode!=KErrNone)

        {

        TLSLOG_FORMAT((KSenLocalTransportLogChannelBase,KMinLogLevel, _L8("CSenLocalTransportPlugin::SubmitL leaved: (%d)"), leaveCode));

        if(statusCode==KErrNone)

            {

            statusCode = leaveCode;

            }

        }

    else // did not leave

        {

        if(!apResponse)

            {

            TLSLOG(KSenLocalTransportLogChannelBase,KMinLogLevel,(_L("After calling CSenLocalTransportPlugin::SubmitL => response==NULL => leaving!")));

            User::Leave(KErrCorrupt);

            }

        TLSLOG_L(KSenLocalTransportLogChannelBase,KMaxLogLevel,"CSenLocalTransportPlugin::SubmitL response:");

        TLSLOG_ALL(KSenLocalTransportLogChannelBase,KMaxLogLevel,(*apResponse));

        }

    return statusCode;

    }

TInt CSenLocalTransportPlugin::SendL(const TDesC8& aEndpoint,

                                     const TDesC8& aMessage,

                                     const TDesC8& aTransportProperties,

                                     MSenServiceSession& aReplyTo,

                                     MSenRemoteServiceConsumer& aConsumer, // "addressee", could be CSenIdentifier

                                     TInt& aTxnId)

    {

    TLSLOG_L(KSenLocalTransportLogChannelBase,KMinLogLevel,"CSenLocalTransportPlugin::SendL:");

    // Sanity check the endpoint

    if (aEndpoint.Length() <= 0)

        {

        TLSLOG_L(KSenLocalTransportLogChannelBase,KMinLogLevel,"- No endpoint!");

        return KErrSenNoEndpoint; // from SenServiceConnection.h (public API)

        }

    TLSLOG_FORMAT((KSenLocalTransportLogChannelBase,KMinLogLevel, _L8("- Endpoint: %S"), &aEndpoint));

    TLSLOG_L(KSenLocalTransportLogChannelBase,KMaxLogLevel,"- Message:");

    TLSLOG_ALL(KSenLocalTransportLogChannelBase,KMaxLogLevel,( aMessage ));

    iTransactionID++;

    TInt* txnID = new (ELeave) TInt(iTransactionID);

    aTxnId = iTransactionID;

	CleanupStack::PushL(txnID);	// memory leaks if CSenLocalRequest::NewLC leaves...

    // CSenLocalTransportPlugin::ProviderL method ("local proxy" for single consumer

    // -- since each consumer always owns its own transport) has now been **replaced**

    // with "provider factory" methods implemented to WSF **core**:

    MSenCoreServiceManager& core = Context().GetCoreL();

    CSenLocalRequest* pRequest = CSenLocalRequest::NewLC(aEndpoint,

                                                         aMessage, 

                                                         aTransportProperties,

                                                         aReplyTo,

                                                         aConsumer,

                                                         core,

                                                         *txnID);

#ifdef _SENDEBUG

    //pRequest->SetLogger(iLogger);

#endif // _SENDEBUG

    TInt retVal = iRequestMap.Append(pRequest, txnID);

    if(retVal==KErrNone)

        {

        CleanupStack::Pop(pRequest);

        CleanupStack::Pop(txnID);        

        if(!pRequest->IsActive())

            {

            TLSLOG_L(KSenLocalTransportLogChannelBase,KNormalLogLevel,"- Activating request / async call to the provider.");

            }

        pRequest->iStatus = KRequestPending;

        TRequestStatus* status = &pRequest->iStatus;

        User::RequestComplete( status, CSenLocalRequest::EInvokeService ); //iTransactionID );

        TLSLOG_FORMAT((KSenLocalTransportLogChannelBase,KNormalLogLevel, _L8("- Request status: %d"), pRequest->iStatus.Int()));

        }

    else

        {

        CleanupStack::PopAndDestroy(pRequest); // orphanized request

        CleanupStack::Pop(txnID);

        }

    return retVal; // status code

    }

TInt CSenLocalTransportPlugin::SetPropertiesL(const TDesC8& /* aProperties */,

                                              MSenLayeredProperties::TSenPropertiesLayer /* aTargetLayer */,

											  MSenRemoteServiceConsumer* /*aConsumer*/)

    { 

    return KErrNotSupported; // not implemented

    }

TInt CSenLocalTransportPlugin::PropertiesL(HBufC8*& /* aProperties */)

    {

    return KErrNotSupported; // not implemented

    }

TInt CSenLocalTransportPlugin::CompleteTransaction(const TInt /*aTxnId*/,

                                                         const TInt /*aStatus*/)

    {

    return KErrNotSupported; // not supported by HTTP Channel

    }

TInt CSenLocalTransportPlugin::CancelTransaction(const TInt /* aTxnId */)

    {

    return KErrNotSupported; 

    }

TPtrC8 CSenLocalTransportPlugin::UriSchemeL()

    {

    return KSenLocalTransportUriScheme();

    }

MSenProperties& CSenLocalTransportPlugin::PropertiesL()

    {

    return *ipTransportProperties; 

    }    

/*

RFileLogger* CSenLocalTransportPlugin::Log() const

    {

    return (RFileLogger*) &iLogger;

    }

*/

CSenLocalRequest* CSenLocalRequest::NewLC(const TDesC8& aEndpoint, //MSenProvider& aRequestTo,

                                          const TDesC8& aMessage,

                                          const TDesC8& aTransportProperties,

                                          MSenServiceSession& aReplyTo,

                                          MSenRemoteServiceConsumer& aConsumer, // "addressee", could be CSenIdentifier

                                          MSenCoreServiceManager& aProviderProxy,

                                          TInt aTxnId)

    {

    //CSenLocalRequest* pNew = new (ELeave) CSenLocalRequest(aRequestTo, aReplyTo, aConsumer, aProviderProxy, aTxnId);

    CSenLocalRequest* pNew = new (ELeave) CSenLocalRequest(aEndpoint, aReplyTo, aConsumer, aProviderProxy, aTxnId);

    CleanupStack::PushL(pNew);

    pNew->ConstructL(aMessage, aTransportProperties);

    return pNew;

    }

CSenLocalRequest::CSenLocalRequest(const TDesC8& aEndpoint, //MSenProvider& aRequestTo, 

                                   MSenServiceSession& aReplyTo,

                                   MSenRemoteServiceConsumer& aConsumer,

                                   MSenCoreServiceManager& aProviderProxy,

                                   TInt aTxnId)

: 

    CActive(EPriorityStandard),

    ipProvider(NULL),

    iEndpoint(aEndpoint),

    iProviderProxy(aProviderProxy),

    ipRequestImpl(NULL),

    ipResponseImpl(NULL),

    ipTransportProperties(NULL),

    iReplyTo(aReplyTo),

    iConsumer(aConsumer),

    iTxnId(aTxnId),

    iLeaveCode(KErrNone),

    iRetVal(KErrNone),

    iDelivered(EFalse),

    ipResponse(NULL)

    {

    CActiveScheduler::Add(this);

    }

CSenLocalRequest::~CSenLocalRequest()

    {

    DoCancel();

    delete ipTransportProperties;

    delete ipRequestImpl;

    delete ipResponseImpl;

    iThread.Close();

    delete ipResponse;

    //    delete ipReqIdentifier;

    }

// Called when local request thread crashes due to wrong local provider code

// WS-Stack catches this crash

// Stack still remain stable and communicates the failure to the request or consumer

void CSenLocalRequest::LocalRequestExceptionHandlerL(TExcType aType)

	{

	// Crash is caused by local provider's ServiceL method 

	// So nothing to be handled here and just return request thread

	// died status or OOM

	switch(aType) 

		{

		case EExcStackFault: //stack overflow

		case EExcAccessViolation: //heap memory overflow

			User::Leave(KErrNoMemory);//OOM

			break;

		default:

			User::Leave(KErrDied);

			break;

		}

	}

void CSenLocalRequest::ExecuteL()

    {

    // Allow only single thread to run ServiceL at the same time,

    // this is mandatory, since the provider might be sharable,

    // and providers might then have some status (session data)

    // which could be violated in multi-threaded execution.

    // @see MSenProvider.h

    if(ipProvider->Threadsafe())

        {

        // Only threadsafe providers block access from other threads.

        // The non-threadsafe providers allow multiple threads to get

        // inside ServiceL() - in such case the provider typically

        // needs to implement critical section handling *itself*

        ipProvider->iCriticalSection.Wait(); 

        }

	User::SetExceptionHandler(CSenLocalRequest::LocalRequestExceptionHandlerL, KExceptionFault);

    // try processing the message through the provider - trap any leave

    TRAP(iLeaveCode, iRetVal = ipProvider->ServiceL(*ipRequestImpl, *ipResponseImpl));

    // If no crashes or leaves during ServiceL

    if (iLeaveCode == KErrNone) 

    	{

    	ipResponse = ipResponseImpl->ExtractResponseUtf8();    	

    	}

   	// ipRequestImpl and ipResponseImpl are created within local provider thread

   	// scope. Since these objects involve XmlEngineAttachL and XmlEngineCleanup 

   	// calls, the cleanup is done within the threads scope otherwise XmlEngineCleanup

   	// will happen in main thread's scope which move the xmlengine reference count

   	// below 0, XmlEngine data structures will cleanup. This is unintended behaviour. So

   	// to avoid this cleanup is done within local provider thread scope

   	delete ipRequestImpl;

   	ipRequestImpl = NULL;

    delete ipResponseImpl;

    ipResponseImpl = NULL;  

    if(ipProvider->Threadsafe())

        {

        // Notify next thread that it can proceed and run 

        // ServiceL (needed for sharable providers):

        ipProvider->iCriticalSection.Signal();

        }

    iStatus = KRequestPending;

    }

const TThreadId CSenLocalRequest::OwnerThreadId() const

    {

    return iOwnerThreadId;

    }

void CSenLocalRequest::RunL() 

    {

    TLSLOG_FORMAT((KSenLocalTransportLogChannelBase,KMinLogLevel, _L8("CSenLocalRequest::RunL(), status: %d"), iStatus.Int()));

    switch(iStatus.Int())

        {

        case EInvokeService: // executed in "main", server thread by the ActiveScheduler

            {

            TLSLOG_L(KSenLocalTransportLogChannelBase,KMinLogLevel,"EInvokeService -- ");

#ifdef _SENDEBUG

            TName fullThreadName = iThread.FullName();

            TLSLOG_FORMAT((KSenLocalTransportLogChannelBase,KNormalLogLevel, _L8("'%S'"), &fullThreadName));

#endif // _SENDEBUG

            iThread.Resume(); // this will issue ExecuteL call from *another thread*!

            }

            break;

        case EDeliverResponse: // executed in "main", server thread by the ActiveScheduler

            {

            TLSLOG_L(KSenLocalTransportLogChannelBase,KMinLogLevel,"EDeliverResponse");

            DeliverL();

            }

            break;

        default:

            {

            TLSLOG_L(KSenLocalTransportLogChannelBase,KMinLogLevel,"- Unknown request. Processing not implemented.");

            }

            // unknown

            break;

        }

    } 

void CSenLocalRequest::DeliverL()

    {

    if(iLeaveCode)

        {

        // send error to consumer

        iRetVal = iLeaveCode;

        TLSLOG_FORMAT((KSenLocalTransportLogChannelBase,KMinLogLevel, _L8("CSenProvider::ExecuteL leaved: %d"), iLeaveCode));

        Session().SendErrorToConsumerL(iRetVal, 

                                       NULL, 

                                       TxnId(),

                                       Consumer());

        }

    else        

        {

//        TPtrC8 response = ipResponseImpl->ResponseUtf8();

        //HBufC8* pResponse = ipResponseImpl->ExtractResponseUtf8();

        TLSLOG_L(KSenLocalTransportLogChannelBase,KMaxLogLevel,"CSenLocalRequest::ExecuteL() hostlet response:");

#ifdef _SENDEBUG        

        if( ipResponse )

            {

            TLSLOG_ALL(KSenLocalTransportLogChannelBase,KMaxLogLevel,( *ipResponse ));

            }

        else

            {

            TLSLOG_L(KSenLocalTransportLogChannelBase,KMinLogLevel,"-Fatal(!): pResponse == NULL");

            }

#endif // _SENDEBUG

        if( iRetVal!=KErrNone ) 

            {

            // send error to the consumer

            Session().SendErrorToConsumerL(iRetVal, 

                                           ipResponse, 

                                           TxnId(),

                                           Consumer());

			// Ownership is transferred if response is delivered so no cleanup                                        

            ipResponse = NULL;

            }

        else

            {

            // send message to consumer

            Session().SendToConsumerL(ipResponse, 

                                      TxnId(),

                                      Consumer());

			// Ownership is transferred if response is delivered so no cleanup                                           

            ipResponse = NULL;

            }

        } 

    iProviderProxy.ReleaseHostletL(ipProvider, iThread.FullName(), iConsumer.Id());

    iThread.Close();

    }

void CSenLocalRequest::DoCancel()