/*

* Copyright (c) 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:

* Main implementation of Wlan Sniffer Keepalive application.

*/

// System include files

#include <rconnmon.h>

// User include files

#include "wsfkeepalivetimer.h"

#include "wsfkeepalivecmm.h"

#include "wsfkeepaliveconnmon.h"

#include "wsfkeepaliveconnmondisc.h"

#include "wsfkeepaliveesock.h"

#include "wsfkeepalive.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "wsfkeepaliveTraces.h"

#endif

// External function prototypes

// Local constants

// We need to poll for client info every 5 seconds

static const int KKeepalivePollInterval = 5000000;

// We can close a connection after 5 minutes of inactivity

static const int KKeepaliveInactivityInterval = 300;

// UID of Wlan sniffer application

static const TUid KWlanSnifferUid = { 0x10281CAA };

// UID of Wlan login application

static const TUid KWlanloginUid = { 0x2002E6D0 };

// List of UIDs of clients not considered as "real"

static const TUid KDiscardedClientUids[] = 

    {

        { 0x2002FF5F }, // Sniffer keepalive process, that is, us

        KWlanSnifferUid, // Sniffer application (wlansniffer.exe)

        KWlanloginUid, //   Wlan Login application (wlanlogin.exe)

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

    };

// ======== LOCAL FUNCTIONS ========

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

CWsfKeepalive* CWsfKeepalive::NewL()

    {

    OstTraceFunctionEntry0( CWSFKEEPALIVE_NEWL_ENTRY );

    CWsfKeepalive* me = new ( ELeave ) CWsfKeepalive();

    CleanupStack::PushL( me );

    me->ConstructL();

    CleanupStack::Pop( me );

    OstTraceFunctionExit0( CWSFKEEPALIVE_NEWL_EXIT );

    return me;

    }

CWsfKeepalive::~CWsfKeepalive()

    {

    OstTraceFunctionEntry0( DUP1_CWSFKEEPALIVE_CWSFKEEPALIVE_ENTRY );

    delete iEsock;

    delete iConnMonDisc;

    delete iCmMgr;

    delete iConnMon;

    delete iTimer;

    OstTraceFunctionExit0( DUP1_CWSFKEEPALIVE_CWSFKEEPALIVE_EXIT );

    }

void CWsfKeepalive::TimerExpired( TInt aError )

    {

    OstTraceFunctionEntry0( CWSFKEEPALIVE_TIMEREXPIRED_ENTRY );

    TBool restartTimer = ETrue; // Should we restart timer or not?

    if ( aError == KErrNone )

        {

        // Timer successfully completed, handle it

        if ( NoRealClients( iConnectionId ) )

            {

            TTime now;

            now.UniversalTime();

            // Check whether we are moving from EActiveWithClients to

            // EActiveNoClients

            if ( iState == EActiveWithClients )

                {

                OstTrace0(

                    TRACE_NORMAL,

                    CWSFKEEPALIVE_TIMEREXPIRED_RESET,

                    "CWsfKeepalive::TimerExpired Keepalive time reset" );

                // Connection had clients, but doesn't anymore. Keepalive

                // inactivity time starts now

                iKeepaliveStart = now;

                }

            // Check whether keepalive time has been reached

            else if ( iKeepaliveStart +

                TTimeIntervalSeconds( KKeepaliveInactivityInterval ) <= now )

                {

                OstTrace0(

                    TRACE_NORMAL,

                    CWSFKEEPALIVE_TIMEREXPIRED_DONE,

                    "CWsfKeepalive::TimerExpired Keepalive time expired" );

                // Keepalive time limit expired, connection should be stopped

                iEsock->Disconnect();

                iConnMonDisc->Disconnect( iConnectionId );

                restartTimer = EFalse;

                }

            // There are now no real clients for the connection

            SetState( EActiveNoClients );

            }

        else

            {

            // One or more real clients are using the connection

            SetState( EActiveWithClients );

            }

        }

    else

        {

        // Timer not successful, probably because we stopped it

        restartTimer = EFalse;

        }

    if ( restartTimer )

        {

        TTimeIntervalMicroSeconds32 interval( KKeepalivePollInterval );

        iTimer->After( interval );

        }

    OstTraceFunctionExit0( CWSFKEEPALIVE_TIMEREXPIRED_EXIT );

    }

