/*

* Copyright (c) 2002 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:  Declaration of the CVpnApEngine class.

*

*/

// INCLUDE FILES

#include    "VpnApEngine.h"

#include    "VpnApItem.h"

#include    "ApEngineLogger.h"

#include    "ApEngineConsts.h"

#include    "ApEngineCommons.h"

#include    <ApDataHandler.h>

#include    <ApAccessPointItem.h>

#include    <ApUtils.h>

#include    <txtetext.h>

#include    <vpnapi.h>

#include    <vpnapidefs.h>

// CONSTANTS

_LIT( KVpnVirtualBearerName, "vpnbearer" );

_LIT( KVpnVirtualBearerAgent, "vpnconnagt.agt" );

_LIT( KVpnVirtualBearerNif, "tunnelnif" );

_LIT( KDefProxyProtocolName, "http" );                      // required !

_LIT( KDefWapGatewayIpAddress, "0.0.0.0" );

// constatnts needed for the virtualbearer table

const TInt KNoTimeout = -1;

const TUint32 KLastSessionTimeout = 3;

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

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

// CVpnApEngine::NewLC

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

//

EXPORT_C CVpnApEngine* CVpnApEngine::NewLC( CCommsDatabase* aDb )

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::NewL" ) ) );

    CVpnApEngine* self = new ( ELeave ) CVpnApEngine;

    CleanupStack::PushL( self );

    self->ConstructL( aDb );

    CLOG( ( EApItem, 1, _L( "<- CVpnApEngine::NewL" ) ) );

    return self;

    }

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

// CVpnApEngine::~CVpnApEngine

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

//

EXPORT_C CVpnApEngine::~CVpnApEngine()

    {

    if ( iOwnDb )

        {

        delete iDb;

        }

    CLOG( ( EApItem, 0, _L( "<-> CVpnApEngine::~CVpnApEngine" ) ) );

    }

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

// CVpnApEngine::ConstructL

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

//

EXPORT_C void CVpnApEngine::ConstructL( CCommsDatabase* aDb )

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::ConstructL" ) ) );

    if ( aDb )

        {

        iDb = aDb;

        iOwnDb = EFalse;

        }

    else

        {

        iDb = CCommsDatabase::NewL();

        iOwnDb = ETrue;

        }

    CLOG( ( EApItem, 0, _L( "<- CVpnApEngine::ConstructL" ) ) );

    }

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

// CVpnApEngine::CVpnApEngine

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

//

EXPORT_C CVpnApEngine::CVpnApEngine()

:iOwnDb( EFalse )

    {

    CLOG( ( EApItem, 0, _L( "<-> CVpnApEngine::CVpnApEngine" ) ) );

    }

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

// CVpnApEngine::CreateVpnApL

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

//

EXPORT_C TUint32 CVpnApEngine::CreateVpnApL( CVpnApItem& aVpnApItem )

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::CreateVpnApL" ) ) );

    TUint32 retval( 0 );

    // Start  a transaction

    TBool ownTransaction = ApCommons::StartPushedTransactionLC( *iDb );

    retval = DoCreateVpnApL( ETrue, aVpnApItem );

    if ( ownTransaction )

        {

        ApCommons::CommitTransaction( *iDb );

        CleanupStack::Pop(); // RollbackTransactionOnLeave

        }

    CLOG( ( EApItem, 1, _L( "<- CVpnApEngine::CreateVpnApL" ) ) );

    return retval;

    }

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

// CVpnApEngine::CreateVpnL

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

//

