/*

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

#include <f32file.h>

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

#include "senlogger.h"

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

#include "rsenserviceconnection.h"

#include <SenSoapMessage.h>

#if defined (__WINS__) && !defined(EKA2)

static const TUint KServerMinHeapSize =    0x1000;     //  4K

static const TUint KServerMaxHeapSize =    0x100000;   // 1000K

#endif

static TInt StartServerL();

static TInt CreateServerProcessL();

CSenProgressResourceHandler::CSenProgressResourceHandler(TInt aTxnId,

        TBool aIncoming, TBool aIsSoap, TInt aProgress,

        RSenServiceConnection* aOwner): CActive(EPriorityStandard),

        iOwner(aOwner)

    {

    TTransferProgress& data = iProgressData();

    data.iTxnId = aTxnId;

    data.iIncoming = aIncoming;

    data.iSoap = aIsSoap;

    data.iProgress = aProgress;

    }

CSenProgressResourceHandler::~CSenProgressResourceHandler()

    {

    delete iSoapOrCid;

    }

void CSenProgressResourceHandler::DoCancel()

    {

    }

void CSenProgressResourceHandler::RunL()

    {

    iOwner->Remove(this);

    delete this;

    }

TInt CSenProgressResourceHandler::SetBuffer(const TDesC8& aSoapOrCid)

    {

    iSoapOrCid = aSoapOrCid.Alloc();

    if (iSoapOrCid)

        {

        return KErrNone;

        }

    return KErrNoMemory;

    }

CSenConnAgentSync::CSenConnAgentSync(): CActive(EPriorityStandard)

	{

	CActiveScheduler::Add(this);

	iStatus = KRequestPending;

	}

CSenConnAgentSync::~CSenConnAgentSync()

	{

	if(IsActive())

		{

		Cancel();

		}

	}

void CSenConnAgentSync::DoCancel()

	{	

	}

void CSenConnAgentSync::RunL()

	{

	}

void CSenConnAgentSync::Start()

	{

	if(!IsActive())

		SetActive();

	}

RSenServiceConnection::RSenServiceConnection(RFileLogger* aLog)

    : RSessionBase(),

      iMessageContextId(0),

      iLog(aLog)

    {

    // No implementation required

    }

void RSenServiceConnection::SetLog(RFileLogger* aLog)

    {

    iLog = aLog;

    }

void RSenServiceConnection::SetChannel(TInt aChannel)

{

     iTLSLogChannel=aChannel;

}

TInt RSenServiceConnection::Connect()

    {

    TInt error(KErrNone);

    TRAPD( leave, error = ::StartServerL(); )

    if( leave != KErrNone )

        {

        error = leave;

        }

    if( error == KErrNone )

        {

        error = CreateSession( KSenServiceManager, Version(), KDefaultMessageSlots );

        /// By defining TRequestStatus (last arg) to NULL, one could force 

        /// error = CreateSession( KSenServiceManager, Version(), KDefaultMessageSlots, NULL, NULL ); 

#ifdef _SENDEBUG

        if(error != KErrNone)

            {

            TLSLOG_FORMAT((KSenServiceConnectionLogChannel, KMinLogLevel , _L8("RSenServiceConnection::Connect - CreateSession returned error: (%d)"), error));

            }

        else

            {

            TLSLOG_L(KSenServiceConnectionLogChannel, KMinLogLevel,"RSenServiceConnection::Connect - CreateSession returned KErrNone");

            }

#endif // _SENDEBUG

        }

#ifdef _SENDEBUG

    else

        {

        TLSLOG_FORMAT((KSenServiceConnectionLogChannel, KMinLogLevel , _L8("RSenServiceConnection::Connect - StartServerL failed, error: (%d)"), error));

        }

#endif // _SENDEBUG

    return error;

    }

TVersion RSenServiceConnection::Version() const

    {

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::Version");

    return(TVersion( KWsfServMajorVersionNumber, KWsfServMinorVersionNumber, KWsfServBuildVersionNumber) );

    }

void RSenServiceConnection::Initialize( TRequestStatus& aStatus,

                                        TDes8& aErrPtr,

                                        TDes& aSessionID,

                                        CSenChunk& aSenChunk,

                                        TInt aSdLength,

                                        TInt /* aCpLength */,

                                        TBool aHasAuthenticationCallback)

    {

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::Initialize");

    TIpcArgs args;

    args.Set(0, &aErrPtr);

    args.Set(1, &aSessionID);

    // Note: chunk will carry XML SD - and possibly consumer policy -

    // over the process boundary.

    aSenChunk.ChunkToArgs(args, 2);

    iFourInts().iInt1 = aSdLength;

    iFourInts().iInt2 = aHasAuthenticationCallback;

    args.Set(3,&iFourInts);

    SendReceive(ESenServInitialize, args, aStatus);

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::Initialize Completed");

    }

