/*

* Copyright (c) 2002-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:  Core functionality for ConnMon.

*

*/

#include <mmtsy_names.h>

#include <featmgr.h>

#include <rmmcustomapi.h>

#include <utf.h>

#include <es_sock_partner.h>

#include "ConnMonServ.h"

#include "ConnMonSess.h"

#include "CEventQueue.h"

#include "CCsdFax.h"

#include "CPsdFax.h"

#include "ConnMonIAP.h"

#include "ConnMonNoti.h"

#include "CDataVolume.h"

#include "connmondtmnoti.h"

#include "connmontelnoti.h"

#include "ConnMonBearerNotifier.h"

#include "log.h"

#include "cellulardatausagekeyupdater.h"

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

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

// TConnInfo::TConnInfo

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

//

TConnInfo::TConnInfo(

        TInt aIapId,

        TInt aNetId,

        TUint aConnectionId,

        TInt aBearer,

        TBearerInfo aBearerInfo )

        :

        iIapId( aIapId ),

        iNetId( aNetId ),

        iConnectionId( aConnectionId ),

        iBearer( aBearer ),

        iConnAttach( 0 ),

        iProgressNotifier( 0 ),

        iDLDataNotifier( 0 ),

        iULDataNotifier( 0 ),

        iDataVolumeAO( 0 ),

        iConnDownNotifier( 0 ),

        iActivityNotifier( 0 ),

        iActivity( 0 ),

        iBearerInfo( aBearerInfo ),

    {

    }

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

// TConnInfo::Reset

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

//

void TConnInfo::Reset()

    {

    // Only call this function to initialize a newly created TConnInfo-object.

    // (There is no cleanup)

    iIapId            = 0;

    iNetId            = 0;

    iConnectionId     = 0;

    iBearer           = EBearerUnknown;

    iBearerInfo.iBearer = EBearerInfoUnknown;

    iBearerInfo.iInternal = ETrue;

    iProgressNotifier = 0;

    iDLDataNotifier   = 0;

    iULDataNotifier   = 0;

    iDataVolumeAO     = 0;

    iConnAttach       = 0;

    iConnDownNotifier = 0;

    iActivityNotifier = 0;

    iActivity         = 0;

    iBearerNotifier   = 0;

    }

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

// TConnInfo::Compare

// Compares two TConnInfo items (by connection id).

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

//

TInt TConnInfo::Compare( const TConnInfo& aFirst, const TConnInfo& aSecond )

    {

    if ( aFirst.iConnectionId < aSecond.iConnectionId )

        {

        return -1;

        }

    if ( aFirst.iConnectionId > aSecond.iConnectionId )

        {

        return 1;

        }

    return 0;

    }

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

// TConnInfo::MatchId

// Finds TConnInfo item matching by connection Id.

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

//