EXPORT_C TUint32 CVpnApEngine::CreateVpnApL(  TDesC& aName, 

                                              TUint32 aIapId, 

                                              TDesC& aPolicy, 

                                              TDesC* aProxyServerAddress, 

                                              TUint32 aProxyPort )

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::CreateVpnApL..." ) ) );

    TUint32 retval( 0 );

    CVpnApItem* item = CVpnApItem::NewLC();

    item->WriteTextL( EApVpnWapAccessPointName, aName );

    item->WriteUint( EApVpnRealIapID, aIapId );

    item->WriteTextL( EApVpnPolicyId, aPolicy );

    item->WriteLongTextL( EApVpnProxyServerAddress, *aProxyServerAddress );

    item->WriteUint( EApVpnProxyPortNumber, aProxyPort );

    RVpnServ ps;

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

    CleanupClosePushL<RVpnServ>( ps );

    TVpnPolicyDetails det;

    TVpnPolicyName pName( aPolicy );

    TInt err = ps.GetPolicyDetails( pName, det );

    // When the policy is deleted (err!=0):

    // have this leave, in UI display a note about needing to be reconfigured

    // & set it & policyID to none to look like there is NO policy

    // which will force the reconfiguration if in the UI

    User::LeaveIfError( err );

    item->WriteTextL( EApVpnPolicy, det.iName );

    CreateVpnApL( *item );

    CleanupStack::PopAndDestroy(); // ps

    CleanupStack::PopAndDestroy( item );

    CLOG( ( EApItem, 1, _L( "<- CVpnApEngine::CreateVpnApL..." ) ) );

    return retval;

    }

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

// CVpnApEngine::DeleteVpnL

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

//

EXPORT_C void CVpnApEngine::DeleteVpnL( TUint32 aVpnApId )

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::DeleteVpnL" ) ) );

    TBool ownTransaction = ApCommons::StartPushedTransactionLC( *iDb );

    DoDeleteVpnL( aVpnApId );

    if ( ownTransaction )

        {

        ApCommons::CommitTransaction( *iDb );

        CleanupStack::Pop(); // RollbackTransactionOnLeave

        }

    CLOG( ( EApItem, 1, _L( "<- CVpnApEngine::DeleteVpnL" ) ) );

    }

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

// CVpnApEngine::VpnDataL

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

//

EXPORT_C void CVpnApEngine::VpnDataL( TUint32 aUid, 

                                      CVpnApItem& aVpnApItem )

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::VpnDataL" ) ) );

    ReadVpnWapBearerDataL( aUid, aVpnApItem );

    ReadVpnWapApDataL( aVpnApItem );

    ReadVpnIapRecordL( aVpnApItem );

    ReadNetworkDataL( aVpnApItem );

    ReadVpnDataL( aVpnApItem );

    ReadProxyDataL( aVpnApItem );

    CLOG( ( EApItem, 1, _L( "<- CVpnApEngine::VpnDataL" ) ) );

    }

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

// CVpnApEngine::UpdateVpnDataL

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

//

EXPORT_C void CVpnApEngine::UpdateVpnDataL( CVpnApItem& aVpnApItem )

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::UpdateVpnDataL" ) ) );

    // Start  a transaction

    TBool ownTransaction = ApCommons::StartPushedTransactionLC( *iDb );

    // ignore return value as it is used only when creating new

    DoCreateVpnApL( EFalse, aVpnApItem );

    if ( ownTransaction )

        {

        ApCommons::CommitTransaction( *iDb );

        CleanupStack::Pop(); // RollbackTransactionOnLeave

        }

    CLOG( ( EApItem, 1, _L( "<- CVpnApEngine::UpdateVpnDataL" ) ) );

    }

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

// CVpnApEngine::IsVpnApL()

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

//

