/*

* 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:  DUN Bluetooth plugin's listener

*

*/

#include <btsdp.h>

#include <e32std.h>

#include <bt_sock.h>

#include <btengdiscovery.h>

#include "DunPlugin.h"

#include "DunBtListen.h"

#include "DunBtPlugin.h"

#include "DunDebug.h"

const TInt KListenQueSize   = 1;

const TInt KDunFixedChannel = 22;  // Hack/kludge for Apple Bug ID 6527598

// ======== MEMBER FUNCTIONS ========

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

// Two-phased constructor.

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

//

CDunBtListen* CDunBtListen::NewL( MDunServerCallback* aServer,

                                  MDunListenCallback* aParent,

                                  CDunTransporter* aTransporter,

                                  TBtPortEntity& aEntity )

    {

    CDunBtListen* self = new (ELeave) CDunBtListen( aServer,

                                                    aParent,

                                                    aTransporter,

                                                    aEntity );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor.

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

//

CDunBtListen::~CDunBtListen()

    {

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

    ResetData();

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

    }

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

// Resets data to initial values

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

//

void CDunBtListen::ResetData()

    {

    // APIs affecting this:

    // IssueRequestL()

    Stop();

    StopServiceAdvertisement();

    // NewL()

    iTransporter->FreeAdvertisementMonitor( KDunBtPluginUid, this );

    delete iDiscovery;

    iDiscovery = NULL;

    if ( iSockServer.Handle() != KNullHandle )

        {

        iSockServer.Close();

        }

    // Internal

    Initialize();

    }

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

// Registers itself to SDP and BT manager, opens a socket

// and starts to listen it.

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

//

void CDunBtListen::IssueRequestL()

    {

    FTRACE(FPrint( _L( "CDunBtListen::IssueRequestL()" ) ));

    if ( iListenState == EBtListenStateListening )

        {

        FTRACE(FPrint( _L( "CDunBtListen::IssueRequestL() (already active) complete" ) ));

        User::Leave( KErrNotReady );

        }

    TBool advertise = iTransporter->AdvertisementStatus();

    if ( !advertise )

        {

        // Return silently here as CDunTransporter will notify later

        return;

        }

    TBool inUse = EFalse;

    TInt numOfChans = 0;

    TInt retTemp = StartServiceAdvertisement( inUse );

    if ( retTemp != KErrNone )

        {

        if ( inUse )

            {

            numOfChans = iTransporter->GetNumberOfAllocatedChannelsByUid(

                KDunBtPluginUid );

            if ( numOfChans == 0)

                {

                // No channels so parent can't reissue requests of this object

                // This is fatal case -> leave.

                // NOTE: To add full support for this case a poller (timer) is

                // needed that polls for free RFCOMM channel by given interval.

                User::Leave( retTemp );

                }

            // If in use and parent has channels then just fail silently.

            // Let this object to wait until parent finds new resources.

            FTRACE(FPrint( _L( "CDunBtListen::IssueRequestL() complete" ) ));

            return;

            }

        FTRACE(FPrint( _L( "CDunBtListen::IssueRequestL() (failed!) complete" ) ));

        User::Leave( retTemp );

        }

    // Not already active here so start listening

    // First open blank data socket

    retTemp = iEntity.iBTPort.Open( iSockServer );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L( "CDunBtListen::IssueRequestL() (ERROR) complete (%d)" ), retTemp));

        User::Leave( retTemp );

        }

    iStatus = KRequestPending;

    iListenSocket.Accept( iEntity.iBTPort, iStatus );

    SetActive();

    iListenState = EBtListenStateListening;

    FTRACE(FPrint( _L( "CDunBtListen::IssueRequestL() complete") ));

    }

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

// Stops listening

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

//

TInt CDunBtListen::Stop()

    {

    FTRACE(FPrint( _L( "CDunBtListen::Stop()") ));

    if ( iListenState != EBtListenStateListening )

        {

        FTRACE(FPrint( _L("CDunBtListen::Stop() (not ready) complete" )));

        return KErrNotReady;

        }

    iListenSocket.CancelAccept();

    Cancel();

    iListenState = EBtListenStateIdle;

    FTRACE(FPrint( _L( "CDunBtListen::Stop() complete") ));

    return KErrNone;

    }

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

// CDunBtListen::CDunBtListen

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

//

CDunBtListen::CDunBtListen( MDunServerCallback* aServer,

                            MDunListenCallback* aParent,

                            CDunTransporter* aTransporter,

                            TBtPortEntity& aEntity ) :

    CActive( EPriorityStandard ),

    iServer( aServer ),

    iParent( aParent ),

    iTransporter( aTransporter ),

    iEntity( aEntity )

    {

    Initialize();

    }

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

// CDunBtListen::ConstructL

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

