/*

* 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 <e32property.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 <SenServicePattern.h>

#include <SenXmlServiceDescription.h>

#include <SenXmlUtils.h>

#include "SenHttpTransportProperties.h"

#include <SenIdentityProvider.h>

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

#include "senchunk.h"

#include "senmessagebase.h"

#include "SenSoapEnvelope2.h"

#include "SenParser.h"

#include "senservicemanagerdefines.h"

#include "SenBaseAttribute.h"

#include <xmlengchunkcontainer.h>

#include <xmlengfilecontainer.h>

#include <xmlengserializer.h>

#include "senconnagentserver.h"

#include "senxmldebug.h"

#include "senatomentry.h"

namespace

    {

    const TInt KMaxChunkNumDecimals = 64;

    _LIT8(KIdentityProviderName, "IdentityProvider");

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

    const TInt KMaxCidLength = 512;

    }

#ifdef RD_SEN_ENABLE_USE_OF_WSD_IN_SC_FOR_HW_TARGET

// in hardware, we can use static variable

TInt CSenConnectionChunk::iServOpenChunkCount;   

#endif    

CSenServiceConnectionImpl* CSenServiceConnectionImpl::NewL(MSenServiceConsumer& aObserver,

                                                           const TDesC8& aContract)

    {

    CSenServiceConnectionImpl* pNew = NewLC(aObserver, aContract);

    CleanupStack::Pop();

    return(pNew) ;

    }

CSenServiceConnectionImpl* CSenServiceConnectionImpl::NewLC(MSenServiceConsumer& aObserver,

                                                            const TDesC8& aContract)

    {

    CSenServiceConnectionImpl* pNew = new (ELeave) CSenServiceConnectionImpl(aObserver, NULL);

    CleanupStack::PushL(pNew);

    CSenXmlServiceDescription* pSD =

            CSenXmlServiceDescription::NewLC(KNullDesC8, aContract);

    pNew->ConstructL(*pSD);

    CleanupStack::PopAndDestroy(); // pServicePattern

    return pNew;

    }

CSenServiceConnectionImpl* CSenServiceConnectionImpl::NewL(MSenServiceConsumer& aObserver,

                                                           MSenServiceDescription& aPattern)

    {

    CSenServiceConnectionImpl* pNew = NewLC(aObserver, aPattern);

    CleanupStack::Pop();

    return(pNew) ;

    }

CSenServiceConnectionImpl* CSenServiceConnectionImpl::NewLC(MSenServiceConsumer& aObserver,

                                                            MSenServiceDescription& aPattern)

    {

    CSenServiceConnectionImpl* pNew =

                            new (ELeave) CSenServiceConnectionImpl(aObserver, NULL);

    CleanupStack::PushL(pNew);

    pNew->ConstructL(aPattern);

    return pNew;

    }

CSenServiceConnectionImpl* CSenServiceConnectionImpl::NewL(MSenServiceConsumer& aObserver,

                                                           CSenServicePattern& aServicePattern)

    {

    CSenServiceConnectionImpl* pNew = NewLC(aObserver, aServicePattern);

    CleanupStack::Pop();

    return(pNew) ;

    }

CSenServiceConnectionImpl* CSenServiceConnectionImpl::NewLC(MSenServiceConsumer& aObserver,

                                                            CSenServicePattern& aServicePattern)

    {

    CSenServiceConnectionImpl* pNew = new (ELeave) CSenServiceConnectionImpl(aObserver, NULL);

    CleanupStack::PushL(pNew);

    pNew->ConstructL(aServicePattern);

    return pNew;

    }

CSenServiceConnectionImpl* CSenServiceConnectionImpl::NewL(MSenServiceConsumer& aConsumer,

                                                           const TDesC8& aContract,

                                                           MSenExtendedConsumerInterface& aExtendedConsumer)

    {

    CSenServiceConnectionImpl* pNew = NewLC(aConsumer, aContract, aExtendedConsumer);

    CleanupStack::Pop();

    return(pNew) ;

    }

CSenServiceConnectionImpl* CSenServiceConnectionImpl::NewLC(MSenServiceConsumer& aConsumer,

                                                            const TDesC8& aContract,

                                                            MSenExtendedConsumerInterface& aExtendedConsumer)

    {

    CSenServiceConnectionImpl* pNew = new (ELeave) CSenServiceConnectionImpl(aConsumer, &aExtendedConsumer);

    CleanupStack::PushL(pNew);

    CSenXmlServiceDescription* pSD =

            CSenXmlServiceDescription::NewLC(KNullDesC8, aContract);

    pNew->ConstructL(*pSD);

    CleanupStack::PopAndDestroy(); // pServicePattern

    return pNew;

    }

CSenServiceConnectionImpl* CSenServiceConnectionImpl::NewL(MSenServiceConsumer& aConsumer,

                                                                MSenServiceDescription& aServiceDescription,

                                                           MSenExtendedConsumerInterface& aExtendedConsumer)

    {

    CSenServiceConnectionImpl* pNew = NewLC(aConsumer, aServiceDescription, aExtendedConsumer);

    CleanupStack::Pop();

    return(pNew) ;

    }

CSenServiceConnectionImpl* CSenServiceConnectionImpl::NewLC(MSenServiceConsumer& aConsumer,

                                                                MSenServiceDescription& aServiceDescription,

                                                                MSenExtendedConsumerInterface& aExtendedConsumer)

    {

    CSenServiceConnectionImpl* pNew =

                            new (ELeave) CSenServiceConnectionImpl(aConsumer,&aExtendedConsumer);

    CleanupStack::PushL(pNew);

    pNew->ConstructL(aServiceDescription);

    return pNew;        

    }

CSenServiceConnectionImpl* CSenServiceConnectionImpl::NewL(MSenServiceConsumer& aConsumer,

                                                           CSenServicePattern& aServicePattern,

                                                           MSenExtendedConsumerInterface& aExtendedConsumer)

    {

    CSenServiceConnectionImpl* pNew = NewLC(aConsumer, aServicePattern, aExtendedConsumer);

    CleanupStack::Pop();

    return(pNew) ;

    }

CSenServiceConnectionImpl* CSenServiceConnectionImpl::NewLC(MSenServiceConsumer& aConsumer,

                                                            CSenServicePattern& aServicePattern,

                                                            MSenExtendedConsumerInterface& aExtendedConsumer)

    {

    CSenServiceConnectionImpl* pNew = new (ELeave) CSenServiceConnectionImpl(aConsumer,&aExtendedConsumer);

    CleanupStack::PushL(pNew);

    pNew->ConstructL(aServicePattern);

    return pNew;

    }

void CSenServiceConnectionImpl::ConstructL(MSenServiceDescription& aSD)

    {

    CSenElement& sdAsElement = ((CSenXmlServiceDescription&)aSD).AsElement();

    // Check if this is an internal service connection:

    const TDesC8* pInternal = sdAsElement.AttrValue( KSenAttrInternalSC );

    if( pInternal )

        {

        iIsInternalSC = ETrue;

        TLSLOG_L(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel ,"This is 'internal SC' => Will NOT create CSenConnectionStatusObserver.");

        delete SenXmlUtils::RemoveAttributeL(sdAsElement, KSenAttrInternalSC);

        iDispatcherEnabled = EFalse;

        }

    else // not internal, but starndard SC

        {

        TLSLOG_L(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel ,"This is normal SC => Creating CSenConnectionStatusObserver.");

#ifdef RD_SEN_SC_MSG_DISPATCHER_ENABLED

        // Dispatcher is enabled ONLY IF the feature is NOT DISABLED AT COMPILER LEVEL:

        iDispatcherEnabled = ETrue; // ==> Default to using the dispatcher with any "normal" SC

#endif // RD_SEN_SC_MSG_DISPATCHER_ENABLED

        }

    // Check if dispatcher is EXPLICITELY DISABLED (no matter if this is internal or not)

    const TDesC8* pDispatcherDisabled = sdAsElement.AttrValue( KSenAttrDisableDispatcherSC );

    if( pDispatcherDisabled )

        {

        TLSLOG_L(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel ,"Dispatcher is EXPLICITELY DISABLED for this SC.");

        delete SenXmlUtils::RemoveAttributeL(sdAsElement, KSenAttrDisableDispatcherSC );

        // Dispatcher is NOW EXPLICITELY DISABLED

        iDispatcherEnabled = EFalse; 

        }

    ipInitPatternAsXml = aSD.AsXmlL();

    if( aSD.DescriptionClassType() == MSenServiceDescription::EServicePattern )

        {

        CSenServicePattern* pServicePattern = (CSenServicePattern*)&aSD;

        ipInitConsumerPolicyAsXml = pServicePattern->ConsumerPolicyAsXmlL();

        }

    ipRegistrationTimer = CSenRegistrationTimer::NewL( *this );        

/*    

#ifdef _SENDEBUG

    TPtrC8 frameworkID = aSD.FrameworkId();

    TPtrC8 endpoint    = aSD.Endpoint();

    TPtrC8 contract    = aSD.Contract();

    TLSLOG_L(KSenServiceConnectionLogChannelBase+iConnectionID, KMaxLogLevel ,"-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|");

    TLSLOG_FORMAT((KSenServiceConnectionLogChannelBase+iConnectionID, KMaxLogLevel , _L8("- FrameworkID: %S"), &frameworkID ));

    TLSLOG_FORMAT((KSenServiceConnectionLogChannelBase+iConnectionID, KMaxLogLevel , _L8("- Endpoint:    %S"), &endpoint ));

    TLSLOG_FORMAT((KSenServiceConnectionLogChannelBase+iConnectionID, KMaxLogLevel , _L8("- Contract:    %S"), &contract ));

    TLSLOG_L(KSenServiceConnectionLogChannelBase+iConnectionID, KMaxLogLevel ,"-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|");

#endif //_SENDEBUG           

*/