EXPORT_C TBool CVpnApEngine::IsVpnApL( const TUint32 aUid )

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::IsVpnApL" ) ) );

    TBool retval( EFalse );

    // Start  a transaction

    TBool ownTransaction = ApCommons::StartPushedTransactionLC( *iDb );

    CCommsDbTableView* wapt;

    wapt = iDb->OpenViewMatchingUintLC( TPtrC(WAP_IP_BEARER),

                                       TPtrC(WAP_ACCESS_POINT_ID), aUid );

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

    TUint32 iapid( 0 );

    ApCommons::ReadUintL( wapt, TPtrC(WAP_IAP), iapid );

    CCommsDbTableView* iapt;

    iapt = iDb->OpenViewMatchingUintLC( TPtrC(IAP),

                                       TPtrC(COMMDB_ID), iapid );

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

    HBufC* iapServiceType = ApCommons::ReadText16ValueLC

                                    (

                                    iapt,

                                    TPtrC(IAP_SERVICE_TYPE)

                                    );

    retval = ( iapServiceType->Compare( TPtrC(VPN_SERVICE) ) == 0 );

    CleanupStack::PopAndDestroy( iapServiceType ); // iapServiceType 

    CleanupStack::PopAndDestroy( iapt ); // iapt

    CleanupStack::PopAndDestroy( wapt ); // wapt

    if ( ownTransaction )

        {

        ApCommons::CommitTransaction( *iDb );

        CleanupStack::Pop(); // RollbackTransactionOnLeave

        }

    CLOG( ( EApItem, 1, _L( "<- CVpnApEngine::IsVpnApL" ) ) );

    return retval;

    }

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

// CVpnApEngine::Cvt()

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

//

EXPORT_C TInt CVpnApEngine::Cvt()

    {

    return KErrNone;

    }

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

// CVpnApEngine::DoCreateVpnApL

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

//

TUint32 CVpnApEngine::DoCreateVpnApL( TBool aIsNew, CVpnApItem& aVpnApItem )

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::DoCreateVpnApL" ) ) );

    // internal function, caller MUST initiate a transaction, WE WILL NOT.

    // create 1 single virtual bearer if not already present

    // Create a new VPN access point (WAP, etc. with VPN IAP

    // Create a new VPN record in VPN table

    CApUtils* util = CApUtils::NewLC( *iDb );        

    TBool valid = 

            util->IsValidNameL( *aVpnApItem.iName, aVpnApItem.iVpnWapId );

    CleanupStack::PopAndDestroy( util );

    if ( !valid )

        {

        User::Leave( KErrAlreadyExists );

        }

    WriteVpnDataL( aIsNew, aVpnApItem );

    TUint32 virtbearerid = CreateVirtBearerIfNeededL();

    aVpnApItem.iVirtualBearerID = virtbearerid;

    WriteNetworkDataL( aIsNew, aVpnApItem );

    WriteVpnIapRecordL( aIsNew, aVpnApItem );

    WriteVpnWapApDataL( aIsNew, aVpnApItem );

    WriteVpnWapBearerDataL( aIsNew, aVpnApItem );

    if ( aVpnApItem.HasProxy() )

        {

        WriteProxyDataL( aIsNew, aVpnApItem );

        }

    else

        {

        if ( !aIsNew )

            {

            CCommsDbTableView* iapt;

            iapt = iDb->OpenViewMatchingUintLC( TPtrC(IAP), TPtrC(COMMDB_ID),

                                                aVpnApItem.iVpnIapId );

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

            HBufC* servicetype = HBufC::NewLC( KCommsDbSvrMaxFieldLength );

            TPtr servptr( servicetype->Des() );

            iapt->ReadTextL( TPtrC(IAP_SERVICE_TYPE), servptr );

            TRAP_IGNORE( RemoveVpnProxyDataL( aVpnApItem.iVpnTableId ) );

            CleanupStack::PopAndDestroy( servicetype );

            CleanupStack::PopAndDestroy( iapt );

            }

        }

    CLOG( ( EApItem, 0, _L( "<- CVpnApEngine::DoCreateVpnApL" ) ) );

    return aVpnApItem.iVpnWapId;

    }

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

// CVpnApEngine::WriteVpnDataL

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

//