//

void CDunBtListen::ConstructL()

    {

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

    if ( !iServer || !iParent || !iTransporter )

        {

        User::Leave( KErrGeneral );

        }

    CBTEngDiscovery* discovery = CBTEngDiscovery::NewLC();

    FTRACE(FPrint(_L("CDunBtListen::ConstructL: iSockServer.Connect")));

    User::LeaveIfError( iSockServer.Connect() );

    // Set advertisement monitor

    iTransporter->SetAdvertisementMonitorL( KDunBtPluginUid, this );

    // Then we are ready to start listening and accepting incoming connection

    // requests.

    CleanupStack::Pop( discovery );

    iDiscovery = discovery;

    CActiveScheduler::Add( this );

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

    }

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

// Initializes this class

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

//

void CDunBtListen::Initialize()

    {

    // Don't initialize iServer here (it is set through NewL)

    // Don't initialize iParent here (it is set through NewL)

    // Don't initialize iTransporter here (it is set through NewL)

    // Don't initialize iEntity here (it is set through NewL)

    iListenState = EBtListenStateIdle;

    iDiscovery = NULL;

    iChannelNum = 0;

    iSDPHandleDun = 0;

    }

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

// Starts dialup service advertisement

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

//

TInt CDunBtListen::StartServiceAdvertisement( TBool& aInUse )

    {

    FTRACE(FPrint( _L( "CDunBtListen::StartServiceAdvertisement()" ) ));

    TInt retTemp = ReserveLocalChannel( iSockServer,

                                        iListenSocket,

                                        iChannelNum,

                                        aInUse );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L( "CDunBtListen::StartServiceAdvertisement() (ERROR) complete" ) ));

        return retTemp;

        }

    // Now RFCOMM channel number of the next data socket must be the same as

    // the current listener's RFCOMM channel number. Set that now.

    iEntity.iChannelNum = iChannelNum;

    // Register SDP record

    iSDPHandleDun = 0;

    retTemp = iDiscovery->RegisterSdpRecord( KDialUpNetworkingUUID,

                                             iChannelNum,

                                             iSDPHandleDun );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L( "CDunBtListen::StartServiceAdvertisement() (failed!) complete (%d)" ), retTemp));

        return retTemp;

        }

    FTRACE(FPrint( _L( "CDunBtListen::StartServiceAdvertisement() complete" ) ));

    return KErrNone;

    }

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

// Stops dialup service advertisement

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

//

TInt CDunBtListen::StopServiceAdvertisement()

    {

    FTRACE(FPrint( _L( "CDunBtListen::StopServiceAdvertisement()" ) ));

    if ( !iDiscovery )

        {

        FTRACE(FPrint( _L( "CDunBtListen::StopServiceAdvertisement() (iDiscovery) not initialized!" ) ));

        return KErrGeneral;

        }

    if ( iSDPHandleDun != 0 )

        {

        TInt retTemp = iDiscovery->DeleteSdpRecord( iSDPHandleDun );

        FTRACE(FPrint( _L( "CDunBtListen::StopServiceAdvertisement() record closed (%d)" ), retTemp ));

        iSDPHandleDun = 0;

        }

    if ( iListenSocket.SubSessionHandle() )

        {

        iListenSocket.Close();

        }

    FTRACE(FPrint( _L( "CDunBtListen::StopServiceAdvertisement() complete" ) ));

    return KErrNone;

    }

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

// Method which reserves local RFCOMM channel (from possible channels 1-30)

// and returns it to client.

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

//