#ifndef RD_SEN_SC_PROXY_ENABLED_BY_DEFAULT

    ConnectL(); 

// #else // ConnectL occurs on  "proxy" / factory  -level

    }

void CSenServiceConnectionImpl::ConnectL()

    {

    ipSessionId = HBufC::NewL(KSenUuidMaxLength); 

    ipChunkName = HBufC::NewL(KSenUuidMaxLength+KMaxChunkNumDecimals);

    iSessionIdBuffer.Set(ipSessionId->Des());

    TLSLOG_OPEN(KSenServiceConnectionLogChannel, KSenServiceConnectionLogLevel, KSenServiceConnectionLogDir, KSenServiceConnectionLogFile);

    TInt connErr = iConnection.Connect();

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

    while ( (connErr == KErrServerTerminated

                     ||

             connErr == KErrServerBusy)

                     &&

             connAttemp < KSenMaxClientConnectionOpeningAttempts )

        {

//        TLSLOG_L(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel," - Server terminated/busy/max_conns => waiting.");

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

//        TLSLOG_L(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel," - Wait is over.");

        connErr = iConnection.Connect();

        connAttemp++;

        }

    if ( connErr != KErrNone )

        {

        User::Leave( connErr );

        }

    if( iDispatcherEnabled ) // DISPATCHER IS ENABLED

        {

        TInt iShareAuto = iConnection.ShareAuto();

        if(iShareAuto != KErrNone )

            {

            User::Leave( iShareAuto );

            }

        }

    iConnectionID = iConnection.ConnectionID();

    iConnection.SetChannel(KSenServiceConnectionLogChannelBase+iConnectionID);   

    iTlsLogStatusChannel = KSenServiceConnectionStatusLogChannelBase + iConnectionID;

#ifdef _SENDEBUG   

    RProcess process; 

    RThread thread;

    TFileName logFile;

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

//    KSenServiceConnectionChannelBase

    TLSLOG_OPEN(KSenServiceConnectionLogChannelBase+iConnectionID, KSenServiceConnectionLogLevel, KSenServiceConnectionLogDir, logFile);

    // Open connection to the file logger server

    TLSLOG_L(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,"CSenServiceConnection::ConstructL - Log file opened");

    TLSLOG_L(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel ,"- About to initialize service connection");

    TLSLOG_FORMAT((KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel , _L8("- Connection ID: (%d)"), iConnectionID));

    logFile.Zero();

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

    TLSLOG_OPEN( iTlsLogStatusChannel, KSenServiceConnectionStatusLogLevel, KSenServiceConnectionLogDir, logFile );

    TLSLOG_OPEN(KSenMessagesLogChannel, KSenMessagesLogLevel, KSenMessages, KSenMessagesLog);

#endif // _SENDEBUG    

    iFragment = CSenBaseFragment::NewL(KServiceConnectionElementLocalName);

    InitializeL( /*aSD*/ );

    if( iDispatcherEnabled ) // DISPATCHER IS ENABLED

        {

        RThread aThread;

        iOwnerThreadId = aThread.Id();

        ipSenServiceDispatcher = CSenServiceDispatcher::NewL(iConnection,iConnectionID);

        ipSenServiceDispatcher->SetOwnerThreadId(iOwnerThreadId);

        TInt dispatcherThreadID = ipSenServiceDispatcher->GetDispactherThreadId();

        //    ipSenUnderTakerWaiter = CSenUnderTakerWaiter::NewL(this,dispatcherThreadID);

        //    ipSenUnderTakerWaiter->StartWaiter();

        }

    }

