/*

* Copyright (c) 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:   VPN access point manipulation.

*

*/

#include <cmpluginvpndef.h>

#include <cmdestinationext.h>

#include "dmadstorevpnap.h"

#include "vpnlogger.h"

using namespace CMManager;

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

CVpnAp* CVpnAp::NewL(void)

    {

    TRACE("CVpnAp::NewL");

    CVpnAp* self = new (ELeave) CVpnAp;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CVpnAp::CVpnAp()

    {

    TRACE("CVpnAp::CVpnAp");

    }

void CVpnAp::ConstructL()

    {

    TRACE("CVpnAp::ConstructL");

    iCmManagerExt.OpenL();

    }

CVpnAp::~CVpnAp()

    {

    TRACE("CVpnAp::~CVpnAp");

    iCmManagerExt.Close();

    }

TBool CVpnAp::FindVpnApL(TVpnApCommsId aId)

    {

    TRACE("CVpnAp::FindVpnApL");

    TBool connectionFound = EFalse;

    RCmConnectionMethodExt vpnConnectionMethod;    

    TRAPD(err, vpnConnectionMethod = iCmManagerExt.ConnectionMethodL( aId ));

    CleanupClosePushL(vpnConnectionMethod); 

    switch(err)    

        {

        case KErrNone:

            if ( IsVpnConnectionMethodL(vpnConnectionMethod) )

                {

                connectionFound = ETrue;

                }

            break;

        case KErrNotFound:

            //do nothing

            break;

        default:

            User::Leave(err);

            break;

        }

    CleanupStack::PopAndDestroy(); //vpnConnectionMethod    

    return connectionFound;

    }

void CVpnAp::DeleteVpnApL(TVpnApCommsId aId)

    {

    TRACE("CVpnAp::DeleteVpnApL");

    RCmConnectionMethodExt vpnConnectionMethod = iCmManagerExt.ConnectionMethodL( aId );

    CleanupClosePushL(vpnConnectionMethod);

    //Check that the type of the connection is correct.

    if ( !IsVpnConnectionMethodL(vpnConnectionMethod) )

        {

        User::Leave(KErrNotFound);

        }

    if ( !vpnConnectionMethod.DeleteL() )

        {

        User::Leave(KErrGeneral);

        }    

    CleanupStack::PopAndDestroy(); //vpnConnectionMethod

    }

void CVpnAp::ListVpnApsL(RArray<TVpnApCommsId>& aIdArray)

    {

    TRACE("CVpnAp::ListVpnApsL");

    aIdArray.Reset();            

    //First collect all VPN connection methods from destinations

    RArray<TUint32> destinationArray;    

    iCmManagerExt.AllDestinationsL( destinationArray );

    CleanupClosePushL(destinationArray);    

    for (TInt i = 0; i < destinationArray.Count(); ++i)

        {

        RCmDestinationExt destination = iCmManagerExt.DestinationL( destinationArray[i] );

        CleanupClosePushL(destination);

        TInt connectionMethodCount = destination.ConnectionMethodCount();

        for (TInt j = 0; j < connectionMethodCount; ++j)

            {

            RCmConnectionMethodExt connectionMethod = destination.ConnectionMethodL( j );  

            CleanupClosePushL(connectionMethod);

            if ( IsVpnConnectionMethodL(connectionMethod) )

                {

                TUint32 apId = connectionMethod.GetIntAttributeL( ECmId );

                User::LeaveIfError(aIdArray.Append(apId));

                }

            CleanupStack::PopAndDestroy(); //connectionMethod       

            }

        CleanupStack::PopAndDestroy(); //destination

        }

    CleanupStack::PopAndDestroy(); //destinationArray    

    //Second collect VPN connection methods, which are not inside a destination.    

    RArray<TUint32> connectionMethodArray;    

    iCmManagerExt.ConnectionMethodL( connectionMethodArray );

    CleanupClosePushL(connectionMethodArray);

    for ( TInt i = 0; i < connectionMethodArray.Count(); ++i)

        {

        RCmConnectionMethodExt connectionMethod = 

                iCmManagerExt.ConnectionMethodL( connectionMethodArray[i] );

        CleanupClosePushL(connectionMethod);

        if ( IsVpnConnectionMethodL(connectionMethod) )

            {

            User::LeaveIfError(aIdArray.Append(connectionMethodArray[i]));

            }

        CleanupStack::PopAndDestroy(); //connectionMethod               

        }    

    CleanupStack::PopAndDestroy(); //connectionMethodArray

    }

void CVpnAp::GetVpnApL(TVpnApCommsId aId, TVpnApParms& aVpnApParms)

    {

    TRACE("CVpnAp::GetVpnApL");

    RCmConnectionMethodExt vpnConnectionMethod = iCmManagerExt.ConnectionMethodL( aId );

    CleanupClosePushL(vpnConnectionMethod);

    //Check that the type of the connection is correct.

    if ( !IsVpnConnectionMethodL(vpnConnectionMethod) )

        {

        User::Leave(KErrNotFound);

        }

    HBufC* string = vpnConnectionMethod.GetStringAttributeL( ECmName );

    aVpnApParms.iName = *string;

    delete string;

    string = NULL;

    string = vpnConnectionMethod.GetStringAttributeL( EVpnServicePolicy );  

    aVpnApParms.iPolicyId = *string;

    delete string;

    string = NULL;

    // real IAP or SNAP. ECmNextLayerIapId == EVpnIapId

    TUint32 realConn = vpnConnectionMethod.GetIntAttributeL(EVpnIapId); 

    if (realConn != 0)

        {

        DEBUG_LOG1(_L("Real connection is IAP %d"), realConn);         

        aVpnApParms.iRealConnRefType = TVpnApParms::EIapRealConnRef;

        aVpnApParms.iRealConnRef = realConn;        

        }

    else

        {

        realConn = vpnConnectionMethod.GetIntAttributeL(ECmNextLayerSNAPId);

        DEBUG_LOG1(_L("Real connection is snap %d"), realConn);         

        aVpnApParms.iRealConnRefType = TVpnApParms::ESnapRealConnRef;

        aVpnApParms.iRealConnRef = realConn;        

        }                        

    CleanupStack::PopAndDestroy(); //vpnConnectionMethod    

    }

TVpnApCommsId CVpnAp::AddVpnApL(const TVpnApParms& aVpnApParms)

    {

    TRACE("CVpnAp::AddVpnApL");

    RCmConnectionMethodExt vpnConnectionMethod = 

        iCmManagerExt.CreateConnectionMethodL( KPluginVPNBearerTypeUid );

    CleanupClosePushL( vpnConnectionMethod );

    UpdateVpnApL(vpnConnectionMethod, aVpnApParms);

    // save changes

    vpnConnectionMethod.UpdateL();

    TUint32 apId = vpnConnectionMethod.GetIntAttributeL( ECmId );

    CleanupStack::PopAndDestroy(); // vpnConnectionMethod

    return apId;

    }

void CVpnAp::UpdateVpnApL(TVpnApCommsId aId, const TVpnApParms& aVpnApParms)

    {

    TRACE("CVpnAp::UpdateVpnApL");

    RCmConnectionMethodExt vpnConnectionMethod = iCmManagerExt.ConnectionMethodL( aId );

    CleanupClosePushL(vpnConnectionMethod);

    //Check that the type of the connection is correct.

    if ( !IsVpnConnectionMethodL(vpnConnectionMethod) )

        {

        User::Leave(KErrNotFound);

        }

    UpdateVpnApL(vpnConnectionMethod, aVpnApParms);    

    vpnConnectionMethod.UpdateL();    

    CleanupStack::PopAndDestroy(); //vpnConnectionMethod    

    }

void CVpnAp::UpdateVpnApL(RCmConnectionMethodExt& aConnectionMethod, 

                          const TVpnApParms& aVpnApParms)

    {

    TRACE("CVpnAp::UpdateVpnApL");

    __ASSERT_DEBUG( aConnectionMethod.GetBoolAttributeL(ECmVirtual), User::Invariant() );

    aConnectionMethod.SetIntAttributeL( ECmNamingMethod, ENamingNothing );

    aConnectionMethod.SetStringAttributeL( ECmName, aVpnApParms.iName );

    aConnectionMethod.SetStringAttributeL( EVpnServicePolicy, aVpnApParms.iPolicyId );  

    switch(aVpnApParms.iRealConnRefType)

        {        

        case TVpnApParms::EIapRealConnRef:

            aConnectionMethod.SetIntAttributeL( EVpnIapId, aVpnApParms.iRealConnRef );            

            DEBUG_LOG1(_L("VPN iap uses real iap %d"), aVpnApParms.iRealConnRef);

            DEBUG_LOG1(_L("ECmNextLayerSNAPId is %d"), aConnectionMethod.GetIntAttributeL(ECmNextLayerSNAPId));            

            break;

        case TVpnApParms::ESnapRealConnRef:            

            aConnectionMethod.SetIntAttributeL( ECmNextLayerSNAPId, aVpnApParms.iRealConnRef );

            DEBUG_LOG1(_L("VPN iap uses real SNAP %d"), aVpnApParms.iRealConnRef);

            DEBUG_LOG1(_L("EVpnIapId is %d"), aConnectionMethod.GetIntAttributeL(EVpnIapId));            

            break;

        default:

            User::Invariant();

            break;                    

        }                

    }

TBool CVpnAp::IsVpnConnectionMethodL(RCmConnectionMethodExt& aConnectionMethod) const

    {

    TBool isVPNConnectionMethod = EFalse;

    if ( aConnectionMethod.GetBoolAttributeL(ECmVirtual) &&

         aConnectionMethod.GetIntAttributeL( ECmBearerType ) == KPluginVPNBearerTypeUid)

        {

        isVPNConnectionMethod = ETrue;        

        }

    return isVPNConnectionMethod;

    }