TBool TConnInfo::MatchId( const TConnInfo& aFirst, const TConnInfo& aSecond )

    {

    if ( aFirst.iConnectionId == aSecond.iConnectionId )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// TConnInfo::MatchIap

// Finds TConnInfo item matching by iap id and net id.

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

//

TBool TConnInfo::MatchIap( const TConnInfo& aFirst, const TConnInfo& aSecond )

    {

    // Only internal bearers can be matched by IapId and NetId

    if ( ( aFirst.iIapId == aSecond.iIapId ) && ( aFirst.iNetId == aSecond.iNetId ) &&

         ( aFirst.iBearer < EBearerExternalCSD ) && ( aSecond.iBearer < EBearerExternalCSD ) &&

         ( aFirst.iBearerInfo.iInternal ) && ( aSecond.iBearerInfo.iInternal ) )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// TConnInfo::MatchBearer

// Finds TConnInfo item matching by bearer.

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

//

TBool TConnInfo::MatchBearer( const TConnInfo& aFirst, const TConnInfo& aSecond )

    {

    // External CSD bearers (there is no event availabe for bearer change)

    if ( ( aFirst.iBearer == EBearerExternalCSD || aFirst.iBearer == EBearerExternalHSCSD ||

           aFirst.iBearer == EBearerExternalWcdmaCSD )

         &&

         ( aSecond.iBearer == EBearerExternalCSD || aSecond.iBearer == EBearerExternalHSCSD ||

           aSecond.iBearer == EBearerExternalWcdmaCSD ) )

        {

        return ETrue;

        }

    // External PSD bearers (there is not always an event availabe for bearer change)

    else if ( ( aFirst.iBearer == EBearerExternalGPRS     ||

                aFirst.iBearer == EBearerExternalEdgeGPRS ||

                aFirst.iBearer == EBearerExternalWCDMA    ||

                aFirst.iBearer == EBearerExternalCDMA2000 ||

                ( !aFirst.iBearerInfo.iInternal &&

                  ( aFirst.iBearerInfo.iBearer == EBearerInfoHSDPA ||

                    aFirst.iBearerInfo.iBearer == EBearerInfoHSUPA ||

                    aFirst.iBearerInfo.iBearer == EBearerInfoHSxPA ) ) )

              &&

              ( aSecond.iBearer == EBearerExternalGPRS     ||

                aSecond.iBearer == EBearerExternalEdgeGPRS ||

                aSecond.iBearer == EBearerExternalWCDMA    ||

                aSecond.iBearer == EBearerExternalCDMA2000 ||

                ( !aSecond.iBearerInfo.iInternal &&

                  ( aSecond.iBearerInfo.iBearer == EBearerInfoHSDPA ||

                    aSecond.iBearerInfo.iBearer == EBearerInfoHSUPA ||

                    aSecond.iBearerInfo.iBearer == EBearerInfoHSxPA ) ) ) )

        {

        return ETrue;

        }

    // Other bearers

    else if ( aFirst.iBearer == aSecond.iBearer &&

            aFirst.iBearerInfo.iBearer == aSecond.iBearerInfo.iBearer )

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

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

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

// CConnMonIAP::CConnMonIAP

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

//

CConnMonIAP::CConnMonIAP( CConnMonServer* aServer )

        :

        iServer( aServer ),

        iEndUserNetIds( KNullDesC8 )

    {

    }

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

// CConnMonIAP::ConstructL

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

//

void CConnMonIAP::ConstructL()

    {

    LOGENTRFN("CConnMonIAP::ConstructL()")

    TInt err( KErrNone );

    // Connect to socket server and use system global pool (-1) for message slots.

    User::LeaveIfError( iSocketServer.Connect( static_cast<TUint>( -1 ) ) );

    LOGIT("(01/11) Loaded OK: ESock")

    // Open RConnection. This object is not attached to any connection

    User::LeaveIfError( iConnection.Open( iSocketServer ) );

    LOGIT("(02/11) Opened OK: RConnection")

    // Connect to ETel server

    TBuf<KCommsDbSvrMaxColumnNameLength> tsyName;

    tsyName.Copy( KMmTsyModuleName );

    // The RTelServer::Connect() might not always work with the first trial,

    // because of a coding error related to using semaphores in the method.

    for ( TInt a = 0; a < KPhoneRetryCount; a++ )

        {

        err = iTelServer.Connect();

        if ( KErrNone == err )

            {

            break;

            }

        User::After( KPhoneRetryTimeout );

        LOGIT("RTelServer::Connect() failed, trying again.")

        }

    User::LeaveIfError( err );

    LOGIT("(03/11) Loaded OK: ETel")

    // Initialize FeatureManager

    FeatureManager::InitializeLibL();

    LOGIT("(04/11) Loaded OK: FeatureManager")

    // Try to load tsy

    err = iTelServer.LoadPhoneModule( tsyName );

    if ( KErrNone == err )

        {

        LOGIT("(05/11) Loaded OK: TSY")

        iTSYLoaded = 1;

        // Phone info can be retrieved with value 0 if there is only one phone

        RTelServer::TPhoneInfo info;

        User::LeaveIfError( iTelServer.GetPhoneInfo( 0, info ) );

        LOGIT("(06/11) Loaded OK: Phone info")

        User::LeaveIfError( iMobilePhone.Open( iTelServer, info.iName ) );

        LOGIT("(07/11) Opened OK: RMobilePhone")

        // Open packet service

        err = iPacketService.Open( iMobilePhone );

        if ( KErrNone == err )

            {

            LOGIT("(08/11) Loaded OK: Packet service")

            iPacketServLoaded = 1;

            // CDMA network does not support external connections. PSD Fax handler module

            // should not be created when in CDMA network. The code below works OK as long

            // as there is no phone that supports both CDMA and GSM at the same time.

            if ( !FeatureManager::FeatureSupported( KFeatureIdProtocolCdma ) )

                {

                // Create PSD Fax handler module

                iPsdFax = new( ELeave ) CPsdFax(

                        iServer,

                        &iTelServer,

                        &iMobilePhone,

                        &iPacketService );

                iPsdFax->ConstructL();

                LOGIT("(09/11) Loaded OK: PSD module")

                }

            else

                {

                LOGIT("(09/11) Nosupport: PSD module not loaded, no PSD support in CDMA networks.")

                }

            }

        else

            {

            LOGIT1("(08/11) Loaderror: Packet service failed with code <%d>", err)

            }

        // CDMA network does not support external connections. CSD Fax handler module

        // should not be created when in CDMA network. The code below works OK as long

        // as there is no phone that supports both CDMA and GSM at the same time.

        if ( !FeatureManager::FeatureSupported( KFeatureIdProtocolCdma ) )

            {

            // Create CSD Fax handler module

            iCsdFax = new( ELeave ) CCsdFax( iServer, &iTelServer, &iMobilePhone );

            iCsdFax->ConstructL();

            LOGIT("(10/11) Loaded OK: CSD module")

            }

        else

            {

            LOGIT("(10/11) Nosupport: CSD module not loaded, no CSD support in CDMA networks")

            }

        }

    else

        {

        LOGIT1("(05/11) Loaderror: TSY failed with code <%d>", err)

        }

    // Open WLAN Management service

    if ( FeatureManager::FeatureSupported( KFeatureIdProtocolWlan ) )

        {

        TRAPD( leaveCode, iWlanSupport = CWlanSupport::NewL( iServer ) );

        if ( KErrNone != leaveCode )

            {

            LOGIT1("(11/11) Loaderror: WLAN module failed with code <%d>", leaveCode)

            }

        else

            {

            LOGIT("(11/11) Loaded OK: WLAN module")

            }

        }

    else

        {

        LOGIT("(11/11) Nosupport: WLAN module not loaded, no WLAN support detected")

        }

    LOGEXITFN("CConnMonIAP::ConstructL()")

    }

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

// CConnMonIAP::~CConnMonIAP

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

//

// Destructor

CConnMonIAP::~CConnMonIAP()

    {

    LOGENTRFN("CConnMonIAP::~CConnMonIAP()")

    // Delele dial up modules.

    delete iCsdFax;

    iCsdFax = NULL;

    delete iPsdFax;

    iPsdFax = NULL;

    // Delete global notifications. This must be called before

    // services are closed or destroyed below.

    DeleteNotifications();

    // Delete connection up/down notification.

    if ( iConnUpDownNotifier != 0 )

        {

        iConnUpDownNotifier->Cancel();

        delete iConnUpDownNotifier;

        }

    // Close all attached connections

    TInt count = iConnInfos.Count();

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

        {

        if ( iConnInfos[i].iConnAttach != 0 )

            {

            iConnInfos[i].iConnAttach->Close();

            delete iConnInfos[i].iConnAttach;

            }

        }

    // Note. all sessions have closed by now.

    // There is no need to delete connection parameters

    // because session destructors have already done that.

    iConnInfos.Close();

    // Close "global" ESOCK objects

    iConnection.Close();

    iSocketServer.Close();

    // Close "global" ETEL objects

    if ( iPacketServLoaded == 1 )

        {

        iPacketService.Close();

        }

    iMobilePhone.Close();

    iTelServer.Close();

    // Unload FeatureManager

    FeatureManager::UnInitializeLib();

    // Destroy WLAN service

    delete iWlanSupport;

    iWlanSupport = NULL;

    // Reset global pointers

    iServer                        = NULL;

    iPsdNetwStatusNotifier         = NULL;

    iNetwRegistrationNotifier      = NULL;

    iEdgeNotifier                  = NULL;

    iWcdmaNotifier                 = NULL;

    iModeNotifier                  = NULL;

    iGSMSignalNotifier             = NULL;

    iGSMBearerAvailabilityNotifier = NULL;

    // Clean up all ECom sessions

    // More info about it: TSW EGUO-64LD36

    REComSession::FinalClose();

    LOGEXITFN("CConnMonIAP::~CConnMonIAP()")

    }

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

// CConnMonIAP::EnumerateConnections

// Enumerates active connections using RConnection API.

// Refreshes iConnInfos array (server view) with the latest information.

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

//

TInt CConnMonIAP::EnumerateConnections( TUint& aCount )

    {

    // Server must be 'blocked' while updating the connection table.

    TBearerInfo bearerInfo;

    TConnInfo connInfo( 0, 0, 0, 0, bearerInfo );

    TInt err( KErrNone );

    aCount = 0;

    RArray<TConnInfo> tempArray;

    // Get existing external (fax) CSD connections

    // These can't be enumerated from ETEL at the moment

    if ( iCsdFax )

        {

        // In practise there can be only ONE fax connection of this type

        connInfo.Reset();

        connInfo.iBearer = EBearerExternalCSD; // This will match any ext-CSD

        connInfo.iBearerInfo.iBearer = EBearerInfoCSD;

        connInfo.iBearerInfo.iInternal = EFalse;

        TInt index = iConnInfos.Find( connInfo, TConnInfo::MatchBearer );

        if ( ( KErrNotFound != index ) && iCsdFax->IsValid() )

            {

            // Add to temp array

            tempArray.Append( iConnInfos[index] );

            aCount++;

            }

        else if ( !iConnUpDownNotifier )

            {

            // Try to find out about external CSD connections

            // that were alive before CM server started.

            // The code below will be executed only when

            // this method is called for the first time.

            err = iCsdFax->FindCall();

            if ( KErrNone == err )

                {

                iCsdFax->GetBearer( connInfo.iBearer, connInfo.iBearerInfo );

                connInfo.iConnectionId = NewConnectionId(); // New unique Id

                iCsdFax->SetConnectionId( connInfo.iConnectionId );

                tempArray.Append( connInfo );

                aCount++;

                }

            }

        }

    // Get existing external (fax) PSD connections

    // These connections can't be enumerated from ETEL at the moment

    // Only notification of a new connection is available from ETEL.

    if ( iPsdFax )

        {

        connInfo.Reset();

        connInfo.iBearer = EBearerExternalGPRS; // This will match any ext-PSD

        connInfo.iBearerInfo.iBearer = EBearerInfoGPRS;

        connInfo.iBearerInfo.iInternal = EFalse;

        // Check all external PSD connections

        for ( TUint index = 0; index < iConnInfos.Count(); index++ )

            {

            // Check that connection bearer is external PSD

            if ( iConnInfos[index].iBearer == EBearerExternalGPRS       ||

                 iConnInfos[index].iBearer == EBearerExternalEdgeGPRS   ||

                 iConnInfos[index].iBearer == EBearerExternalWCDMA      ||

                 iConnInfos[index].iBearer == EBearerExternalCDMA2000   ||

                 ( !iConnInfos[index].iBearerInfo.iInternal &&

                   ( iConnInfos[index].iBearerInfo.iBearer == EBearerInfoHSDPA ||

                     iConnInfos[index].iBearerInfo.iBearer == EBearerInfoHSUPA ||

                     iConnInfos[index].iBearerInfo.iBearer == EBearerInfoHSxPA ) ) )

                {

                // Check if connection is still valid

                if ( iPsdFax->IsValid( iConnInfos[index].iConnectionId ) )

                    {

                    // Add to temp array