void CSenServiceConnectionImpl::SetConsumer( MSenServiceConsumer& aConsumer, MSenExtendedConsumerInterface* apExtConsumer )

    {

    iObserver = &aConsumer;

    ipExtendedConsumerInterface = apExtConsumer;

    }

void CSenServiceConnectionImpl::Consumer( MSenServiceConsumer*& aConsumer, MSenExtendedConsumerInterface*& apExtConsumer )

    {

    aConsumer = iObserver;

    apExtConsumer = ipExtendedConsumerInterface;

    }   

TPtrC8 CSenServiceConnectionImpl::InitDescription()

    {

    return *ipInitPatternAsXml;

    }

CSenServiceConnectionImpl::CSenServiceConnectionImpl(MSenServiceConsumer& aObserver,

                                                     MSenExtendedConsumerInterface* aExtendedConsumerInteface)

 :  iConnection(&iLog),

    iObserver(&aObserver),

    iInBuf(NULL),

    iInBuffer(NULL,0),

    iOutBuf(NULL),

    iOutBuffer(NULL,0),

    iInitialized(EFalse),

    iFragment(NULL),

    iResponseLength(0),

    iErrorNumber(0),

    iErrorNumberBuffer(NULL, 0),

    iTxnId(0),

    iTxnIdBuffer(NULL, 0),

    iChunkMap(NULL),

    ipSessionId(NULL),

    iSessionIdBuffer(NULL, 0),

    iChunkNameNumber(0),

    ipChunkName(NULL),

    iResponse(NULL),

    ipInitChunk(NULL),

    ipCompleteServerMsgsOnOff(NULL),

    iConnectionID( KErrNotReady ),

    //iTlsLogChannel( KSenServiceConnectionLogChannelBase )

    iTlsLogStatusChannel( KSenServiceConnectionStatusLogChannelBase ),

    iConnectionAgentCallbackInitialized(EFalse),

    iRegisterFileObserverDone(EFalse),

    iRegisterMobilityObserverDone(EFalse),

    iRegisterAuthObserverDone(EFalse),

    iRegisterCoBrandingObserverDone(EFalse),

    iReauthenticationNeeded(EFalse),

    ipExtendedConsumerInterface(aExtendedConsumerInteface),

