/*

* Copyright (c) 2006-2008 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:  Managing abstracted "channels" of network side communication

*

*/

#include "DunTransUtils.h"

#include "DunTransporter.h"

#include "DunDataWaiter.h"

#include "DunUpstream.h"

#include "DunDownstream.h"

#include "DunSignalCopy.h"

#include "DunNoteHandler.h"

#include "DunUtils.h"

#include "DunDebug.h"

#include "DunPlugin.h"

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

// Two-phased constructor.

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

//

EXPORT_C CDunTransporter* CDunTransporter::NewL(

    MDunPluginManager* aPluginManager,

    TInt aNumOfMaxChannels )

    {

    CDunTransporter* self = new (ELeave) CDunTransporter( aPluginManager,

                                                          aNumOfMaxChannels );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor.

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

//

CDunTransporter::~CDunTransporter()

    {

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

    UnInitialize();

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

    }

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

// Number of allocated channels, is the same number as allocated and active

// (non-waiting) channels

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

//

EXPORT_C TInt CDunTransporter::NumberOfAllocatedChannels()

    {

    FTRACE(FPrint( _L("CDunTransporter::NumberOfAllocatedChannels()" )));

    TInt i;

    TInt allocChannels = 0;

    TInt count = iChannelData.Count();

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

        {

        TDunChannelData& channelData = iChannelData[i];

        if ( channelData.iChannelInUse )

            {

            allocChannels++;

            }

        }

    FTRACE(FPrint( _L("CDunTransporter::NumberOfAllocatedChannels() complete" )));

    return allocChannels;

    }

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

// Number of waiting channels, is the same number as allocated and inactive

// (waiting) channels

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

//

EXPORT_C TInt CDunTransporter::NumberOfWaitingChannels()

    {

    FTRACE(FPrint( _L("CDunTransporter::NumberWaitingChannels()" )));

    if ( !iInitialized )

        {

        FTRACE(FPrint( _L("CDunTransporter::NumberWaitingChannels() complete" )));

        return 0;

        }

    TInt waiters = iChanMan->NumberOfWaiters();

    FTRACE(FPrint( _L("CDunTransporter::NumberWaitingChannels() complete" )));

    return waiters;

    }

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

// Gets the number of allocated channels by owner UID, is the same number as

// allocated and active (non-waiting) channels

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

//

EXPORT_C TInt CDunTransporter::GetNumberOfAllocatedChannelsByUid(

    TUid aOwnerUid )

    {

    FTRACE(FPrint( _L("CDunTransporter::GetNumberOfAllocatedChannelsByUid()" )));

    TInt i;

    TInt allocChannels = 0;

    TInt count = iChannelData.Count();

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

        {

        TDunChannelData& channelData = iChannelData[i];

        if ( channelData.iOwnerUid==aOwnerUid && channelData.iChannelInUse )

            {

            allocChannels++;

            }

        }

    FTRACE(FPrint( _L("CDunTransporter::GetNumberOfAllocatedChannelsByUid() complete" )));

    return allocChannels;

    }

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

// Gets the number of waiting channels by owner UID, is the same number as

// allocated and inactive (waiting) channels

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

//

EXPORT_C TInt CDunTransporter::GetNumberOfWaitingChannelsByUid(

    TUid aOwnerUid )

    {

    FTRACE(FPrint( _L("CDunTransporter::GetNumberWaitingChannelsByUid()" )));

    if ( !iInitialized )

        {

        FTRACE(FPrint( _L("CDunTransporter::GetNumberWaitingChannelsByUid() complete" )));

        return 0;

        }

    TInt waiters = iChanMan->GetNumberOfWaitersByUid( aOwnerUid );

    FTRACE(FPrint( _L("CDunTransporter::GetNumberWaitingChannelsByUid() complete" )));

    return waiters;

    }

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

// Transporter's service advertisement status

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

//

EXPORT_C TBool CDunTransporter::AdvertisementStatus()

    {

    FTRACE(FPrint( _L("CDunTransporter::AdvertisementStatus()" )));

    FTRACE(FPrint( _L("CDunTransporter::AdvertisementStatus() complete" )));

    return iAdvertise;

    }

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

// Creates a channel of communication between local media (aComm) and network

// Local media object pointer also works as a connection ID for the

// allocated channel

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

//

EXPORT_C void CDunTransporter::AllocateChannelL(

    RComm* aComm,

    TUid aOwnerUid,

    const TDesC8& aName,

    TBool aEnqueuedFail,

    MDunBufferCorrection* aCorrection )

    {

    FTRACE(FPrint( _L("CDunTransporter::AllocateChannel() (RComm)" )));

    if ( !aComm )

        {

        FTRACE(FPrint( _L("CDunTransporter::AllocateChannel() (aComm not initialized!) complete" )));

        User::Leave( KErrGeneral );

        }

    if ( !aComm->SubSessionHandle() )

        {

        FTRACE(FPrint( _L("CDunTransporter::AllocateChannel() (RComm) (bad handle) complete" ) ));

        User::Leave( KErrBadHandle );

        }

    TInt retTemp = InitializeOnDemand();

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L("CDunTransporter::AllocateChannel() (RComm) (ERROR) complete" ) ));

        User::Leave( retTemp );

        }

    iChanMan->AddConnWaiterL( aComm,

                              aOwnerUid,

                              aName,

                              aEnqueuedFail,

                              aCorrection );

    FTRACE(FPrint( _L("CDunTransporter::AllocateChannel() (RComm) complete" )));

    }

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

