/*

* 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 <SenXmlUtils.h>

//#include "SenHostletConnectionLog.h"

#include "sendebug.h"

#include "senlogger.h"

#include "senhostletconnectionimpl.h"

#include "MSenHostlet.h"              // public

#include "MSenHostletRequest.h"       // public

#include "MSenHostletResponse.h"      // public

#include "senhostletrequest.h"

#include "senhostletresponse.h"

#include "rsenhostletconnection.h"

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

#include "SenXmlServiceDescription.h"

#include "senguidgen.h"  // internal: Utils\inc - the prefix length constant for WSF GUIDs

#include "senchunk.h"

#include "senidentifier.h"

#include "MSenMessage.h"

#include "senconnagentserver.h"

#include "senvtcptransportproperties.h"

#include "SenXmlReader.h"

namespace

    {

    _LIT8( KSenCidPostfix, "@example.org" );

    const TInt KMaxCidLength = 512;

    }

CSenHostletConnectionImpl* CSenHostletConnectionImpl::NewL(MSenHostlet& aProvider)

    {

    CSenHostletConnectionImpl* pNew = NewLC(aProvider);

    CleanupStack::Pop();

    return(pNew) ;

    }

CSenHostletConnectionImpl* CSenHostletConnectionImpl::NewLC(MSenHostlet& aProvider)

    {

    CSenHostletConnectionImpl* pNew = new (ELeave) CSenHostletConnectionImpl(aProvider);

    CleanupStack::PushL(pNew);

    pNew->ConstructL();

    return pNew;

    }

void CSenHostletConnectionImpl::ConstructL()

    {

    TInt connErr = iConnection.Connect();

    TInt connAttemp(0); // max 5 attempts are allowed

    while ( (connErr == KErrServerTerminated || connErr == KErrServerBusy)

                     && connAttemp < KSenMaxClientConnectionOpeningAttempts  )

        {

//        TLSLOG_L(iTlsLogChannel, KSenHostletConnectionLogLevel, "CSenHostletConnection::ConstructL - Server busy/going down");

        User::After(1000000); // wait for a second if server has been shut down

//        TLSLOG_L(iTlsLogChannel, KSenHostletConnectionLogLevel, "CSenHostletConnection::ConstructL - Creating connection");

        connErr = iConnection.Connect();

        connAttemp++;

        }

    if ( connErr != KErrNone )

        {

        User::Leave( connErr );

        }

    iConnectionID = iConnection.ConnectionID();

    iTlsLogChannel = KSenHostletConnectionLogChannelBase + iConnectionID;

    ipRegistrationTimer = CSenRegistrationTimer::NewL( *this );

#ifdef _SENDEBUG

    RThread thread;

    RProcess process;

    TFileName logFile;

    logFile.Append( KSenHostletConnectionLogFile().Left(KSenHostletConnectionLogFile().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( KSenHostletConnectionLogFile().Right(4) ); // postfix with ".log" file extension

    // Open connection to the file logger server

    TLSLOG_OPEN( iTlsLogChannel, KSenHostletConnectionLogLevel, KSenHostletConnectionLogDir, logFile );

    TLSLOG_L(iTlsLogChannel, KMinLogLevel, "CSenHostletConnection::ConstructL - About to establish new hostlet connection..");

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

#endif

    User::LeaveIfError(EstablishConnectionL(iProvider));

    }

CSenHostletConnectionImpl::CSenHostletConnectionImpl(MSenHostlet& aProvider) :

    iProvider(aProvider),

    iErrorNumber(0),

    iErrorNumberBuffer(NULL, 0),

    iTxnId(KErrNotFound),

    iTxnIdBuffer(NULL, 0),

    iHostletTransactionMap(NULL),

    ipSessionId(NULL),

    iSessionIdBuffer(NULL, 0),

    iChunkNameNumber(0),

    ipChunkName(NULL),

    iAlive(ETrue),

    iConnectionID(KErrNotReady),

    iTlsLogChannel(KSenHostletConnectionLogChannelBase),

    iCancelSession(EFalse),

    ipFileProgressObserver(NULL),

    iRegisterFileObserverDone(EFalse),

    ipRegistrationTimer(NULL)

    {

    CActiveScheduler::Add(this);

    }

CSenHostletConnectionImpl::~CSenHostletConnectionImpl()

    {

    delete ipRegistrationTimer; // Invokes connagent registrations & subscribes for RProperty updates

    delete ipFileProgressObserver; // Subscriber (observer) for RProperty update

    TLSLOG(iTlsLogChannel, KMinLogLevel, _L("CSenHostletConnectionImpl::~CSenHostletConnectionImpl"));

    CSenHostletConnectionImpl::Cancel(); // Causes call to DoCancel()

    CSenHostletConnectionImpl::iAlive = EFalse;

   if (iFilesObserver)

        {

        CSenConnAgentServer::Close();

        }

    if (iAsyncOpsArray)

        {

        TInt count(iAsyncOpsArray->Count());

        for(TInt i=0; i<count; i++)

            {

            CSenAsyncOperation* pOp = (*iAsyncOpsArray)[i];

            if ( pOp )

                {

                TRequestStatus* status = &pOp->iStatus;

                User::RequestComplete( status, KErrSenCancelled );

                pOp->iActive = NULL;

                }

            }

        iAsyncOpsArray->ResetAndDestroy();

        delete iAsyncOpsArray;

        }

    if ( iHostletTransactionMap )

        {

        iHostletTransactionMap->Reset();

        delete iHostletTransactionMap;

        }

    delete ipSessionId;

    delete ipChunkName;

    iConnection.Close();

    // Close the log file and the connection to the server.

    TLSLOG_L(iTlsLogChannel, KMinLogLevel, "Log file closed.");

    TLSLOG_CLOSE( iTlsLogChannel );

    //TLSLOG_CLOSE( KSenHostletConnectionLogChannel );

    }

TInt CSenHostletConnectionImpl::Identifier()

    {

    return iConnectionID;    

    }

TInt CSenHostletConnectionImpl::RegisterFilesObserver()

    {

    TLSLOG(iTlsLogChannel, KMinLogLevel, _L("CSenHostletConnectionImpl::RegisterFilesObserver"));

    TInt retVal(KErrNone);

    const TDesC& name = CSenConnAgentServer::Open();

    if (name == KNullDesC)

        {

        return KErrGeneral;

        }

    retVal = iConnection.RegisterTransferObserver(&name, iFilesObserver);

    TLSLOG(iTlsLogChannel, KMinLogLevel, _L("CSenHostletConnectionImpl::RegisterFilesObserver Completed"));

    return retVal; 

    }

TPtrC CSenHostletConnectionImpl::SessionID()

    {

    if(ipSessionId)

        {

        return *ipSessionId;

        }

    else

        {

        return KNullDesC();

        }

    }

TInt CSenHostletConnectionImpl::RespondL(MSenHostletResponse& aResponse)

    {

    TLSLOG_L(iTlsLogChannel, KMinLogLevel, "CSenHostletConnectionImpl::RespondL");

    TInt retVal(KErrNone);

    retVal = HostletTransactionMapL().Find(aResponse.RequestId());

    if ( retVal != KErrNotFound )

        {

        CSenHostletTransaction* pTransaction = (CSenHostletTransaction*)HostletTransactionMapL().ValueAt(retVal);

        CSenChunk* pOperation = (CSenChunk*)pTransaction->Chunk();

        if ( pOperation )

            {

            // First check whether this request has ALREADY BEEN responded (to prevent multiple RespondL

            // calls performed inside MSenHostlet::ServiceL / per single request):

            MSenMessage::TDirection direction = pOperation->ChunkHeader().MessageDirection();

            if( direction == MSenMessage::EOutbound )

                {

                // Note: direction is always consumers point of view. So outbound here

                // means "a request from consumer" - inbound would be "response to consumer".

                // Note: this sort of really double-safety action, since hostlet transport plugin also turns the 

                // direction to "inbound" before sending responses to consumers. But better be safe than sorry

                pOperation->ChunkHeader().SetMessageDirection( MSenMessage::EInbound );

                MSenProperties* pProperties = aResponse.ResponseProperties();

                if( pProperties )

                    {

                    // Serialize properties

                    HBufC8* pPropsAsXml = pProperties->AsUtf8LC();

                    // Store the properties class type into chunk

                    MSenProperties::TSenPropertiesClassType type

                        = pProperties->PropertiesClassType();

                    pOperation->ChunkHeader().SetPropertiesType( type );

                    // Store response message AND properties into chunk

                    TPtrC8 properties = pPropsAsXml->Des();

                    pOperation->DescsToChunk( aResponse.ResponseUtf8(), properties );

                    CleanupStack::PopAndDestroy(pPropsAsXml);

                    }

                else

                    {

                    // There is only a response message. Store it into chunk.

                    pOperation->ChunkHeader().SetPropertiesType(MSenProperties::ENotInUse);

                    pOperation->DescToChunk( aResponse.ResponseUtf8() );

                    }            

                CSenAsyncOperation* pSenAO = CSenAsyncOperation::NewL(this);

                iConnection.ProvideResponse(pSenAO->iStatus, 

                                            pSenAO->iErrorNumberBuffer,

                                            pSenAO->iTxnIdBuffer,

                                            *pOperation,

                                            aResponse.ResponseCode());

                }

            else

                {

                retVal = KErrAlreadyExists; 

                }                

            }

        else

            {

            retVal = KErrNotFound; 

            }

        }

    TLSLOG_FORMAT((iTlsLogChannel, KNormalLogLevel, _L8("- ProvideResponse returned: %d"), retVal));

    return retVal;

    }

// This method is executed when one of the static constructors of

// service connection (NewL or NewLC) is called.

TInt CSenHostletConnectionImpl::EstablishConnectionL(MSenHostlet& aProvider)

    {

    TLSLOG_L(iTlsLogChannel, KMinLogLevel, "CSenHostletConnectionImpl::InitializeL");

	TInt retVal = KErrNone;

    ipInterface = NULL;

    ipInterface = aProvider.GetInterfaceByUid(KSenInterfaceUidFilesObserver);

    if(ipInterface)

    {

        iFilesObserver = (MSenFilesObserver*) ipInterface;

        if ( !iRegisterFileObserverDone )

            {

            TLSLOG_L( iTlsLogChannel, KMinLogLevel, "EstablishConnectionL(): - Calling IssueRegistrations()");

            ipRegistrationTimer->IssueRegistrations( ETrue );

                TLSLOG_L(iTlsLogChannel, KMinLogLevel ,"- RegisterFilesObserver() failed!");

            } // end of if ( !iRegisterFileObserverDone )

    }

    if(retVal == KErrNone)

        {

    TPtrC8 endpoint     = aProvider.Endpoint();

    TPtrC8 contract     = aProvider.Contract();

    TPtrC8 frameworkId  = aProvider.FrameworkId();

    CSenXmlServiceDescription* pDescription = CSenXmlServiceDescription::NewLC(endpoint, contract);

    pDescription->SetFrameworkIdL(frameworkId);

    aProvider.DescribeServiceL(*pDescription);

    if(pDescription->Endpoint().Length()==0 && pDescription->Contract().Length()==0)

        {

        User::Leave(KErrSenNoContractNoEndPoint);

        }

    if ( pDescription->Endpoint().Length() == 0 )

        {

#ifdef EKA2            

        RProcess process;

        TSecureId sId = process.SecureId();

        if ( sId == 0 )

            {

            User::Leave(KErrSenNoEndpoint);

            }

        TBuf8<128> buf;

        TUint i(sId);

        _LIT8(KFormat, "%u");

        buf.Format(KFormat, i);

        pDescription->SetEndPointL(buf);

#else

        User::Leave(KErrSenNoEndpoint); // in EKA1, endpoints are not generated!

#endif // EKA2/EKA1        

        }

    // Ensure that hostlet connection transport-plugin cue is applied,

    // unless the application has specified some other plug-in:

    TPtrC8 cue = pDescription->TransportCue();

    if( cue.Length() == 0 )

        {

        // Set the default cue (hostlet connection transport plug-in) to the XML SD:

        pDescription->SetTransportCueL(KSenTransportCueHostletConnection);

//        LOG_WRITEFORMAT((_L8("- Setting the default transport cue: '%S'"), &KSenTransportCueHostletConnection()));

        }

#ifdef _FORCE_DESCRIBED_MSW_2005_08_CONTRACT_TO_2006_10

    /// // Hard coded workaround for update hostlet contract: // ///

    //     Update contract from 2005 => 2006

    _LIT8( KMessaging200508, "http://schemas.live.com/mws/2005/08/messaging" );

    _LIT8( KMessaging200510, "http://schemas.live.com/mws/2006/10/messaging" );

    if( pDescription->Contract() == KMessaging200508 )

        {

        pDescription->SetContractL( KMessaging200510 );

        }

#endif // _FORCE_DESCRIBED_MSW_2005_08_CONTRACT_TO_2006_10

#ifdef _SENDEBUG

    //TPtrC8 providerID  = ((CSenXmlServiceDescription&)aSD).ProviderId();

    TLSLOG_L(iTlsLogChannel, KMinLogLevel, "-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|");

    TLSLOG_FORMAT((iTlsLogChannel, KMinLogLevel, _L8("- FrameworkID:  %S"), &frameworkId ));

    TLSLOG_FORMAT((iTlsLogChannel, KMinLogLevel, _L8("- Endpoint:     %S"), &endpoint ));

    TLSLOG_FORMAT((iTlsLogChannel, KMinLogLevel, _L8("- Contract:     %S"), &contract ));

    TLSLOG_FORMAT((iTlsLogChannel, KMinLogLevel, _L8("- TransportCue: %S"), &cue ));

//    LOG_WRITEFORMAT((iTlsLogChannel, KSenHostletConnectionLogLevel, _L8("- ProviderID:  %S"), &providerID ));

    TLSLOG_L(iTlsLogChannel, KMinLogLevel, "-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|");

#endif //_SENDEBUG            

    HBufC8* pServiceDescriptionXml = pDescription->AsXmlL();

    CleanupStack::PopAndDestroy(pDescription);

    CleanupStack::PushL(pServiceDescriptionXml);

#ifdef _SENDEBUG

    TLSLOG_L(iTlsLogChannel, KMinLogLevel, "CSenHostletConnectionImpl::EstablishConnectionL - Service description:");

    if ( pServiceDescriptionXml )

        {

            TPtrC8 xml = pServiceDescriptionXml->Des();

            TLSLOG_ALL(iTlsLogChannel, KMinLogLevel, (xml));

        }

#endif // _SENDEBUG

	 if ( pServiceDescriptionXml )

		{

			TPtr8 ptrServiceDescriptionXml(pServiceDescriptionXml->Des());

			retVal = iConnection.Establish(ptrServiceDescriptionXml);

		}

		else

		{

	    TLSLOG_L(iTlsLogChannel, KMinLogLevel, "EstablishConnectionL ---- Returning KErrGeneral");		

		retVal = KErrGeneral;

		}

    TLSLOG_FORMAT((iTlsLogChannel, KNormalLogLevel, _L("- Establish returned: %d"), retVal));

    User::LeaveIfError( retVal );

    CleanupStack::PopAndDestroy(pServiceDescriptionXml);

    // Start awaiting for next hostlet request

    iErrorNumber = 0;

    iTxnId = 0;

    CSenAsyncOperation* pSenAO = CSenAsyncOperation::NewL(this); // appends itself into array

    // NOTE, following ASYNC AwaitRequest() will stay as pending IPC -operation; this is the design:

    iConnection.AwaitRequest(pSenAO->iStatus, pSenAO->iErrorNumberBuffer, pSenAO->iTxnIdBuffer); 

        }

	TLSLOG_L(iTlsLogChannel, KMinLogLevel, "CSenHostletConnectionImpl::InitializeL Completed");        

    return retVal;

    }

void CSenHostletConnectionImpl::RunL()

    {

    TLSLOG_FORMAT((iTlsLogChannel, KNormalLogLevel, _L("CSenHostletConnectionImpl::RunL( %d )"),  iStatus.Int()));

    }

void CSenHostletConnectionImpl::HandleErrorFromChildAOL(TInt aError, TInt aTxnId, const TDesC8& aDesc, CSenAsyncOperation& aChild )

    {

    TLSLOG_L(iTlsLogChannel, KMinLogLevel, "CSenHostletConnectionImpl::HandleErrorFromChildAOL");

    TInt leaveCode(KErrNone);

    TRAP( leaveCode, iProvider.OnServiceCompleteL(aTxnId, aError, aDesc); )

    HostletTransactionMapL().RemoveByKey(aTxnId);

    TLSLOG_L(iTlsLogChannel, KMinLogLevel, "CSenHostletConnectionImpl::HandleErrorFromChildAOL:");

#ifdef _SEDEBUG

    if( leaveCode != KErrNone ) 

        {

        TLSLOG_FORMAT((iTlsLogChannel, KMinLogLevel, _L(" - OnServiceCompleteL leaved: %d"), leaveCode));

        }

    if( aChild.iStatus.Int() == ESenOnServiceComplete && aError == KErrSenCancelled )

        {

        TLSLOG_L(iTlsLogChannel, KMinLogLevel, "- Await was cancelled (ESenOnServiceComplete).");

        }

#endif // _SENDEBUG

    if( aChild.iStatus.Int() == ESenOnServiceComplete && iAlive )

        {

        CSenAsyncOperation* pSenAO = CSenAsyncOperation::NewL(this); // appends itself into array

        iConnection.AwaitRequest(pSenAO->iStatus, pSenAO->iErrorNumberBuffer, pSenAO->iTxnIdBuffer); 

        }

    leaveCode = 0; // not used in release builds

    TLSLOG_L(iTlsLogChannel, KMinLogLevel, "CSenHostletConnectionImpl::HandleErrorFromChildAOL Completed");

    }

void CSenHostletConnectionImpl::HandleMessageFromChildAOL(TInt aStatus, CSenAsyncOperation& aChild)

    {

    TLSLOG_FORMAT((iTlsLogChannel, KMinLogLevel, _L("CSenHostletConnectionImpl::HandleMessageFromChildAOL( %d )"), aStatus));

    iAsyncOpsCount--;

//    TLSLOG_FORMAT((iTlsLogChannel, KSenHostletConnectionLogLevel, _L("One asynchronous operation completed. Pending iAsyncOpsCount: %i"), iAsyncOpsCount));

    TLSLOG_FORMAT((iTlsLogChannel, KNormalLogLevel, _L("One asynchronous operation completed. Pending iAsyncOpsCount: %i"), iAsyncOpsCount));

    if ( aStatus == ESenOnServiceComplete) // temporary: implement "acquire request handle" operation and use switch case here..

        {

        TInt leaveCode(KErrNone);

        TRAP(leaveCode, iProvider.OnServiceCompleteL(aChild.iTxnId, aChild.iErrorNumber, KNullDesC8); ) 

        HostletTransactionMapL().RemoveByKey(aChild.iTxnId);

        TLSLOG_L(iTlsLogChannel, KMinLogLevel, "CSenHostletConnectionImpl::HandleMessageFromChildAOL: ESenOnServiceComplete");

#ifdef _SEDEBUG

        if( leaveCode != KErrNone ) 

            {

            TLSLOG_FORMAT((iTlsLogChannel, KMinLogLevel, _L(" - OnServiceCompleteL leaved: %d"), leaveCode));

            }

        if( aChild.iErrorNumber == KErrSenCancelled )

            {

            TLSLOG_L(iTlsLogChannel, KMinLogLevel, "- Await was cancelled.");

            }

#endif // _SENDEBUG

        if( aChild.iErrorNumber != KErrSenCancelled && iAlive )

            {

            CSenAsyncOperation* pSenAO = CSenAsyncOperation::NewL(this); // appends itself into array

            // NOTE, following ASYNC AwaitRequest() will stay as pending IPC -operation; this is the design:

            iConnection.AwaitRequest(pSenAO->iStatus, pSenAO->iErrorNumberBuffer, pSenAO->iTxnIdBuffer); 

            }

        leaveCode = 0; // not used in release builds

        }

    else if ( aStatus > KErrNone )

        {

        TLSLOG_L(iTlsLogChannel, KMinLogLevel, "- handle received.");

        CSenChunk* pOperation = CSenChunk::NewLC(KNullDesC);

        TInt retVal = pOperation->OpenChunkFromHandleNumberL(aStatus);

        if ( retVal == KErrNone )

            {

            CSenHostletTransaction* pHostletTxn = CSenHostletTransaction::NewL(pOperation);

            CleanupStack::Pop(pOperation);

            CleanupStack::PushL(pHostletTxn);

            TInt* pTxnId = new (ELeave) TInt(pOperation->ChunkHeader().TransactionId());

            CleanupStack::PushL(pTxnId);

            retVal = HostletTransactionMapL().Append(pTxnId, pHostletTxn);

            if ( retVal == KErrNone )

                {

                CleanupStack::Pop(pTxnId);

                CleanupStack::Pop(pHostletTxn);

                TPtrC8 request;

                retVal = pOperation->DescFromChunk(request);

                if ( retVal == KErrNone )

                    {

                    RThread thread;

                    CSenIdentifier* pIdentifier = CSenIdentifier::NewL();

                    pHostletTxn->SetIdentifier(pIdentifier);

                    CSenHostletRequest* pRequest =

                            CSenHostletRequest::NewL(pOperation->ChunkHeader().TransactionId(),

                                                     request,

                                                     thread,