#ifdef __ENABLE_ALR__

    iMobiltyObserver(NULL),

#endif

    iCancelSession(EFalse),

    iIsInternalSC(EFalse),

    iDispatcherEnabled(EFalse),

    ipRegistrationTimer(NULL)

    {

    CActiveScheduler::Add(this);

    }

CSenServiceConnectionImpl::~CSenServiceConnectionImpl()

    {

    delete ipRegistrationTimer;

    TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::~CSenServiceConnectionImpl")));

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

#if !defined (RD_SEN_USE_PUBSUB_FOR_OUTGOING_FILE_PROGRESS) && !defined( RD_SEN_USE_CONNAGENT_FOR_SOAP_PROGRESS ) // pub&sub is not in use for outgoing file progress

    TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::~CSenServiceConnectionImpl(): RD_SEN_USE_PUBSUB_FOR_OUTGOING_FILE_PROGRESS == FALSE")));

    if (ipAuthProvider || iFilesObserver || ipCoBrandingObserver)

#else // RD_SEN_USE_PUBSUB_FOR_OUTGOING_FILE_PROGRESS == TRUE

    TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::~CSenServiceConnectionImpl(): RD_SEN_USE_PUBSUB_FOR_OUTGOING_FILE_PROGRESS == TRUE")));

    if (ipAuthProvider || ipCoBrandingObserver) // iFilesObserver is not used

#endif // RD_SEN_USE_PUBSUB_FOR_OUTGOING_FILE_PROGRESS end

        {

        CSenConnAgentServer::Close();

        iConnectionAgentCallbackInitialized = EFalse;

        }

#ifdef __ENABLE_ALR__        

    if (iMobiltyObserver)

        {

        CSenConnAgentServer::Close();

        iRegisterMobilityObserverDone = EFalse;

        }

#endif //__ENABLE_ALR__

//    delete ipSenUnderTakerWaiter;

    delete ipSenServiceDispatcher;

    if ( iAsyncOpsArray )

        {

        TInt count(iAsyncOpsArray->Count());

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

            {

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

            if ( pOp )

                {

                pOp->iActive = NULL;

                pOp->Deque();

                delete pOp;

                }

            }

        iAsyncOpsArray->Close();

        delete iAsyncOpsArray;

        }

    if(iChunkMap)

        {

        iChunkMap->Reset();

        delete iChunkMap;

        }

    delete iInBuf;

    delete iOutBuf;

    delete iFragment;

    delete ipSessionId;

    delete ipChunkName;

    delete ipInitPatternAsXml;

    delete ipInitConsumerPolicyAsXml;

    delete ipInitChunk;

    delete ipCompleteServerMsgsOnOff;

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

    TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("Log file closed.")));

    TLSLOG_CLOSE (KSenServiceConnectionLogChannelBase+iConnectionID);

    TLSLOG_CLOSE(KSenServiceConnectionLogChannel);

    TLSLOG_CLOSE( iTlsLogStatusChannel );

    TLSLOG_CLOSE( KSenMessagesLogChannel );

    iConnection.Close();

    delete ipConnectionStatusObserver;

    delete ipFileProgressObserver;

    }

