/*

* Copyright (c) 2007-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:  Implementation of CWsfWlanBearerConnectionMonitor

*

*/

//  EXTERNAL INCLUDES

#include <w32std.h> 

#include <apgtask.h>

#include <utf.h>

#include <cmpluginwlandef.h>

#include <commdbconnpref.h>

#include <wlanerrorcodes.h>

#include <cmconnectionmethodext.h>

#include <commdb.h>

#include <WlanCdbCols.h>

//  CLASS HEADER

#include "wsfwlanbearerconnectionmonitor.h"

//  INTERNAL INCLUDES

#include "wsfwlanmonitorobserver.h"

#include "wsflogger.h"

#include "wsfactivewaiter.h"

#include "wsfservercloseradapter.h"

#include "wsfcommon.h"

#include "wsfict.h"

//  LOCAL DEFINITIONS

using namespace CMManager;

#ifdef _DEBUG

    _LIT( KWlanConnMonPanic, "wsfwlanconnmon" );

    #define __ASSERTD(x) __ASSERT_DEBUG( (x), \

                                User::Panic( KWlanConnMonPanic, __LINE__ ) );

#else

    #define __ASSERTD(x)

#endif                                

//  LOCAL CONSTANTS

/**

* Connection id referring to a non-existing connection

*/

static const TInt KNoConnection = -1;

/**

* Max allowed connection inactivity time in seconds

*/

static const TUint KMaxConnectionInactivityTime = 60;

/**

* Client polling interval in microseconds

*/

static const TUint KClientPollInterval = 5 * 1000 * 1000;

/**

* Number of trivial clients of a connection (Sniffer, AI/CP plugin etc)

*/

static const TUint KTrivialClientCount = 2;

/**

* List of UIDs of the trivial clients

*/

static const TUid KTrivialClientUids[KTrivialClientCount] = 

    {

    { 0x10281CAB },         // Sniffer server (wsfserver.exe)

    { 0x101fD9C5 }          // DHCP server (dhcpserv.exe)

    };

/**

* Browser UID

*/

const TUid KCRUidBrowser   = {0x10008D39};

//  CONSTRUCTION AND DESTRUCTION

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

// CWsfWlanBearerConnectionMonitor::NewL

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

//

CWsfWlanBearerConnectionMonitor* CWsfWlanBearerConnectionMonitor::NewL( 

                                  MWsfServerCloserAdapter& aServerCloser )

    {

    CWsfWlanBearerConnectionMonitor* thisPtr = NewLC( aServerCloser );

    CleanupStack::Pop( thisPtr );

    return thisPtr;

    }

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

// CWsfWlanBearerConnectionMonitor::NewLC

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

//

CWsfWlanBearerConnectionMonitor* CWsfWlanBearerConnectionMonitor::NewLC( 

                                  MWsfServerCloserAdapter& aServerCloser )

    {

    CWsfWlanBearerConnectionMonitor* thisPtr = 

           new (ELeave) CWsfWlanBearerConnectionMonitor( aServerCloser );

    CleanupStack::PushL( thisPtr );

    thisPtr->ConstructL();

    return thisPtr;

    }

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

// CWsfWlanBearerConnectionMonitor::~CWsfWlanBearerConnectionMonitor

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

//

CWsfWlanBearerConnectionMonitor::~CWsfWlanBearerConnectionMonitor()

    {

    LOG_ENTERFN( "CWsfWlanBearerConnectionMonitor::"

                 L"~CWsfWlanBearerConnectionMonitor" );

    iMonitor.CancelNotifications();

    iMonitor.Close();

    Cancel();

    if ( iConnectionOwned )

        {

        // in case Cancel() hasn't done the job

        TRAP_IGNORE( ShutdownOwnedConnectionL() );

        }

    else if ( iMonitoredAp )

        {

        }

    delete iClientPoll;

    delete iIct;

    iCmMgr.Close();

    }

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

// CWsfWlanBearerConnectionMonitor::CWsfWlanBearerConnectionMonitor

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

//

CWsfWlanBearerConnectionMonitor::CWsfWlanBearerConnectionMonitor( 

                                MWsfServerCloserAdapter& aServerCloser ):

    CActive( CActive::EPriorityStandard ),

    iConnectionId( KNoConnection ),

    iMonitoring( EFalse ),

    iConnectingState( ECsIdle ),

    iServerCloser( aServerCloser )

    {

    CActiveScheduler::Add( this );

    }

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

// CWsfWlanBearerConnectionMonitor::ConstructL

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

//

void CWsfWlanBearerConnectionMonitor::ConstructL()

    {

    LOG_ENTERFN( "CWsfWlanBearerConnectionMonitor::ConstructL" );

    iCmMgr.OpenL();

    iMonitor.ConnectL();

    iClientPoll = CPeriodic::NewL( CActive::EPriorityLow );

    iIct = CWsfIct::NewL();

    FindWlanBearerConnectedL();

    }

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

// CWsfWlanBearerConnectionMonitor::GetWlanBearerNameL

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

//