// Creates a channel of communication between local media (aSocket) and

// network

// Local media object pointer also works as a connection ID for the

// allocated channel

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

//

EXPORT_C void CDunTransporter::AllocateChannelL(

    RSocket* aSocket,

    TUid aOwnerUid,

    const TDesC8& aName,

    TBool aEnqueuedFail,

    TBool& aNoFreeChans )

    {

    FTRACE(FPrint( _L("CDunTransporter::AllocateChannel() (RSocket)" )));

    aNoFreeChans = EFalse;  // Initialize now if plugin didn't do it already

    if ( !aSocket )

        {

        FTRACE(FPrint( _L("CDunTransporter::AllocateChannel() (aSocket not initialized!) complete" )));

        User::Leave( KErrGeneral );

        }

    if ( !aSocket->SubSessionHandle() )

        {

        FTRACE(FPrint( _L("CDunTransporter::AllocateChannel() (RSocket) (bad handle) complete" ) ));

        User::Leave( KErrBadHandle );

        }

    TInt retTemp = InitializeOnDemand();

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L("CDunTransporter::AllocateChannel() (RSocket) (ERROR) complete" )));

        User::Leave( retTemp );

        }

    TInt firstFree = iUtility->InitializeFirstFreeChannel( aSocket );

    if ( firstFree < 0 )

        {

        FTRACE(FPrint( _L("CDunTransporter::AllocateChannel() (RSocket) (firstfree failed!) complete" ) ));

        User::Leave( firstFree );

        }

    if ( firstFree >= iChannelData.Count() )

        {

        FTRACE(FPrint( _L("CDunTransporter::AllocateChannel() (RSocket) (firstfree failed!) complete" ) ));

        User::Leave( KErrGeneral );

        }

    TInt bufferLength = KErrNotFound;

    // bufferLength will be omitted (not needed to set to RSocket)

    TRAPD( retTrap,

        iUtility->DoAllocateChannelL(NULL, bufferLength, firstFree, NULL) );

    if ( retTrap != KErrNone )

        {

        FTRACE(FPrint( _L("CDunTransporter::AllocateChannel() (RSocket) trapped!" ) ));

        UnInitializeOnDemand();  // remove unused initialized channel

        if ( retTrap == KErrTooBig )

            {

            if ( aEnqueuedFail )

                {

                // Inform plugin enqueue request

                iPluginManager->NotifyPluginEnqueueRequest( aOwnerUid );

                }

            aNoFreeChans = ETrue;  // Inform plugin about no free channels

            FTRACE(FPrint( _L("CDunTransporter::AllocateChannel() (RSocket) complete" )));

            User::Leave( KErrTooBig );

            }

        FTRACE(FPrint( _L("CDunTransporter::AllocateChannel() (RSocket) complete" )));

        User::Leave( retTrap );

        }

    TDunChannelData& channelData = iChannelData[firstFree];

    channelData.iSocket = aSocket;

    channelData.iChannelName = HBufC8::NewMaxL( aName.Length() );

    TPtr8 chanNamePtr = channelData.iChannelName->Des();

    chanNamePtr.Copy( aName );

    channelData.iUpstreamRW->SetMedia( aSocket, EDunMediaContextLocal );

    channelData.iDownstreamRW->SetMedia( aSocket, EDunMediaContextLocal );

    channelData.iOwnerUid = aOwnerUid;

    // Channel now occupied

    channelData.iChannelInUse = ETrue;

    // Clear the queue, just to be sure

    iPluginManager->NotifyPluginDequeueRequest( aOwnerUid );

    FTRACE(FPrint( _L("CDunTransporter::AllocateChannel() (RSocket) complete" )));

    }

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