void CWsfKeepalive::WlanConnectionOpenedL( TUint aConnectionId, TUint aIapId )

    {

    OstTraceFunctionEntry0( CWSFKEEPALIVE_WLANCONNECTIONOPENEDL_ENTRY );

    OstTraceExt2(

        TRACE_NORMAL,

        CWSFKEEPALIVE_WLANCONNECTIONOPENED,

        "CWsfKeepalive::WlanConnectionOpened;aConnectionId=%u;aIapId=%u",

        aConnectionId,

        aIapId );

    // We are only interested in connections opened by the Wlan Sniffer

    if ( OpenedByWlanSniffer( aConnectionId ) )

        {

        // Start to monitor this connection, and add us as a user to the

        // connection

        iConnectionId = aConnectionId;

        iIapId = aIapId;

        iEsock->ConnectL( aIapId );

        // Assume there are no real clients yet. Setup timer for polling

        // when real clients might be added to the connection

        SetState( EActiveNoClients );

        iKeepaliveStart.UniversalTime();

        OstTrace0(

            TRACE_NORMAL,

            CWSFKEEPALIVE_WLANCONNECTIONOPENED_RESET,

            "CWsfKeepalive::WlanConnectionOpened Keepalive time reset" );

        TTimeIntervalMicroSeconds32 interval( KKeepalivePollInterval );

        iTimer->After( interval );

        }

    OstTraceFunctionExit0( CWSFKEEPALIVE_WLANCONNECTIONOPENEDL_EXIT );

    }

void CWsfKeepalive::WlanConnectionClosed()

    {

    OstTraceFunctionEntry0( CWSFKEEPALIVE_WLANCONNECTIONCLOSED_ENTRY );

    // No need to monitor anything anymore

    SetState( EInactive );

    iConnectionId = KInvalidConnectionId;

    // Stop also the polling timer

    iTimer->Stop();

    OstTrace1(

        TRACE_NORMAL,

        CWSFKEEPALIVE_WLANCONNECTIONCLOSED_IAPID,

        "CWsfKeepalive::WlanConnectionClosed iapId=%d",

        iIapId );

    // If connected to hotspot IAP, the IAP must be deleted

    if ( iCmMgr->GetHotspotInfoL( iIapId ) )

        {

        OstTrace0(

            TRACE_NORMAL,

            CWSFKEEPALIVE_WLANCONNECTIONCLOSED_HOTSPOTDETECTED,

            "CWsfKeepalive::WlanConnectionClosed Hotspot IAP detected" );

        if ( !iCmMgr->DeleteHotspotIapL( iIapId ) )

            {

            OstTrace0(

                TRACE_NORMAL,

                CWSFKEEPALIVE_WLANCONNECTIONCLOSED_HOTSPOTDELETEFAILED,

                "CWsfKeepalive::WlanConnectionClosed Hotspot delete failed" );

            }

        iIapId = 0;

        }

    OstTraceFunctionExit0( CWSFKEEPALIVE_WLANCONNECTIONCLOSED_EXIT );

    }

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

// Default constructor

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

//

CWsfKeepalive::CWsfKeepalive() :

    iConnectionId( KInvalidConnectionId ),

    iState( EInactive ),

    iIapId( 0 )

    {

    OstTraceFunctionEntry0( CWSFKEEPALIVE_CWSFKEEPALIVE_ENTRY );

    OstTraceFunctionExit0( CWSFKEEPALIVE_CWSFKEEPALIVE_EXIT );

    }

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

// Leaving constructor

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

//

