/*

* Copyright (c) 2007-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: MPM CommsDat access functions

*

*/

/**

@file mpmcommsdataccess.cpp

Mobility Policy Manager CommsDat access functions.

*/

// INCLUDE FILES

#include <e32base.h>

#include <commdb.h>

#include <metadatabase.h>

#include <commsdattypeinfov1_1.h>

#include <commsdattypesv1_1.h>

#include <datamobilitycommsdattypes.h>

#include <cmpluginbaseeng.h>

#include <WlanCdbCols.h>

#include <cmmanagerdef.h>

#include <cmconnectionmethoddef.h>

#include <wlancontainer.h>

#include <utf.h>

#include <cmpluginwlandef.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <commsdattypeinfov1_1_internal.h>

#include <commsdattypesv1_1_partner.h>

#endif

#include <in_sock.h>

#include <cmgenconnsettings.h>

#include <cmdestination.h>

#include "mpmcommsdataccess.h"

#include "mpmserversession.h"

#include "mpmconnmonevents.h"

#include "mpmiapselection.h"

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

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

// CMPMCommsDatAccess::NewL

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

//

CMPMCommsDatAccess* CMPMCommsDatAccess::NewL()

    {

    CMPMCommsDatAccess* self = new ( ELeave ) CMPMCommsDatAccess();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CMPMCommsDatAccess::CMPMCommsDatAccess

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

//

CMPMCommsDatAccess::CMPMCommsDatAccess()

    {

    }

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

// CMPMCommsDatAccess::ConstructL

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

//

void CMPMCommsDatAccess::ConstructL()

    {

    }

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

// CMPMCommsDatAccess::~CMPMCommsDatAccess

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

//

CMPMCommsDatAccess::~CMPMCommsDatAccess()

    {

    }

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

// CMPMCommsDatAccess::FindAllSnapsL

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

//

void CMPMCommsDatAccess::FindAllSnapsL( RArray<TUint>& aSnapIds )

    {

    MPMLOGSTRING( "CMPMCommsDatAccess::FindAllSnapsL " )

    CMDBSession* db = CMDBSession::NewLC( KCDVersion1_1 );

    // Get the table id from generic

    // 

    CMDBGenericRecord* generic = static_cast<CMDBGenericRecord*>

        ( CCDRecordBase::RecordFactoryL( 0 ) );

    CleanupStack::PushL( generic );

    generic->InitializeL( TPtrC( KCDTypeNameDataMobilitySelectionPolicy ), 

                          NULL );

    generic->LoadL( *db );

    // Create the DN-IAP record set

    // 

    CMDBRecordSet<CCDDataMobilitySelectionPolicyRecord>* dnIAPRecordSet = 

        new ( ELeave ) CMDBRecordSet<CCDDataMobilitySelectionPolicyRecord>( 

        generic->TableId() );

    CleanupStack::PushL( dnIAPRecordSet );

    dnIAPRecordSet->LoadL( *db );

    for ( TInt i = 0; i < dnIAPRecordSet->iRecords.Count(); i++ )

        {

        CCDDataMobilitySelectionPolicyRecord* dnRecord = new ( ELeave ) 

        CCDDataMobilitySelectionPolicyRecord( generic->TableId() );

        dnRecord->SetElementId( GetRealElementId( dnIAPRecordSet->iRecords[i] ) );

        dnRecord->LoadL( *db );

        TUint snapId = dnRecord->iSNAP;

        MPMLOGSTRING2( "CMPMCommsDatAccess::FindAllSnapsL snap %d", snapId )

        // Insert unique ids to array

        //

        aSnapIds.InsertInOrder( snapId );

        delete dnRecord;

        }

    CleanupStack::PopAndDestroy( dnIAPRecordSet );

    CleanupStack::PopAndDestroy( generic );

    CleanupStack::PopAndDestroy( db );

    }

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

// CMPMCommsDatAccess::ValidateIapL

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

//

void CMPMCommsDatAccess::ValidateIapL( 

    const TConnectionId         aConnId,

    TUint32&                    aIapId, 

    TUint32&                    aNetId, 

    TBool&                      aLanOrWlan,

    CMPMServerSession&          aSession )

    {

    MPMLOGSTRING2(

        "CMPMCommsDatAccess::ValidateIapL: Validating chosen IAP Id = %i", 

        aIapId )

    aLanOrWlan = EFalse;

    SearchAccessNetIdL( aIapId, aNetId );

    CCommsDatabase* commsDatabase = CCommsDatabase::NewL();

    CleanupStack::PushL( commsDatabase );

    // Make hidden records visible

    // 

    commsDatabase->ShowHiddenRecords();

    CCommsDbTableView* commsDbIapTableView = 

        commsDatabase->OpenViewMatchingUintLC( TPtrC( IAP ),

                                               TPtrC( COMMDB_ID ),

                                               aIapId );

    User::LeaveIfError( commsDbIapTableView->GotoFirstRecord() );

    TInt length1( 0 );

    commsDbIapTableView->ReadColumnLengthL( TPtrC( IAP_SERVICE_TYPE ), 

                                            length1 );

    HBufC* buf1 = HBufC::NewLC( length1 );

    TPtr ptr1( buf1->Des() );

    // Read IAP's service type

    //

    commsDbIapTableView->ReadTextL(TPtrC( IAP_SERVICE_TYPE ), ptr1 );

    MPMLOGSTRING2(

        "CMPMCommsDatAccess::ValidateIapL: IAP service type = %S",

        &ptr1)

    // In case offline mode is enabled, we need to find out what type 

    // of bearer is used. Only LAN or WLAN is allowed in offline mode.

    // 

    if ( ptr1.Compare( TPtrC( LAN_SERVICE ) ) == KErrNone )

        {

        aLanOrWlan = ETrue;

        TUint32 service( 0 );

        commsDbIapTableView->ReadUintL( TPtrC( IAP_SERVICE ), service );

        // Now open a view to LAN_SERVICE table

        //

        CCommsDbTableView* commsDbLanTableView = 

            commsDatabase->OpenViewMatchingUintLC( TPtrC( LAN_SERVICE ),

                                                   TPtrC( COMMDB_ID ),

                                                   service );

        User::LeaveIfError( commsDbLanTableView->GotoFirstRecord() );

        TUint32 commDbId( 0 );

        commsDbLanTableView->ReadUintL( TPtrC( COMMDB_ID ), commDbId );

        // Now open a view to WLAN_SERVICE table

        //

        // If non wlan product, wlan tables won't exist and this will 

        // leave. In that case do not check WLAN related issues 

        //

        CCommsDbTableView* commsDbWlanTableView( NULL );

        TRAPD( err2, commsDbWlanTableView = 

                    commsDatabase->OpenViewMatchingUintLC( TPtrC( WLAN_SERVICE ),

                                                   TPtrC( WLAN_SERVICE_ID ),

                                                   commDbId );

                    CleanupStack::Pop( commsDbWlanTableView ) );

        if( err2 == KErrNone )

            {

            // Push back to cleanup stack. Object must be popped within 

            // TRAP, to avoid unbalance in cleanup stack and panic 71

            CleanupStack::PushL( commsDbWlanTableView );

            TInt err = commsDbWlanTableView->GotoFirstRecord();

            if ( err == KErrNone )

                {

                TWlanSsid ssid;

                commsDbWlanTableView->ReadTextL( TPtrC( NU_WLAN_SSID ), ssid );

                MPMLOGSSID( "CMPMCommsDatAccess<0x%x>::ValidateIapL: SSID = %S", 

                    aSession.ConnectionId(), &ssid )

                TUint32 presumedIapId = aIapId; 

                // Store Iap Id, Net Id and empty APN to TConnInfo, 

                // so that FindAPN can utilise the information 

                // during the validation of next IAP to support 

                // using existing WLAN connection SSID.

                //

                aSession.MyServer().Events()->AppendConnInfo( aConnId );

                aSession.MyServer().Events()->SetConnInfo( aConnId, 

                                                           aIapId, 

                                                           presumedIapId, 

                                                           aNetId, 

                                                           ssid );

                }

            else

                {

                MPMLOGSTRING2( "CMPMCommsDatAccess::ValidateIapL\

 GotoFirstRecord returned %d", err )

                }

            CleanupStack::PopAndDestroy( commsDbWlanTableView );

            }

        else

            {

            MPMLOGSTRING2(

                        "CMPMCommsDatAccess::ValidateIapL: WLAN table view failed, err %d", err2 )

            }                

        CleanupStack::PopAndDestroy( commsDbLanTableView );

        }

    // If this IAP needs PDP Context management, we'll do it here

    // 

    else if ( ptr1.Compare(TPtrC(OUTGOING_WCDMA)) == KErrNone )

        {

        TUint32 service;

        commsDbIapTableView->ReadUintL( TPtrC( IAP_SERVICE ), service );

        // Now open a view to OUTGOING_WCDMA table

        //

        CCommsDbTableView* commsDbPsdTableView = 

            commsDatabase->OpenViewMatchingUintLC( TPtrC( OUTGOING_WCDMA ),

                                                   TPtrC( COMMDB_ID ),

                                                   service );

        User::LeaveIfError( commsDbPsdTableView->GotoFirstRecord() );

        TInt length2( 0 );

        commsDbPsdTableView->ReadColumnLengthL( TPtrC( GPRS_APN ), length2 );

        HBufC* buf2 = HBufC::NewLC( length2 );

        TPtr ptr2( buf2->Des() );

        // Read APN

        //

        commsDbPsdTableView->ReadTextL( TPtrC( GPRS_APN ), ptr2 );

        MPMLOGSTRING2(

            "CMPMCommsDatAccess::ValidateIapL: APN = %S", &ptr2)

        TUint32 presumedIapId = aIapId; 

        // Find and change Iap and Net Id if APN exist

        //

        aSession.MyServer().Events()->FindAPN( ptr2, aIapId, aNetId ); 

        // Store Iap Id, Net Id and APN to TConnInfo, 

        // so that FindAPN can utilise the information 

        // during the validation of next IAP to support 

        // using existing PDP context per APN.

        //

        aSession.MyServer().Events()->AppendConnInfo( aConnId );

        aSession.MyServer().Events()->SetConnInfo( aConnId, 

                                                   aIapId, 

                                                   presumedIapId, 

                                                   aNetId, 

                                                   ptr2 );

        CleanupStack::PopAndDestroy( buf2 );

        CleanupStack::PopAndDestroy( commsDbPsdTableView );

        }

    else if ( ptr1.Compare(TPtrC( VPN_SERVICE )) == KErrNone )

        {

        MPMLOGSTRING(

            "CMPMCommsDatAccess::ValidateIapL: Enable VPN in offline mode" )

        aLanOrWlan = ETrue;

        }

    else

        {

        MPMLOGSTRING(

            "CMPMCommsDatAccess::ValidateIapL: Service Type out of range" )

        }

    CleanupStack::PopAndDestroy( buf1 );

    CleanupStack::PopAndDestroy( commsDbIapTableView );

    CleanupStack::PopAndDestroy( commsDatabase );

    MPMLOGSTRING2(

        "CMPMCommsDatAccess::ValidateIapL: Validated IAP Id = %i", aIapId )

    }

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

// CMPMCommsDatAccess::CheckBearerL

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

//

void CMPMCommsDatAccess::CheckBearerL( 

    TUint32&                    aIapId, 

    TBool&                      aLanOrWlan, 

    const RAvailableIAPList&    aAvailableIAPList,

    CMPMServerSession&          aSession )

    {

    MPMLOGSTRING2( "CMPMCommsDatAccess::CheckBearerL: IAP Id = %i", aIapId )

    aLanOrWlan = EFalse;

    // Use FindRealIapL to find the real IAP behind the virtual IAP.

    // 

    TUint32 realIapId( 0 );

    FindRealIapL( aIapId, 

                  realIapId, 

                  aAvailableIAPList,

                  aSession );

    if ( ( realIapId != 0 ) && ( aIapId != realIapId ) )

        {

        aIapId = realIapId;

        MPMLOGSTRING2(

            "CMPMCommsDatAccess::CheckBearerL: Found real IAP Id = %i", 

            aIapId )

        }

    CCommsDatabase* commsDatabase = CCommsDatabase::NewL();

    CleanupStack::PushL(commsDatabase);

    // Make hidden records visible

    // 

    commsDatabase->ShowHiddenRecords();

    CCommsDbTableView* commsDbIapTableView = 

        commsDatabase->OpenViewMatchingUintLC( TPtrC(IAP),

                                               TPtrC(COMMDB_ID),

                                               aIapId);

    User::LeaveIfError( commsDbIapTableView->GotoFirstRecord() );

    TInt length1( 0 );

    commsDbIapTableView->ReadColumnLengthL(TPtrC(IAP_SERVICE_TYPE), length1);

    HBufC* buf1 = HBufC::NewLC(length1);

    TPtr ptr1( buf1->Des() );

    // Read IAP's service type

    //

    commsDbIapTableView->ReadTextL(TPtrC(IAP_SERVICE_TYPE), ptr1);

    MPMLOGSTRING2(

        "CMPMCommsDatAccess::CheckBearerL: IAP_SERVICE_TYPE from CommsDat = %S",

        &ptr1 )

    // In case offline mode is enabled, we need to find out what type 

    // of bearer is used. Only LAN or WLAN is allowed in offline mode.

    // 

    if ( ptr1.Compare(TPtrC(LAN_SERVICE)) == KErrNone )

        {

        aLanOrWlan = ETrue;

        MPMLOGSTRING( "CMPMCommsDatAccess::CheckBearerL: Bearer type LAN/WLAN" )

        }

    else

        {

        aLanOrWlan = EFalse;

        MPMLOGSTRING( "CMPMCommsDatAccess::CheckBearerL: Bearer type GSM/UMTS" )

        }

    CleanupStack::PopAndDestroy(buf1);

    CleanupStack::PopAndDestroy(commsDbIapTableView);    

    CleanupStack::PopAndDestroy(commsDatabase);

    }

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

// CMPMCommsDatAccess::DumpIAPsL

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

//

void CMPMCommsDatAccess::DumpIAPsL() const

    {

#ifdef _DEBUG

    // Dump CommsDat IAPs to log in order to support testing

    // 

    TInt err( KErrNone );

    MPMLOGSTRING( "Display CommsDat IAPs - Start" )

    MPMLOGSTRING( "" )

    CCommsDatabase* commsDatabase = CCommsDatabase::NewL();

    CleanupStack::PushL(commsDatabase);

    // Make hidden records visible

    // 

    commsDatabase->ShowHiddenRecords();

    // Iterate the IAP table from CommsDat

    CCommsDbTableView* table = NULL;

    table = commsDatabase->OpenTableLC( TPtrC( IAP ) );

    err = table->GotoFirstRecord();

    while ( !err )

        {

        TUint32 iapId( 0 );

        TInt    length1( 0 );

        TInt    length2( 0 );

        // Read IAP's ID

        //

        table->ReadUintL( TPtrC( COMMDB_ID ), iapId );

        // Read IAP's connection name

        //

        table->ReadColumnLengthL( TPtrC( COMMDB_NAME ), length1 );

        HBufC* buf1 = HBufC::NewLC( length1 );

        TPtr ptr1( buf1->Des() );

        table->ReadTextL( TPtrC( COMMDB_NAME ), ptr1 );

        // Read IAP's service type

        //

        table->ReadColumnLengthL(TPtrC( IAP_SERVICE_TYPE ), length2 );

        HBufC* buf2 = HBufC::NewLC( length2 );

        TPtr ptr2( buf2->Des() );

        table->ReadTextL(TPtrC( IAP_SERVICE_TYPE ), ptr2 );

        // Dump information to log

        // 

        MPMLOGSTRING3( "IAP %i: Name = %S", iapId, &ptr1 )

        MPMLOGSTRING2( "Service type = %S", &ptr2 )

        MPMLOGSTRING( "" )

        err = table->GotoNextRecord();

        CleanupStack::PopAndDestroy( buf2 );

        CleanupStack::PopAndDestroy( buf1 );

        }

    MPMLOGSTRING( "Display CommsDat IAPs - End" )

    CleanupStack::PopAndDestroy( table );

    CleanupStack::PopAndDestroy( commsDatabase );

#endif // _DEBUG

    }

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

// CMPMCommsDatAccess::DumpSnapsL

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

//

void CMPMCommsDatAccess::DumpSnapsL()

    {

#ifdef _DEBUG

    // Dump CommsDat Snaps to log in order to support testing

    // 

    MPMLOGSTRING( "Display CommsDat Snaps - Start" )

    MPMLOGSTRING( "" )

    // Creating a session with the latest version

    // 

    CMDBSession* db = CMDBSession::NewLC( KCDVersion1_1 );

    db->SetAttributeMask( ECDHidden | ECDProtectedWrite );

    // Create the generic record set

    // 

    CMDBGenericRecord* generic = static_cast<CMDBGenericRecord*>

        ( CCDRecordBase::RecordFactoryL( 0 ) ); 

    CleanupStack::PushL( generic );  

    generic->InitializeL( TPtrC( KCDTypeNameDataMobilitySelectionPolicy ), 

                          NULL );

    generic->LoadL( *db );

    // Create the DN-IAP record set

    // 

    CMDBRecordSet<CCDDataMobilitySelectionPolicyRecord>* dnIAPRecordSet = 

        new ( ELeave ) CMDBRecordSet<CCDDataMobilitySelectionPolicyRecord>( 

        generic->TableId() );

    CleanupStack::PushL( dnIAPRecordSet ); 

    CCDDataMobilitySelectionPolicyRecord* dnIAPRecord = new ( ELeave ) 

        CCDDataMobilitySelectionPolicyRecord( generic->TableId() );

    CleanupStack::PushL( dnIAPRecord );

    // Find all the DN-IAP records

    // 

    dnIAPRecordSet->LoadL( *db );

    CCDIAPRecord*       linkedIAP;

    //CCDNetworkRecord*   linkedDN;