TInt RSenServiceConnection::IsReady(TBool& aReady)

    {

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::IsReady");

    TPtr8 descriptor(reinterpret_cast<TUint8*>(&aReady), sizeof(aReady), sizeof(aReady));

    TIpcArgs args;

    args.Set(0, &descriptor);

    return SendReceive(ESenServIsReady, args);

    }

TInt RSenServiceConnection::HasFacet(TDesC8& aUri, TBool& aHasFacet)

    {

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::HasFacet");

    TLSLOG_ALL(iTLSLogChannel, KMaxLogLevel,(aUri));

    TPtr8 descriptor(reinterpret_cast<TUint8*>(&aHasFacet), sizeof(aHasFacet), sizeof(aHasFacet));

    TInt length = aUri.Length();

    TIpcArgs args;

    args.Set(0, &aUri);

    args.Set(1, &descriptor);

    args.Set(2, length);

    return SendReceive(ESenServHasFacet, args);

    }

TInt RSenServiceConnection::CompleteServerMessagesOnOff(TBool& aOnOff)

    {

    TLSLOG(iTLSLogChannel, KMinLogLevel,(_L("RSenServiceConnection::CompleteServerMessagesOnOff")));

    // Note : Using TPtr8 since this is binary information

    TPtr8 descriptor(reinterpret_cast<TUint8*>(&aOnOff),sizeof(aOnOff),

        sizeof(aOnOff));

    TIpcArgs args;

    args.Set(0, &descriptor);

    return SendReceive(ESenServServerMessagesOnOff, args);

    }

void RSenServiceConnection::Transaction( TRequestStatus& aStatus,

                                         TDes8& aErrPtr,

                                         TDes8& aTxnPtr,

                                         CSenChunk& aClientOp )

    {

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::Transaction");

    // Set the message context ID in here: it is only locally unique, inside each service connection - "in client scope"

    // Context IDs use negative range, to avoid collisions with txnIDs (which are always positive integers)

    aClientOp.ChunkHeader().SetContextId( --iMessageContextId );

    TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Transaction - SetContextId: %d"), iMessageContextId));

    TIpcArgs args;

    args.Set(0, &aErrPtr);

    args.Set(1, &aTxnPtr);

    // This RChunk will pass message to server and include response when this

    // txn is complete

    aClientOp.ChunkToArgs(args,2);

    SendReceive(ESenServTransaction, args, aStatus);

    }

TInt RSenServiceConnection::SendMsgAndReceiveTxnId(CSenChunk& aClientOp)

    {

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::SendMsgAndReceiveTxnId");

    TInt retVal(KErrNone);

    TIpcArgs args;

    aClientOp.ChunkToArgs(args,0);

    args.Set(1,aClientOp.ChunkHeader().ContextId());

    retVal = SendReceive(ESenServSendMsgAndGetTxnId, args);

    return retVal;

    }

TInt RSenServiceConnection::MoveFile(CSenChunk& aClientOp,

                                     const TDesC8& aCid,

                                     RFile& aFile)

    {

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::SendFile");

    TInt retVal = aClientOp.DescToChunk(aCid,2);

    TIpcArgs args;

    if ( retVal == KErrNone)

        {

        aClientOp.ChunkToArgs(args,0);

        aFile.TransferToServer(args, 1, 2);

        retVal = SendReceive(ESenServMoveFile, args);

        }

    return retVal;

    }