const TDesC& CWsfWlanBearerConnectionMonitor::GetWlanBearerNameL()

    {

    LOG_ENTERFN( "CWsfWlanBearerConnectionMonitor::GetWlanBearerNameL" );

    if ( iConnectionId == KNoConnection )

        {

        LOG_WRITE( "[no connection]" );

        return KNullDesC();

        }

    LOG_WRITEF( "connection name: %S", &iWlanNetworkName );

    return iWlanNetworkName;

    }

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

// CWsfWlanBearerConnectionMonitor::FindWlanBearerConnectedL

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

//

void CWsfWlanBearerConnectionMonitor::FindWlanBearerConnectedL()

    {

    LOG_ENTERFN( "CWsfWlanBearerConnectionMonitor::FindWlanBearerConnectedL" );

    CWsfActiveWaiter* waiter = CWsfActiveWaiter::NewLC();

    TUint connectionNumber( 0 );

    iMonitor.GetConnectionCount( connectionNumber, waiter->iStatus );

    waiter->WaitForRequest();

    if ( !waiter->iStatus.Int() )

        {

        TBool connectionIDFound = EFalse;

        for ( TUint i = 1; i <= connectionNumber; ++i )

            {

            TUint connectionId( 0 );

            TUint subConnectionCount( 0 );

            User::LeaveIfError( iMonitor.GetConnectionInfo( i, connectionId, 

                                                        subConnectionCount ) );

            if ( CheckConnectionDetailsL( connectionId ) )

                {

                LOG_WRITEF( "found connection %d", connectionId );

                connectionIDFound = ETrue;

                iConnectionId = connectionId;

                break;

                }

            }

        if ( !connectionIDFound )

            {

            LOG_WRITE( "Reset connection ID" );

            iConnectionId = KNoConnection;

            }

        }

    else

        {

        LOG_WRITEF( "GetConnectionCount failed error = %d", 

                                                    waiter->iStatus.Int() );

        }

    CleanupStack::PopAndDestroy( waiter );

    }

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

// CWsfWlanBearerConnectionMonitor::EventL

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

//

void CWsfWlanBearerConnectionMonitor::EventL( 

                                       const CConnMonEventBase& aConnMonEvent )

    {

    LOG_ENTERFN( "CWsfWlanBearerConnectionMonitor::EventL" );

    TConnMonEvent event = TConnMonEvent( aConnMonEvent.EventType() );

    TInt connectionId = aConnMonEvent.ConnectionId();

    LOG_WRITEF( "event = %d", (TInt)event );

    switch ( event )

        {

        case EConnMonCreateConnection:

            {

            LOG_WRITEF( "EConnMonCreateConnection id = %d", 

                        connectionId );

            break;

            }

        case EConnMonConnectionStatusChange:

            {

            LOG_WRITEF( "EConnMonConnectionStatusChange id = %d", 

                        connectionId );

            const CConnMonConnectionStatusChange* statusChangeEvent = 

                        static_cast<const CConnMonConnectionStatusChange*>( 

                                                              &aConnMonEvent );

            LOG_WRITEF( "EConnMonConnectionStatusChange status = %d", 

                        statusChangeEvent->ConnectionStatus() );

            if ( statusChangeEvent->ConnectionStatus() == KConnectionOpen &&

                 !iConnectionOwned )

                {

                LOG_WRITE( "connection status: open" );

                TBool wlanEvent( EFalse );

                wlanEvent = CheckConnectionDetailsL( connectionId );

                if ( wlanEvent )

                    {

                    LOG_WRITEF( "[%S] connected, id = %d", 

                                &iWlanNetworkName, connectionId );

                    // notify observer ...

                    iConnectionId = connectionId;

                    iObserver->ConnectionEstablishedL( iWlanNetworkName );

                    }

                }

            break;

            }                

        case EConnMonDeleteConnection:

            {

            LOG_WRITEF( "EConnMonDeleteConnection id = %d", connectionId );

            if ( connectionId == iConnectionId )

                {

                if ( iConnectionOwned )

                    {

                    LOG_WRITE( "connection was owned, manual closing" );

                    ShutdownOwnedConnectionL();

                    }

                else

                    {

                    LOG_WRITE( "connection was not owned" );

                    iWlanNetworkName.Zero();

                    iConnectionId = KNoConnection;

                    // notify observer

                    iObserver->ConnectionLostL();

                    }

                }

            break;

            }

        default:

            {

            }

        }

    }

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

// CWsfWlanBearerConnectionMonitor::CheckConnectionDetailsL

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

//