void CVpnApEngine::WriteVpnDataL( TBool aIsNew, CVpnApItem& aVpnApItem )

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::WriteVpnDataL" ) ) );

    // internal function, caller MUST initiate a transaction, WE WILL NOT.

    CCommsDbTableView* t;

    if ( aIsNew )

        {

        t = iDb->OpenTableLC( TPtrC(VPN_SERVICE) );

        TInt err = t->InsertRecord( aVpnApItem.iVpnTableId );

        if ( err )

            {

            User::LeaveIfError( err );

            }

        }

    else

        {

        t = iDb->OpenViewMatchingUintLC( TPtrC(VPN_SERVICE),

                                         TPtrC(COMMDB_ID), 

                                         aVpnApItem.iVpnTableId );

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

        User::LeaveIfError( t->UpdateRecord() );

        }

    t->WriteTextL( TPtrC(COMMDB_NAME), *aVpnApItem.iName );

    t->WriteTextL( TPtrC(VPN_SERVICE_POLICY), *aVpnApItem.iPolicyId );

    t->WriteUintL( TPtrC(VPN_SERVICE_IAP), aVpnApItem.iRealIapId );

    t->WriteUintL( TPtrC(VPN_SERVICE_NETWORKID), aVpnApItem.iHomeNetwork );

    User::LeaveIfError( t->PutRecordChanges( EFalse, EFalse ) );

    CleanupStack::PopAndDestroy( t );   // t

    CLOG( ( EApItem, 0, _L( "<- CVpnApEngine::WriteVpnDataL" ) ) );

    }

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

// CVpnApEngine::CreateVirtBearerIfNeededL

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

//

TUint32 CVpnApEngine::CreateVirtBearerIfNeededL()

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::CreateVirtBearerIfNeededL" ) ) );

    TUint32 retval( 0 );

    CCommsDbTableView* t = NULL;

    t = iDb->OpenViewMatchingTextLC( TPtrC(VIRTUAL_BEARER), 

                                     TPtrC(VIRTUAL_BEARER_AGENT), 

                                     KVpnVirtualBearerAgent );

    if ( t->GotoFirstRecord() == KErrNotFound )

        { // no such yet, create one

        TInt err = t->InsertRecord( retval );

        if ( err )

            {

            User::LeaveIfError( err );

            }        

        t->WriteTextL( TPtrC(COMMDB_NAME), KVpnVirtualBearerName );

        t->WriteTextL( TPtrC(VIRTUAL_BEARER_AGENT), KVpnVirtualBearerAgent );

        t->WriteTextL( TPtrC(VIRTUAL_BEARER_NIF), KVpnVirtualBearerNif );

        t->WriteUintL( TPtrC(LAST_SOCKET_ACTIVITY_TIMEOUT), 

                       (TUint32)KNoTimeout ); 

        t->WriteUintL( TPtrC(LAST_SESSION_CLOSED_TIMEOUT), 

                       KLastSessionTimeout ); 

        t->WriteUintL( TPtrC(LAST_SOCKET_CLOSED_TIMEOUT), 

                       (TUint32)KNoTimeout ); 

        User::LeaveIfError( t->PutRecordChanges( EFalse, EFalse ) );

        }

    else

        { // there is one, use it

        t->ReadUintL( TPtrC(COMMDB_ID), retval );

        }

    CleanupStack::PopAndDestroy( t );   // t

    CLOG( ( EApItem, 0, _L( "<- CVpnApEngine::CreateVirtBearerIfNeededL" ) ) );

    return retval;

    }

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

// CVpnApEngine::WriteVpnIapRecordL

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

//

TUint32 CVpnApEngine::WriteVpnIapRecordL( TBool aIsNew, 

                                          CVpnApItem& aVpnApItem )

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApEngine::WriteVpnIapRecordL" ) ) );

    // internal function, caller MUST initiate a transaction, WE WILL NOT.

    CCommsDbTableView* t;

    if ( aIsNew )

        {

        t = iDb->OpenTableLC( TPtrC(IAP) );

        TInt err = t->InsertRecord( aVpnApItem.iVpnIapId );

        if ( err )

            {

            User::LeaveIfError( err );

            }

        }

    else

        {

        t = iDb->OpenViewMatchingUintLC( TPtrC(IAP),

                                         TPtrC(COMMDB_ID),