TInt RSenServiceConnection::SendFileHandle(CSenChunk& aSenChunk, 

                      						RFile& aFile)

	{

  	 TInt retVal(KErrNone);

     TIpcArgs args;

     if ( retVal == KErrNone)

        {

         aSenChunk.ChunkToArgs(args,0);

         aFile.TransferToServer(args, 1, 2);       

         retVal = SendReceive(ESenServSendFileHandle, args);

        }

     return retVal;

	}

TInt RSenServiceConnection::MoveChunk(CSenChunk& aClientOp,

                                      const TDesC8& aCid,

                                      RChunk& aChunk,

                                      TInt aDataOffset,

                                      TInt aDataSize)

    {

    TLSLOG(iTLSLogChannel, KMinLogLevel,(_L("RSenServiceConnection::SendChunk")));

    TInt retVal = aClientOp.DescToChunk(aCid,2);

    TIpcArgs args;

    if ( retVal == KErrNone )

        {

        TIpcArgs args;

        aClientOp.ChunkToArgs(args,0);

        args.Set(1, aChunk);

        args.Set(2, aDataOffset);

        args.Set(3, aDataSize);

        retVal = SendReceive(ESenServMoveChunk, args);

        }

    return retVal;

    }

TInt RSenServiceConnection::RequestServiceDescription(TDes8& aSdLength)

    {

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::RequestServiceDescription");

    TIpcArgs args;

    args.Set(0, &aSdLength);

    return SendReceive(ESenServRequestServiceDescription, args);

    }

TInt RSenServiceConnection::ReceiveServiceDescription(TDes8& aServiceDescription)

    {

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::ReceiveServiceDescription");

    TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Waiting for SD: maxlength(%d):"),

                                aServiceDescription.MaxLength()));

    TIpcArgs args;

    args.Set(0, &aServiceDescription);

    return SendReceive(ESenServReceiveServiceDescription, args);

    }

TInt RSenServiceConnection::StartTransaction()

    {

    TLSLOG(iTLSLogChannel, KMinLogLevel,(_L("RSenServiceConnection::StartTransaction")));

    return SendReceive(ESenServStartTransaction);

    }

TInt RSenServiceConnection::TransactionCompleted()

    {

    TLSLOG(iTLSLogChannel, KMinLogLevel,(_L("RSenServiceConnection::TransactionCompleted")));

    return SendReceive(ESenServTransactionCompleted);

    }

TInt RSenServiceConnection::SetTransportPropertiesL(CSenChunk& aSenChunk)

    {

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::SetTransportPropertiesL");

    TIpcArgs args;

    aSenChunk.ChunkToArgs(args, 0);

    TInt retVal = SendReceive(ESenServSetTransportProperties, args);

    return retVal;

    }

TInt RSenServiceConnection::TransportPropertiesL(CSenChunk& aSenChunk)

    {

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::TransportPropertiesL");

    TIpcArgs args;

    aSenChunk.ChunkToArgs(args, 0);

    TInt retVal = SendReceive(ESenServTransportProperties, args);

    return retVal;

    }

void  RSenServiceConnection::CancelSession(TRequestStatus& aStatus)

    {

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::CancelSession(sync)");

    SendReceive(ESenServCancelSession, aStatus);

    }

// ASYNC VERSION

void RSenServiceConnection::CancelRequests(TRequestStatus& aStatus)

    {

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::CancelSession(async)");

    TIpcArgs args; // empty

    SendReceive(ESenServCancelSession, args, aStatus);

    }

void RSenServiceConnection::CancelRequest(TInt aTransactionID)

    {

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::CancelRequest");

    TIpcArgs args;

    args.Set(0, aTransactionID);

    SendReceive(ESenServCancelRequest, args);

    }