// Frees an allocated channel by local media (aComm) connection ID

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

//

EXPORT_C TInt CDunTransporter::FreeChannel( RComm* aComm )

    {

    FTRACE(FPrint( _L("CDunTransporter::FreeChannel() (RComm)" )));

    TInt retTemp = CheckInitAndHandle( aComm );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L("CDunTransporter::FreeChannel() (RComm) (ERROR) complete" ) ));

        return retTemp;

        }

    retTemp = iChanMan->RemoveConnWaiter( aComm );

    if ( retTemp == KErrNone )

        {

        FTRACE(FPrint( _L("CDunTransporter::FreeChannel() (RComm) complete" )));

        return KErrNone;

        }

    // No waiter found, so try to find from channels

    TInt mediaIndex = GetMediaIndex( aComm );

    if ( mediaIndex < 0 )

        {

        FTRACE(FPrint( _L("CDunTransporter::FreeChannel() (RComm) (ERROR) complete" ) ));

        return mediaIndex;

        }

    retTemp = iUtility->DoFreeChannel( mediaIndex );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L("CDunTransporter::FreeChannel() (RComm) (ERROR) complete" )));

        return retTemp;

        }

    UnInitializeOnDemand();

    FTRACE(FPrint( _L("CDunTransporter::FreeChannel() (RComm) complete" )));

    return KErrNone;

    }

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

// Frees an allocated channel by local media (aSocket) connection ID

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

//

EXPORT_C TInt CDunTransporter::FreeChannel( RSocket* aSocket )

    {

    FTRACE(FPrint( _L("CDunTransporter::FreeChannel() (RSocket)" )));

    TInt retTemp = CheckInitAndHandle( aSocket );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L("CDunTransporter::FreeChannel() (RSocket) (ERROR) complete" ) ));

        return retTemp;

        }

    TInt mediaIndex = GetMediaIndex( aSocket );

    if ( mediaIndex < 0 )

        {

        return mediaIndex;

        }

    retTemp = iUtility->DoFreeChannel( mediaIndex );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L("CDunTransporter::FreeChannel() (RSocket) (ERROR) complete" ) ));

        return retTemp;

        }

    UnInitializeOnDemand();

    FTRACE(FPrint( _L("CDunTransporter::FreeChannel() (RSocket) complete" )));

    return KErrNone;

    }

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

// Issues transfer requests for all transfer objects by local media

// (aComm) connection ID

// This will cause the Transporter by be ready for transferring data

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

//

EXPORT_C void CDunTransporter::IssueTransferRequestsL( RComm* aComm )

    {

    FTRACE(FPrint( _L("CDunTransporter::IssueTransferRequests() (RComm)" )));

    User::LeaveIfError( CheckInitAndHandle( aComm ) );

    TInt retTemp = iChanMan->IssueConnWaiterRequest( aComm );

    if ( retTemp == KErrNone )

        {

        FTRACE(FPrint( _L("CDunTransporter::IssueTransferRequests() (RComm) complete" )));

        return;

        }

    // No waiter found, so try to find from channels

    TInt mediaIndex = GetMediaIndexL( aComm );

    User::LeaveIfError( iUtility->DoIssueTransferRequests( mediaIndex ) );

    FTRACE(FPrint( _L("CDunTransporter::IssueTransferRequests() (RComm) complete" )));

    }

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

// Issues transfer requests for all transfer objects by local media

// (aSocket) connection ID

// This will cause the Transporter by be ready for transferring data

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

//

EXPORT_C void CDunTransporter::IssueTransferRequestsL( RSocket* aSocket )

    {

    FTRACE(FPrint( _L("CDunTransporter::IssueTransferRequests() (RSocket)" )));

    User::LeaveIfError( CheckInitAndHandle( aSocket ) );

    TInt mediaIndex = GetMediaIndexL( aSocket );

    User::LeaveIfError( iUtility->DoIssueTransferRequests(mediaIndex) );

    FTRACE(FPrint( _L("CDunTransporter::IssueTransferRequests() (RSocket) complete" )));

    }

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

// Stops transfers for all transfer objects by local media (aComm)

// connection ID

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

//

