/*

* Copyright (c) 2006-2010 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:  Utility class for other CDunTransporter classes

*

*/

#include <e32base.h>

#include <e32property.h>

#include "dundomainpskeys.h"

#include "DunTransUtils.h"

#include "DunDataWaiter.h"

#include "DunUpstream.h"

#include "DunDownstream.h"

#include "DunSignalCopy.h"

#include "DunSignalNotify.h"

#include "DunNoteHandler.h"

#include "DunUtils.h"

#include "DunDebug.h"

// ---------------------------------------------------------------------------

// Two-phased constructor.

// ---------------------------------------------------------------------------

//

CDunTransUtils* CDunTransUtils::NewL( CDunTransporter& aParent,

                                      MDunPluginManager* aPluginManager )

    {

    CDunTransUtils* self = new (ELeave) CDunTransUtils( aParent,

                                                        aPluginManager );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// Destructor.

// ---------------------------------------------------------------------------

//

CDunTransUtils::~CDunTransUtils()

    {

    FTRACE(FPrint( _L("CDunTransUtils::~CDunTransUtils()" )));

    FTRACE(FPrint( _L("CDunTransUtils::~CDunTransUtils() complete" )));

    }

// ---------------------------------------------------------------------------

// CDunTransUtils::CDunTransUtils

// ---------------------------------------------------------------------------

//

CDunTransUtils::CDunTransUtils( CDunTransporter& aParent,

                                MDunPluginManager* aPluginManager ) :

    iParent( aParent ),

    iChannelData( aParent.iChannelData ),

    iServAdvData( aParent.iServAdvData ),

    iPluginManager( aPluginManager )

    {

    }

// ---------------------------------------------------------------------------

// CDunTransUtils::ConstructL

// ---------------------------------------------------------------------------

//

void CDunTransUtils::ConstructL()

    {

    FTRACE(FPrint( _L("CDunTransUtils::ConstructL()" )));

    if ( !iPluginManager )

        {

        User::Leave( KErrGeneral );

        }

    FTRACE(FPrint( _L("CDunTransUtils::ConstructL() complete" )));

    }

// ---------------------------------------------------------------------------

// Manages service advertisement status changes

// ---------------------------------------------------------------------------

//

void CDunTransUtils::ManageAdvertisementStatusChange( TBool aAdvertise,

                                                      TBool aCreation )

    {

    FTRACE(FPrint( _L("CDunTransUtils::ManageAdvertisementStatusChange()" )));

    TInt i;

    TInt count;

    iParent.iAdvertise = aAdvertise;

    count = iServAdvData.Count();

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

        {

        TDunServAdvData& servAdvData = iServAdvData[i];

        if ( servAdvData.iServAdvMon )

            {

            if ( aAdvertise )

                {

                servAdvData.iServAdvMon->NotifyAdvertisementStart( aCreation );

                }

            else

                {

                servAdvData.iServAdvMon->NotifyAdvertisementEnd();

                }

            }

        }

    FTRACE(FPrint( _L("CDunTransUtils::ManageAdvertisementStatusChange() complete" )));

    }

// ---------------------------------------------------------------------------

// Creates empty channel data

// ---------------------------------------------------------------------------

//

void CDunTransUtils::CreateEmptyChannelData( TDunChannelData& aChannel )

    {

    FTRACE(FPrint( _L("CDunTransUtils::CreateEmptyChannelData()" )));

    aChannel.iNetwork = NULL;

    aChannel.iComm = NULL;

    aChannel.iSocket = NULL;

    aChannel.iChannelName = NULL;

    aChannel.iUpstreamRW = NULL;

    aChannel.iDownstreamRW = NULL;

    aChannel.iBufferUpstream = NULL;

    aChannel.iBufferDownstream = NULL;

    aChannel.iBufferUpPtr = NULL;

    aChannel.iBufferDownPtr = NULL;

    aChannel.iUpstreamSignalCopy = NULL;

    aChannel.iDownstreamSignalCopy = NULL;

    aChannel.iSignalNotify = NULL;

    aChannel.iOwnerUid = TUid::Null();

    aChannel.iChannelInUse = EFalse;

    FTRACE(FPrint( _L("CDunTransUtils::CreateEmptyChannelData() complete" )));

    }

// ---------------------------------------------------------------------------

// Creates new buffer if source buffer defined, otherwise already existing

// buffer will be used

// ---------------------------------------------------------------------------

//

void CDunTransUtils::DoCreateBufferLC( TUint8* aSrcBuffer,

                                       TPtr8* aSrcPtr,

                                       TUint8*& aDstBuffer,

                                       TPtr8*& aDstPtr,

                                       TInt aBufferLength,

                                       TInt& aItemsInCs )

    {

    FTRACE(FPrint( _L("CDunTransUtils::DoCreateBufferLC()" )));

    TUint8* buffer;

    if ( !aSrcBuffer )

        {

        buffer = new (ELeave) TUint8[aBufferLength];

        CleanupStack::PushL( buffer );

        aItemsInCs++;

        FTRACE(FPrint( _L("CDunTransUtils::DoCreateBufferLC() new created" )));

        }

    else

        {

        buffer = aSrcBuffer;

        FTRACE(FPrint( _L("CDunTransUtils::DoCreateBufferLC() existing set" )));

        }

    TPtr8* bufferPtr;

    if ( !aSrcPtr )

        {

        bufferPtr = new (ELeave) TPtr8( buffer, aBufferLength, aBufferLength );

        CleanupStack::PushL( bufferPtr );

        aItemsInCs++;

        FTRACE(FPrint( _L("CDunTransUtils::DoCreateBufferLC() new created" )));

        }

    else

        {

        bufferPtr = aSrcPtr;

        FTRACE(FPrint( _L("CDunTransUtils::DoCreateBufferLC() existing set" )));

        }

    aDstBuffer = buffer;

    aDstPtr = bufferPtr;

    FTRACE(FPrint( _L("CDunTransUtils::DoCreateBufferLC() complete" )));

    }

// ---------------------------------------------------------------------------

// Creates new signal copy object if source defined, otherwise already

// existing will be used

// ---------------------------------------------------------------------------

//

void CDunTransUtils::DoCreateSignalCopyLC( CDunSignalCopy* aSrcSignalCopy,

                                           CDunSignalCopy*& aDstSignalCopy,

                                           TInt& aItemsInCs )

    {

    FTRACE(FPrint( _L("CDunTransUtils::DoCreateSignalCopyLC()" )));

    CDunSignalCopy* signalCopy;

    if ( !aSrcSignalCopy )

        {

        signalCopy = CDunSignalCopy::NewL();

        CleanupStack::PushL( signalCopy );

        aItemsInCs++;

        FTRACE(FPrint( _L("CDunTransUtils::DoCreateSignalCopyLC() new created" )));

        }

    else

        {

        signalCopy = aSrcSignalCopy;

        FTRACE(FPrint( _L("CDunTransUtils::DoCreateSignalCopyLC() existing set" )));

        }

    aDstSignalCopy = signalCopy;

    FTRACE(FPrint( _L("CDunTransUtils::DoCreateSignalCopyLC() complete" )));

    }

// ---------------------------------------------------------------------------

// Creates new signal notify object if source defined, otherwise already

// existing will be used

// ---------------------------------------------------------------------------

//

void CDunTransUtils::DoCreateSignalNotifyLC(

    CDunSignalNotify* aSrcSignalNotify,

    CDunSignalNotify*& aDstSignalNotify,

    TInt& aItemsInCs )

    {

    FTRACE(FPrint( _L("CDunTransUtils::DoCreateSignalNotifyLC()" )));

    CDunSignalNotify* signalNotify;

    if ( !aSrcSignalNotify )

        {

        signalNotify = CDunSignalNotify::NewL( this );

        CleanupStack::PushL( signalNotify );

        aItemsInCs++;

        FTRACE(FPrint( _L("CDunTransUtils::DoCreateSignalNotifyLC() new created" )));

        }

    else

        {

        signalNotify = aSrcSignalNotify;

        FTRACE(FPrint( _L("CDunTransUtils::DoCreateSignalNotifyLC() existing set" )));

        }

    aDstSignalNotify = signalNotify;

    FTRACE(FPrint( _L("CDunTransUtils::DoCreateSignalNotifyLC() complete" )));

    }

// ---------------------------------------------------------------------------

// Creates transfer objects for reader and writer if sources defined,

// otherwise already existing ones will be used

// ---------------------------------------------------------------------------

//

void CDunTransUtils::DoCreateUpTransferObjectL( CDunUpstream* aSrcReader,

                                                CDunUpstream*& aDstReader,

                                                TInt& aItemsInCs )

    {

    FTRACE(FPrint( _L("CDunTransUtils::DoCreateUpTransferObjectL()" )));

    CDunUpstream* dunReader;

    if ( !aSrcReader )

        {

        dunReader = CDunUpstream::NewL( this );

        CleanupStack::PushL( dunReader );

        aItemsInCs++;

        FTRACE(FPrint( _L("CDunTransUtils::DoCreateUpTransferObjectL() new created" )));

        }

    else

        {

        dunReader = aSrcReader;

        FTRACE(FPrint( _L("CDunTransUtils::DoCreateUpTransferObjectL() existing set" )));

        }

    aDstReader = dunReader;

    FTRACE(FPrint( _L("CDunTransUtils::DoCreateUpTransferObjectL() complete" )));

    }

// ---------------------------------------------------------------------------

// Creates transfer objects for reader and writer if sources defined,

// otherwise already existing ones will be used

// ---------------------------------------------------------------------------

//

void CDunTransUtils::DoCreateDownTransferObjectL( CDunDownstream* aSrcReader,

                                                  CDunDownstream*& aDstReader,

                                                  TInt& aItemsInCs )

    {

    FTRACE(FPrint( _L("CDunTransUtils::DoCreateDownTransferObjectL()" )));

    CDunDownstream* dunReader;

    if ( !aSrcReader )

        {

        dunReader = CDunDownstream::NewL( this );

        CleanupStack::PushL( dunReader );

        aItemsInCs++;

        FTRACE(FPrint( _L("CDunTransUtils::DoCreateDownTransferObjectL() new created" )));

        }

    else

        {

        dunReader = aSrcReader;

        FTRACE(FPrint( _L("CDunTransUtils::DoCreateDownTransferObjectL() existing set" )));

        }

    aDstReader = dunReader;

    FTRACE(FPrint( _L("CDunTransUtils::DoCreateDownTransferObjectL() complete" )));

    }

// ---------------------------------------------------------------------------

// Resets/frees network data of aIndex:th channel

// ---------------------------------------------------------------------------

//

TInt CDunTransUtils::DeleteOneNetworkData( TInt aIndex )

    {

    FTRACE(FPrint( _L("CDunTransUtils::DeleteOneNetworkData()" )));

    if ( aIndex < 0 ||

         aIndex >= iChannelData.Count() )

        {

        FTRACE(FPrint( _L("CDunTransUtils::DeleteOneNetworkData (not found) complete" )));

        return KErrNotFound;

        }

    TDunChannelData& channelData = iChannelData[aIndex];

    if ( !channelData.iChannelInUse )

        {

        FTRACE(FPrint( _L("CDunTransUtils::DeleteOneNetworkData() (channel not found) complete" ), aIndex));

        return KErrGeneral;

        }

    // channelData.iDownstreamSignalCopy may or may not exist (optional)

    // channelData.iSignalNotify may or may not exist (optional)

    delete channelData.iDownstreamSignalCopy;

    channelData.iDownstreamSignalCopy = NULL;

    delete channelData.iSignalNotify;

    channelData.iSignalNotify = NULL;

    delete channelData.iDownstreamRW;

    channelData.iDownstreamRW = NULL;

    FTRACE(FPrint( _L("CDunTransUtils::DeleteOneNetworkData complete()" )));

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// Resets/frees network data of aIndex:th channel

// ---------------------------------------------------------------------------

//

TInt CDunTransUtils::DeleteOneLocalData( TInt aIndex )

    {

    FTRACE(FPrint( _L("CDunTransUtils::DeleteOneLocalData()" )));

    if ( aIndex < 0 ||

         aIndex >= iChannelData.Count() )

        {

        FTRACE(FPrint( _L("CDunTransUtils::DeleteOneLocalData() (not found) complete" )));

        return KErrNotFound;

        }

    TDunChannelData& channelData = iChannelData[aIndex];

    if ( !channelData.iChannelInUse )

        {

        FTRACE(FPrint( _L("CDunTransUtils::DeleteOneLocalData() (channel not found) complete" ), aIndex));

        return KErrGeneral;

        }

    // channelData.iUpstreamSignalCopy may or may not exist (optional)

    delete channelData.iUpstreamSignalCopy;

    channelData.iUpstreamSignalCopy = NULL;

    delete channelData.iUpstreamRW;

    channelData.iUpstreamRW = NULL;

    FTRACE(FPrint( _L("CDunTransUtils::DeleteOneLocalData() complete" )));

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// Deletes buffering objects of aIndex:th channel

// ---------------------------------------------------------------------------

//

TInt CDunTransUtils::DeleteBuffering( TInt aIndex )

    {

    FTRACE(FPrint( _L("CDunTransUtils::DeleteBuffering()" )));

    if ( aIndex < 0 ||

         aIndex >= iChannelData.Count() )

        {

        FTRACE(FPrint( _L("CDunTransUtils::DeleteBuffering() (not found) complete" )));

        return KErrNotFound;

        }

    TDunChannelData& channelData = iChannelData[aIndex];

    if ( !channelData.iChannelInUse )

        {

        FTRACE(FPrint( _L("CDunTransUtils::DeleteBuffering() (channel not found) complete" ), aIndex));

        return KErrGeneral;

        }

    delete channelData.iChannelName;

    channelData.iChannelName = NULL;

    delete channelData.iBufferUpstream;

    channelData.iBufferUpstream = NULL;

    delete channelData.iBufferDownstream;

    channelData.iBufferDownstream = NULL;

    delete channelData.iBufferUpPtr;

    channelData.iBufferUpPtr = NULL;

    delete channelData.iBufferDownPtr;

    channelData.iBufferDownPtr = NULL;

    FTRACE(FPrint( _L("CDunTransUtils::DeleteBuffering() complete" )));

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// Initializes first free channel

// ---------------------------------------------------------------------------

//

TInt CDunTransUtils::InitializeFirstFreeChannel( TConnId aLocalIdNew )

    {

    FTRACE(FPrint( _L("CDunTransUtils::InitializeFirstFreeChannel()" )));

    TInt i;

    TInt count;

    TInt retTemp;

    TInt firstFree = KErrNotFound;

    count = iChannelData.Count();

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

        {

        TDunChannelData& channelData = iChannelData[i];

        if ( channelData.iComm==aLocalIdNew ||

             channelData.iSocket==aLocalIdNew )

            {

            FTRACE(FPrint( _L("CDunTransUtils::InitializeFirstFreeChannel() (already exists) complete" )));

            return KErrAlreadyExists;

            }

        if ( !channelData.iChannelInUse && firstFree==KErrNotFound )

            {

            firstFree = i;

            // no "break" here since KErrAlreadyExists needs to be checked

            }

        }

    if ( firstFree >= 0 )

        {

        FTRACE(FPrint( _L("CDunTransUtils::InitializeFirstFreeChannel() complete" )));

        return i;

        }

    // Free channel not found, now create new if possible

    TDunChannelData emptyChannel;

    CreateEmptyChannelData( emptyChannel );

    retTemp = iChannelData.Append( emptyChannel );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L("CDunTransUtils::InitializeFirstFreeChannel() (append failed!) complete" )));

        return retTemp;

        }

    FTRACE(FPrint( _L("CDunTransUtils::InitializeFirstFreeChannel() complete" )));

    return i;

    }

// ---------------------------------------------------------------------------

// From class MDunTransporterUtility.

// Allocates a channel by creating and setting local media independent

// objects

// This is a common method used by exported local media dependent methods

// ---------------------------------------------------------------------------

//

void CDunTransUtils::DoAllocateChannelL( RComm* aComm,

                                         TInt& aBufferLength,

                                         TInt aFirstFree,

                                         MDunBufferCorrection* aCorrection )

    {

    FTRACE(FPrint( _L("CDunTransUtils::DoAllocateChannelL()" )));

    TInt retTemp;

    TInt itemsInCs = 0;

    if ( !iParent.iNetwork )

        {

        FTRACE(FPrint( _L("CDunTransUtils::DoAllocateChannelL() (iNetwork) not initialized!" )));

        User::Leave( KErrGeneral );

        }

    FTRACE(FPrint( _L("CDunTransUtils::DoAllocateChannelL() aFirstFree = %d" ), aFirstFree));

    // Allocate network channel

    RComm* networkEntity;

    retTemp = iParent.iNetwork->AllocateChannel( networkEntity );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L("CDunTransUtils::DoAllocateChannelL() network allocation failed" )));

        if ( retTemp == KErrTooBig )

            {

            // Start to show note

            if ( iParent.iNoteHandler )

                {

                iParent.iNoteHandler->IssueRequest();

                }

            // Set flag to indicate that advertisement is not possible anymore

            ManageAdvertisementStatusChange( EFalse );

            FTRACE(FPrint( _L("CDunTransUtils::DoAllocateChannelL() (too big) complete" )));

            User::Leave( KErrTooBig );

            }

        FTRACE(FPrint( _L("CDunTransUtils::DoAllocateChannelL() (ERROR) complete" )));

        User::Leave( KErrGeneral );

        }

    TInt currentLength = networkEntity->ReceiveBufferLength();

    TInt newLength = currentLength;

    FTRACE(FPrint( _L("CDunTransUtils::DoAllocateChannelL() buffer length before = %d" ), currentLength));

    if ( aCorrection )

        {

        // Get network side buffer length and request change if required.

        // Check "newlength>currentLength" here as it is not possible to

        // increase Dataport's buffer length

        newLength = aCorrection->NotifyBufferCorrection( currentLength );

        if ( newLength<=0 || newLength>currentLength )

            {

            FTRACE(FPrint( _L("CDunTransUtils::DoAllocateChannelL() unknown buffer length" )));

            User::Leave( KErrGeneral );

            }

        // It is not possible to set Dataport side receive buffer length to any

        // arbitrary value (currently only 8kB..20kB are supported but that

        // can't be queried via an API). So here only default buffer size will

        // be used from Dataport while this component's local buffering uses

        // Dataport's default buffer size if not adjusted via plugin side.

        // NOTE: If Dataport side starts to support arbitrary receive buffer

        // size, it should be changed here if newLength != currentLength.

        }

    aBufferLength = newLength;

    FTRACE(FPrint( _L("CDunTransUtils::DoAllocateChannelL() buffer length after = %d" ), newLength));

    // Get channel data

    TDunChannelData& channelData = iChannelData[aFirstFree];

    // Create buffers and set length

    TUint8* bufferUpstream;

    TPtr8* bufferUpPtr;

    DoCreateBufferLC( channelData.iBufferUpstream,

                      channelData.iBufferUpPtr,

                      bufferUpstream,

                      bufferUpPtr,

                      newLength,

                      itemsInCs );

    TUint8* bufferDownstream;

    TPtr8* bufferDownPtr;

    DoCreateBufferLC( channelData.iBufferDownstream,

                      channelData.iBufferDownPtr,