void CWsfKeepalive::ConstructL()

    {

    OstTraceFunctionEntry0( CWSFKEEPALIVE_CONSTRUCTL_ENTRY );

    iTimer = CWsfKeepaliveTimer::NewL( *this );

    iConnMon = CWsfKeepaliveConnMon::NewL( *this );

    iConnMonDisc = CWsfKeepaliveConnMonDisc::NewL();

    iEsock = CWsfKeepaliveEsock::NewL();

    iCmMgr = CWsfKeepaliveCmm::NewL();

    OstTraceFunctionExit0( CWSFKEEPALIVE_CONSTRUCTL_EXIT );

    }

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

// Checks whether the given connection was opened by the Wlan Sniffer

// application

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

//

TBool CWsfKeepalive::OpenedByWlanSniffer( TUint aConnectionId )

    {

    OstTraceFunctionEntry0( CWSFKEEPALIVE_OPENEDBYWLANSNIFFER_ENTRY );

    TBool retVal = EFalse;

    // Get all clients of this connection

    TConnMonClientEnumBuf clientInfo;

    iConnMon->GetClientInfo( clientInfo, aConnectionId );

    // Check whether Wlan sniffer is one of the clients

    for ( TInt i( 0 ); i < clientInfo().iCount; ++i )

        {

        if ( clientInfo().iUid[i] == KWlanSnifferUid )

            {

            // Match found, stop looking

            retVal = ETrue;

            break;

            }

        }

    OstTraceExt2(

        TRACE_NORMAL,

        CWSFKEEPALIVE_OPENEDBYWLANSNIFFER,

        "CWsfKeepalive::OpenedByWlanSniffer;aConnectionId=%u;retVal=%u",

        aConnectionId,

        retVal );

    OstTraceFunctionExit0( CWSFKEEPALIVE_OPENEDBYWLANSNIFFER_EXIT );

    return retVal;

    }

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

// Checks whether there are any real clients using the given connection

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

//

TBool CWsfKeepalive::NoRealClients( TUint aConnectionId )

    {

    OstTraceFunctionEntry0( CWSFKEEPALIVE_NOREALCLIENTS_ENTRY );

    // Get all clients of this connection

    TConnMonClientEnumBuf clientInfo;

    iConnMon->GetClientInfo( clientInfo, aConnectionId );

    // Get the client count

    TInt clientCount = clientInfo().iCount;

    TInt discardedClientCount = sizeof( KDiscardedClientUids ) / sizeof( TUid );

    // Decrease count by each non-real client we must discard

    for ( TInt i( 0 ); i < clientInfo().iCount; ++i )

        {

        for ( TInt j( 0 ); j < discardedClientCount; ++j )

            {

            if ( clientInfo().iUid[i] == KDiscardedClientUids[j] )

                {

                OstTrace1(

                    TRACE_NORMAL,

                    CWSFKEEPALIVE_NOREALCLIENTS_DISCARD,

                    "CWsfKeepalive::NoRealClients Client discarded;clientInfo().iUid[i].iUid=%x",

                    clientInfo().iUid[i].iUid );

                --clientCount;

                break;

                }

            }

        }

    // If we reached zero, there were no real clients

    TBool retVal = clientCount == 0 ? ETrue : EFalse;

    OstTraceExt2(

        TRACE_NORMAL,

        CWSFKEEPALIVE_NOREALCLIENTS,

        "CWsfKeepalive::NoRealClients;aConnectionId=%u;retVal=%u",

        aConnectionId,

        retVal );

    OstTraceFunctionExit0( CWSFKEEPALIVE_NOREALCLIENTS_EXIT );

    return retVal;

    }

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

// Sets the given state and traces the transition, if state changed.

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

//

void CWsfKeepalive::SetState( TUint aState )

    {

    OstTraceFunctionEntry0( CWSFKEEPALIVE_SETSTATE_ENTRY );

#ifdef OST_TRACE_COMPILER_IN_USE

    if ( aState != iState )

        {

        OstTrace1(

            TRACE_NORMAL,

            CWSFKEEPALIVE_SETSTATE,

            "CWsfKeepalive::SetState;aState=%{State}",

            aState );

        }

#endif

    iState = aState;

    OstTraceFunctionExit0( CWSFKEEPALIVE_SETSTATE_EXIT );

    }