TInt CDunBtListen::ReserveLocalChannel( RSocketServ& aSocketServ,

                                        RSocket& aListenSocket,

                                        TUint& aChannelNum,

                                        TBool& aInUse )

    {

    FTRACE(FPrint(_L("CDunBtListen::ReserveLocalChannel()")));

    aInUse = EFalse;

    if ( aListenSocket.SubSessionHandle() )

        {

        FTRACE(FPrint(_L("CDunBtListen::ReserveLocalChannel() (open socket!) complete")));

        return KErrArgument;

        }

    TInt retTemp;

    TProtocolDesc pInfo;

    retTemp = aSocketServ.FindProtocol( TProtocolName(KRFCOMMDesC), pInfo );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint(_L("CDunBtListen::ReserveLocalChannel() (FindProtocol failed) complete (%d)"), retTemp));

        return retTemp;

        }

    retTemp = aListenSocket.Open( aSocketServ,

                                  pInfo.iAddrFamily,

                                  pInfo.iSockType,

                                  pInfo.iProtocol );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint(_L("CDunBtListen::ReserveLocalChannel() (Open failed) complete (%d)"), retTemp));

        return retTemp;

        }

    TRfcommSockAddr addr;

    TBTServiceSecurity sec;

    sec.SetAuthentication( ETrue );

    sec.SetAuthorisation( ETrue );

    sec.SetEncryption( ETrue );

    sec.SetPasskeyMinLength( 0 );

    addr.SetSecurity( sec );

    addr.SetPort( KRfcommPassiveAutoBind );

    // When fix from Apple, replace the following with

    // "retTemp = aListenSocket.Bind( addr );"

    retTemp = DoExtendedBind( aListenSocket, addr );

    if ( retTemp != KErrNone )

        {

        aListenSocket.Close();

        aInUse = ETrue;

        FTRACE(FPrint(_L("CDunBtListen::ReserveLocalChannel() Bind() complete (%d)"), retTemp));

        return KErrInUse;

        }

    aChannelNum = aListenSocket.LocalPort();

    retTemp = aListenSocket.Listen( KListenQueSize );

    if ( retTemp != KErrNone )

        {

        aListenSocket.Close();

        FTRACE(FPrint(_L("CDunBtListen::ReserveLocalChannel() Listen() complete (%d)"), retTemp));

        return retTemp;

        }

    FTRACE(FPrint(_L("CDunBtListen::ReserveLocalChannel() complete (%d)"), aChannelNum));

    return KErrNone;

    }

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

// Tries to bind to a fixed port and if that fails with KRfcommPassiveAutoBind.

// This is for spec breaking solutions like the OSX Leopard.

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

//

TInt CDunBtListen::DoExtendedBind( RSocket& aListenSocket,

                                   TRfcommSockAddr& aSockAddr )

    {

    FTRACE(FPrint(_L("CDunBtListen::DoExtendedBind()")));

    if ( !aListenSocket.SubSessionHandle() )

        {

        FTRACE(FPrint(_L("CDunBtListen::DoExtendedBind() (closed socket!) complete")));

        return KErrGeneral;

        }

    TRfcommSockAddr fixedAddr = aSockAddr;

    fixedAddr.SetPort( KDunFixedChannel );

    TInt retTemp = aListenSocket.Bind( fixedAddr );

    if ( retTemp == KErrNone )

        {

        FTRACE(FPrint(_L("CDunBtListen::DoExtendedBind() complete")));

        return KErrNone;

        }

    TInt retVal = aListenSocket.Bind( aSockAddr );

    FTRACE(FPrint(_L("CDunBtListen::DoExtendedBind() complete")));

    return retVal;

    }

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

// From class CActive.

// Called when a service is requested via BT.

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

//

void CDunBtListen::RunL()

    {

    FTRACE(FPrint( _L( "CDunBtListen::RunL()" ) ));

    iListenState = EBtListenStateIdle;

    StopServiceAdvertisement();

    TInt retTemp = iStatus.Int();

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L( "CDunBtListen::RunL() (ERROR) complete (%d)" ), retTemp));

        iServer->NotifyPluginCloseRequest( KDunBtPluginUid, ETrue );

        return;

        }

    // Notify new connection

    TBool noFreeChans = EFalse;

    retTemp = iParent->NotifyChannelAllocate( noFreeChans );

    if ( retTemp != KErrNone )

        {

        FTRACE(FPrint( _L( "CDunBtListen::RunL() channel allocation failed! (%d)" ), retTemp));

        // Other error than no free channels, close plugin now

        if ( !noFreeChans )

            {

            iServer->NotifyPluginCloseRequest( KDunBtPluginUid, ETrue );

            }

        return;

        }

    // Don't restart listening here. Request is issued via

    // NotifyAdvertisementStart()

    FTRACE(FPrint( _L( "CDunBtListen::RunL() complete" ) ));

    }

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

// From class CActive.

// Cancel current activity.

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

//

void CDunBtListen::DoCancel()

    {

    }

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

// From class MDunServAdvMon.

// Gets called when advertisement status changes to start.

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

//

void CDunBtListen::NotifyAdvertisementStart( TBool aCreation )

    {

    FTRACE(FPrint( _L( "CDunBtListen::NotifyAdvertisementStart()" ) ));

    // Remove the "if" below when fix comes from Apple

    if ( !aCreation )

        {

        TRAP_IGNORE( IssueRequestL() );

        }

    FTRACE(FPrint( _L( "CDunBtListen::NotifyAdvertisementStart() complete" ) ));

    }

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

// From class MDunServAdvMon.

// Gets called when advertisement status changes to end.

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

//

void CDunBtListen::NotifyAdvertisementEnd()

    {

    FTRACE(FPrint( _L( "CDunBtListen::NotifyAdvertisementEnd()" ) ));

    Stop();

    StopServiceAdvertisement();

    FTRACE(FPrint( _L( "CDunBtListen::NotifyAdvertisementEnd() complete" ) ));

    }