TPtrC CSenServiceConnectionImpl::SessionID()

    {

    if(ipSessionId)

        {

        return *ipSessionId;

        }

    else

        {

        return KNullDesC();

        }

    }

TInt CSenServiceConnectionImpl::RegisterAndSubscribeFileProgressObserversL()

    {

    TInt retCode( KErrNone );

    if(iFilesObserver && !iRegisterFileObserverDone)

    	{

#ifndef RD_SEN_USE_PUBSUB_FOR_OUTGOING_FILE_PROGRESS // pub&sub not in use for outgoing file progress

        TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::RegisterAndSubscribeFileProgressObserversL: RD_SEN_USE_PUBSUB_FOR_OUTGOING_FILE_PROGRESS == FALSE")));

    	retCode = RegisterFilesObserver();

#else // RD_SEN_USE_PUBSUB_FOR_OUTGOING_FILE_PROGRESS == TRUE

        TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::RegisterAndSubscribeFileProgressObserversL: RD_SEN_USE_PUBSUB_FOR_OUTGOING_FILE_PROGRESS == TRUE")));

    	ipFileProgressObserver = CSenFileProgressObserver::NewL( *iFilesObserver, iConnectionID, iDispatcherEnabled, ipSenServiceDispatcher, ChunkMapL() );

    #ifdef RD_SEN_USE_CONNAGENT_FOR_SOAP_PROGRESS

        TLSLOG_L(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel, "CSenServiceConnectionImpl::RegisterAndSubscribeFileProgressObserversL: RD_SEN_USE_CONNAGENT_FOR_SOAP_PROGRESS == TRUE");

        TLSLOG_L(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel, "=> calling RegisterFilesObserver()");

        retCode = RegisterFilesObserver(); // MIXED MODE, using conn agent for SOAP progress..

    #else // RD_SEN_USE_CONNAGENT_FOR_SOAP_PROGRESS == FALSE

        TLSLOG_L(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel, "CSenServiceConnectionImpl::RegisterAndSubscribeFileProgressObserversL: RD_SEN_USE_CONNAGENT_FOR_SOAP_PROGRESS == FALSE");

    #endif // RD_SEN_USE_CONNAGENT_FOR_SOAP_PROGRESS

#endif // RD_SEN_USE_PUBSUB_FOR_OUTGOING_FILE_PROGRESS end 	

    	iRegisterFileObserverDone = ETrue; // register only once

    	}

    return retCode;

    }

TInt CSenServiceConnectionImpl::SubmitL(CSenConnectionChunk& aClientOp)

    {

    TLSLOG(KSenServiceConnectionLogChannelBase+iConnectionID, KMinLogLevel,(_L("CSenServiceConnectionImpl::SubmitL(CSenChunk)")));

    TInt retVal(KErrNone);