void RSenServiceConnection::DataTrafficDetails(TSenDataTrafficDetails& aDetails,

											   TSenDataTrafficOperations& aOperations) 

	{

	TLSLOG_L(iTLSLogChannel, KSenServiceConnectionLogLevel,"RSenServiceConnection::DataTrafficDetails");

    TPtr8 trafficDetailsDesc(reinterpret_cast<TUint8*>(&aDetails),sizeof(aDetails),

        					sizeof(aDetails));

    TIpcArgs args;

    args.Set(0,&trafficDetailsDesc);

    args.Set(1,&aOperations.iReset);

    SendReceive(ESenTrafficDetails, args);

    }

TInt RSenServiceConnection::ConnectionID()

    {

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::ConnectionID");

    TInt connectionID = SendReceive( ESenServConnectionID );

    //LOG_WRITEFORMAT((_L("- Connection ID: (%d)"), connectionID));

    return connectionID;

    }

TInt RSenServiceConnection::IdentityProviderL(CSenChunk& aSenChunk)

    {

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::IdentityProviderL");

    TIpcArgs args;

    aSenChunk.ChunkToArgs(args, 0);

    TInt retVal = SendReceive(ESenServConnectionIdentityProvider, args);

    return retVal;

    }

TInt RSenServiceConnection::RegisterIdentityProvider(TDesC8& aMessage)

    {

#ifdef _SENDEBUG

    TLSLOG_L(iTLSLogChannel, KMinLogLevel,"RSenServiceConnection::RegisterIdentityProvider");

    TPtrC8 outBufferLeft = aMessage.Left(30);

    TLSLOG_FORMAT((iTLSLogChannel, KNormalLogLevel , _L8("Out: %S ..., length: (%d)"), &outBufferLeft,

        aMessage.Length()));

#endif // _SENDEBUG

    TInt length = aMessage.Length();

    TIpcArgs args;

    args.Set(0, &aMessage);

    args.Set(1, length);

    return SendReceive(ESenServRegisterIdentityProvider, args);

    }

TInt RSenServiceConnection::RegisterTransferObserver(

        const TDesC* aServerName, TAny* aConnection)

    {

    TInt retVal(KErrNone);

    CActiveSchedulerWait asWait;

    TIpcArgs args(aServerName, aConnection, &asWait);

    CSenConnAgentSync* caSync = new CSenConnAgentSync();

    if(caSync)

    	{

	    SendReceive(ESenObserveTransfer, args, caSync->iStatus);

	    caSync->Start();

	    Mem::FillZ(&asWait, sizeof(asWait));

	    asWait.Start();

	    retVal = caSync->iStatus.Int();

	    delete caSync;

    	}

    else

    	{

    	retVal = KErrNoMemory;

    	}

    return retVal;

    }

TInt RSenServiceConnection::SendFileProgress( TInt aTxnId, 

                                              TBool aIncoming,

                                              TBool aIsSoap, 

                                              const TDesC8& aSoapOrCid, 

                                              TInt aProgress)

    {

    CSenProgressResourceHandler* resHandler = new CSenProgressResourceHandler(

            aTxnId, aIncoming, aIsSoap, aProgress, this);

    if (!resHandler)

        {

        return KErrNoMemory; // new (ELeave) was not used!

        }

    TInt retVal = resHandler->SetBuffer(aSoapOrCid);

    if ( retVal != KErrNone)

        {

        delete resHandler;

        }

    else

        {

        if (iFirst)

            {

            iFirst->iPrevious = resHandler;

            }

        resHandler->iNext = iFirst;

        iFirst = resHandler;

        CActiveScheduler::Add(resHandler);

        if(!resHandler->IsActive())

        	resHandler->SetActive();

        resHandler->iStatus = KRequestPending;

        TIpcArgs args(&resHandler->iProgressData, resHandler->iSoapOrCid);

        SendReceive(ESenTransferProgress, args, resHandler->iStatus);

        }

    return retVal;

    }

void RSenServiceConnection::Remove(

        CSenProgressResourceHandler* aResourceHandler)

    {

    if (aResourceHandler == iFirst)

        {

        iFirst = aResourceHandler->iNext;

        if (iFirst)

            {

            iFirst->iPrevious = NULL;

            }

        }

    else

        {

        aResourceHandler->iPrevious->iNext = aResourceHandler->iNext;

        }

    }