EXPORT_C TInt CDunTransporter::StopTransfers( RComm* aComm )

    {

    FTRACE(FPrint( _L("CDunTransporter::StopTransfers() (RComm)" )));

    TInt retTemp = CheckInitAndHandle( aComm );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L("CDunTransporter::StopTransfers() (RComm) (ERROR) complete" ) ));

        return retTemp;

        }

    retTemp = iChanMan->StopConnWaiter( aComm );

    if ( retTemp == KErrNone )

        {

        FTRACE(FPrint( _L("CDunTransporter::StopTransfers() (RComm) complete" )));

        return KErrNone;

        }

    // No waiter found, so try to find from channels

    TInt mediaIndex = GetMediaIndex( aComm );

    if ( mediaIndex < 0 )

        {

        FTRACE(FPrint( _L("CDunTransporter::StopTransfers() (RComm) (ERROR) complete" ) ));

        return mediaIndex;

        }

    retTemp = iUtility->DoStopTransfers( mediaIndex );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L("CDunTransporter::StopTransfers() (RComm) (ERROR) complete" )));

        return retTemp;

        }

    FTRACE(FPrint( _L("CDunTransporter::StopTransfers() (RComm) complete" )));

    return KErrNone;

    }

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

// Stops transfers for all transfer objects by local media (aSocket)

// connection ID

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

//

EXPORT_C TInt CDunTransporter::StopTransfers( RSocket* aSocket )

    {

    FTRACE(FPrint( _L("CDunTransporter::StopTransfers() (RSocket)" )));

    TInt retTemp = CheckInitAndHandle( aSocket );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L("CDunTransporter::StopTransfers() (RSocket) (ERROR) complete" ) ));

        return retTemp;

        }

    TInt mediaIndex = GetMediaIndex( aSocket );

    if ( mediaIndex < 0 )

        {

        FTRACE(FPrint( _L("CDunTransporter::StopTransfers() (RSocket) (ERROR) complete" ) ));

        return mediaIndex;

        }

    retTemp = iUtility->DoStopTransfers( mediaIndex );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L("CDunTransporter::StopTransfers() (RSocket) (ERROR) complete" )));

        return retTemp;

        }

    FTRACE(FPrint( _L("CDunTransporter::StopTransfers() (RSocket) complete" )));

    return KErrNone;

    }

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

// Adds connection monitor callback for either local media or network side

// by connection ID

// Callbacks will be called read/write error is detected during endpoint

// operation

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

//

EXPORT_C void CDunTransporter::AddConnMonCallbackL( RComm* aComm,

                                                    MDunConnMon* aCallback,

                                                    TDunDirection aDirection,

                                                    TBool /*aSignal*/ )

    {

    FTRACE(FPrint( _L("CDunTransporter::AddConnMonCallbackL() (RComm)" )));

    User::LeaveIfError( CheckInitAndHandle( aComm ) );

    TInt retTemp = iChanMan->SaveWaiterConnMonCallbackL( aComm,

                                                         aCallback,

                                                         aDirection );

    if ( retTemp == KErrNone )

        {

        FTRACE(FPrint( _L("CDunTransporter::AddConnMonCallbackL() (RComm) complete" )));

        return;

        }

    TInt mediaIndex = GetMediaIndexL( aComm );

    User::LeaveIfError( iUtility->DoAddConnMonCallback( mediaIndex,

                                                        aCallback,

                                                        aDirection,

                                                        NULL ));

    FTRACE(FPrint( _L("CDunTransporter::AddConnMonCallbackL() (RComm) complete" )));

    }

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

// Adds connection monitor callback for either local media or network side

// by connection ID

// Callbacks will be called when line status switches to high or low

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

//

EXPORT_C void CDunTransporter::AddConnMonCallbackL( RSocket* aSocket,

                                                    MDunConnMon* aCallback,

                                                    TDunDirection aDirection,

                                                    TBool aSignal )

    {

    FTRACE(FPrint( _L("CDunTransporter::AddConnMonCallbackL() (RSocket)" )));

    User::LeaveIfError( CheckInitAndHandle( aSocket ) );

    TInt mediaIndex = GetMediaIndexL( aSocket );

    User::LeaveIfError( iUtility->DoAddConnMonCallback( mediaIndex,

                                                        aCallback,

                                                        aDirection,

                                                        aSignal ));

    FTRACE(FPrint( _L("CDunTransporter::AddConnMonCallbackL() (RSocket) complete" )));

    }

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

// Adds error to consider as no error condition when doing any of the four