TBool CWsfWlanBearerConnectionMonitor::CheckConnectionDetailsL( 

                                                         TUint aConnectionId )

    {

    LOG_ENTERFN( "CWsfWlanBearerConnectionMonitor::CheckConnectionDetailsL" );

    LOG_WRITEF( "aConnectionId: %d", aConnectionId );

    TConnMonBearerType bearerType( EBearerUnknown );

    TBool foundWlanBearer( EFalse );

    // Add only connections with valid id

    if ( aConnectionId > 0 )

        {

        CWsfActiveWaiter* waiter = CWsfActiveWaiter::NewLC();

        iMonitor.GetIntAttribute( aConnectionId, 0, KBearer, 

                                  (TInt&)bearerType, 

                                  waiter->iStatus );

        waiter->WaitForRequest();

        LOG_WRITEF( "found bearer: %d", bearerType );        

        if ( waiter->iStatus.Int() == KErrNone )

            {

            LOG_WRITE( "status: KErrNone" );

            if ( bearerType == EBearerWLAN )

                {

                iMonitor.GetStringAttribute( aConnectionId, 0, KNetworkName, 

                                         iWlanNetworkName, waiter->iStatus );

                waiter->WaitForRequest();        

                if ( waiter->iStatus.Int() == KErrNone )

                    {

                    LOG_WRITEF( "WLAN network name: %S", &iWlanNetworkName );

                    foundWlanBearer = ETrue;

                    }

                }

            }

        else

            {

            LOG_WRITEF( "status: %d", waiter->iStatus.Int() );

            }

        CleanupStack::PopAndDestroy( waiter );

        }

    return foundWlanBearer;

    }

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

// CWsfWlanBearerConnectionMonitor::StartMonitoringL

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

//

void CWsfWlanBearerConnectionMonitor::StartMonitoringL( 

                                           MWsfWlanMonitorObserver* aObserver )

    {

    LOG_ENTERFN( "CWsfWlanBearerConnectionMonitor::StartMonitoringL" );        

    __ASSERTD( aObserver );

    iObserver = aObserver;

    if ( !iMonitoring )

        {

        iMonitoring = ETrue;

        iMonitor.NotifyEventL( *this );

        }

    }

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

// CWsfWlanBearerConnectionMonitor::StopMonitoring

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

//

void CWsfWlanBearerConnectionMonitor::StopMonitoring()

    {

    LOG_ENTERFN( "CWsfWlanBearerConnectionMonitor::StopMonitoring" );        

    if ( iMonitoring )

        {

        iMonitoredAp = 0;

        iMonitoring = EFalse;

        iMonitor.CancelNotifications();

        }

    }

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

// CWsfWlanBearerConnectionMonitor::ConnectBearer

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

//

TInt CWsfWlanBearerConnectionMonitor::ConnectBearer( TUint32 aIapId,

                                                     TBool aConnectOnly,

                                                     TBool aTestAccessPoint )

    {

    LOG_ENTERFN( "CWsfWlanBearerConnectionMonitor::ConnectBearer" );

    if ( iConnectionId != KNoConnection || iConnectingState != ECsIdle )

        {

        // there is already a connection

        LOG_WRITE( "there is already a WLAN connection" );

        return KErrWlanConnAlreadyActive;

        }

    // self-completion

    if ( iConnectingState == ECsIdle )

        {

        LOG_WRITE( "initiating connection process" );

        iConnIap = aIapId;

        iConnectingState = ECsNotConnected;

        iConnectionOwned = ETrue;

        iServerCloser.WaitForOwnedConnection( ETrue );

        TRAPD( err, iIct->InitializeIctL( aTestAccessPoint, aIapId, 

                                          aConnectOnly ) );

        if ( err )

            {

            LOG_WRITEF( "Ict initialization failed error = %d", err );

            }

        SetActive();

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrNone );

        }

    return KErrNone;

    }

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

// CWsfWlanBearerConnectionMonitor::DisconnectBearer

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

//

TBool CWsfWlanBearerConnectionMonitor::DisconnectBearer()

    {

    LOG_ENTERFN( "CWsfWlanBearerConnectionMonitor::DisconnectBearer" );

    if ( iConnectionId != KNoConnection )

        {

        LOG_WRITEF( "closing connection id = %d", iConnectionId );

        iMonitor.SetBoolAttribute( iConnectionId, 0, KConnectionStop, ETrue );

        }

    return ( iConnectionId != KNoConnection );

    }

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

// CWsfWlanBearerConnectionMonitor::AbortConnecting

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

//

TInt CWsfWlanBearerConnectionMonitor::AbortConnecting()

    {

    LOG_ENTERFN( "CWsfWlanBearerConnectionMonitor::AbortConnecting" );

    TInt result = KErrGeneral;

    if ( iConnectingState != ECsIdle )

        {

        LOG_WRITE( "connection in progress, aborting");

        iAborting = ETrue;

        if ( IsActive() && iConnectingState == ECsSocketOpened )

            {

            LOG_WRITE( "forcing connection to stop" );

            result = iConnection.Stop();

            }

        }

    return result;

    }

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

// CWsfWlanBearerConnectionMonitor::MonitorAccessPoint

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

//

void CWsfWlanBearerConnectionMonitor::MonitorAccessPoint( TUint32 aIapId )    

    {

    LOG_ENTERFN( "CWsfWlanBearerConnectionMonitor::MonitorAccessPoint" );

    iMonitoredAp = aIapId;

    }

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

// CWsfWlanBearerConnectionMonitor::ConnectedWlanConnectionDetailsL

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

//

TBool CWsfWlanBearerConnectionMonitor::ConnectedWlanConnectionDetailsL( 

                                                     TWsfWlanInfo* aWlanInfo )

    {