/*

 * ==============================================================================

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

 * 

 * ==============================================================================

 */

#include <featmgr.h>

#include <cmmanagerext.h> 

#include <cmpluginpacketdatadef.h>

#include <cmpluginwlandef.h>

#include <cmconnectionmethoddef.h>

#include <nsmldmtreedbclient.h>

#include "NapBranch.h"

#include "Utils.h"

#include "AddBuffer.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "NapBranchTraces.h"

#endif

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

// Constants

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

// NAP Branch

_LIT8( KCMDdfID, "ID" );

_LIT8( KCMDdfName, "Name" );

_LIT8( KCMDdfAddrType, "AddrType" );

_LIT8( KCMDdfAddr, "Addr" );

_LIT8( KCMDdfIP, "IP" );

_LIT8( KCMDdfAuthInfo, "AuthInfo" );

_LIT8( KCMDdfAuthType, "AuthType" );

_LIT8( KCMDdfBearerType, "BearerType" );

_LIT8( KCMDdfBearerParams, "BearerParams" );

_LIT8( KCMDdfIPv4, "IPv4" );

_LIT8( KCMDdfAutoConfig, "AutoConfig" );

_LIT8( KCMDdfIPAddr, "IPAddr" );

_LIT8( KCMDdfNetMask, "NetMask" );

_LIT8( KCMDdfGateway, "Gateway" );

_LIT8( KCMDdfAutoDNS, "AutoDNS" );

_LIT8( KCMDdfDNS, "DNS" );

_LIT8( KCMDdfServers, "Servers" );

_LIT8( KCMDdfServer, "Server" );

_LIT8( KCMDdfAuthName, "AuthName" );

_LIT8( KCMDdfAuthSecret, "AuthSecret" );

// NAP Child URI List

_LIT8( KCMNapFields, "ID/Name/AddrType/Addr/IP/AuthInfo/BearerType" );

_LIT8( KCMNIPFields, "IPv4" );

_LIT8( KCMNIPv4Fields, "AutoConfig/IPAddr/NetMask/Gateway/AutoDNS/DNS" );

_LIT8( KCMNDNSFields, "Servers" );

_LIT8( KCMNAuthInfoFields, "AuthType/AuthName/AuthSecret" );

_LIT8( KCMNDNSServersFields, "Addr");

_LIT8( KSlash, "/" );

_LIT8( KDynamicNapNode, "NAP/*" );

_LIT8( KDynamicNapNodeChildUri, "NAP/*/*" );

_LIT8( KDynamicIPNode, "NAP/*/IP" );

_LIT8( KDynamicIPNodeChildUri, "NAP/*/IP/*" );

_LIT8( KDynamicIPv4Node, "NAP/*/IP/IPv4" );

_LIT8( KDynamicIPv4NodeChildUri, "NAP/*/IP/IPv4/*" );

_LIT8( KDynamicIPv4DnsNode, "NAP/*/IP/IPv4/DNS" );

_LIT8( KDynamicIPv4DnsNodeChildUri, "NAP/*/IP/IPv4/DNS/*" );

_LIT8( KDynamicIPv4DnsServersNode, "NAP/*/IP/IPv4/DNS/Servers" );

_LIT8( KDynamicIPv4DnsServersNodeChildUri, "NAP/*/IP/IPv4/DNS/Servers/*" );

_LIT8( KDynamicIPv4DnsServersNodeChildUriNodes, "NAP/*/IP/IPv4/DNS/Servers/*/*");

_LIT8( KDynamicAuthInfoNode, "NAP/*/AuthInfo");

_LIT8( KDynamicAuthInfoNodeChildUri, "NAP/*/AuthInfo/*");

_LIT8( KNapBearerTypeUri, "NAP/*/BearerType");

_LIT8( KNapAddrUri, "NAP/*/Addr");

_LIT8( KNapDNSAddr1Uri, "NAP/*/Server1/Addr");

_LIT8( KNapDNSAddr2Uri, "NAP/*/Server2/Addr");

_LIT8( KNapIPv4AddrUri, "NAP/*/IPv4/*Addr");

_LIT8( KPacketDataBearerType, "3GPPPS");

_LIT8( KGPRSAddrType, "APN");

_LIT8( KGPRSAuthType, "PAP");

TInt const KInvalidBearerType = 0;

TInt const KBufferExpandSize = 128;

TInt const KNumOfNAPNodes = 8;

TInt const KMaxResultSize = 64;

TInt const KMaxDnsAddr = 2;

_LIT8( KFalse, "False");

_LIT8( KTrue, "True");

_LIT8( KDynamicNodePrefix, "NAPId" );

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

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

// TUint32 CNapBranch::CheckForUnmodifiableFieldL()

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

CSmlDmAdapter::TError CNapBranch::GetUnmodifiableFieldValueL(

        const TDesC8& aUri, CBufBase* aResult)

    {

    OstTraceExt1( TRACE_NORMAL, CNAPBRANCH_GETUNMODIFIABLEFIELDVALUEL_ENTRY,

            "ENTRY: CNapBranch::GetUnmodifiableFieldValueL;aUri=%s", aUri );

    CSmlDmAdapter::TError retval( CSmlDmAdapter::ENotFound );

    TPtrC8 nodeName = CUtils::GetLastURISeg( aUri );

    if ( nodeName.Match( KCMDdfAddrType ) != KErrNotFound )

        {

        aResult->InsertL( 0, KGPRSAddrType );

        retval = CSmlDmAdapter::EOk;

        }

    else if ( nodeName.Match( KCMDdfBearerType ) != KErrNotFound )

        {

        aResult->InsertL( 0, KPacketDataBearerType );

        retval = CSmlDmAdapter::EOk;

        }

    else if ( nodeName.Match( KCMDdfAuthType ) != KErrNotFound )

        {

        aResult->InsertL( 0, KGPRSAuthType );

        retval = CSmlDmAdapter::EOk;

        }

    else if ( nodeName.Match( KCMDdfID ) != KErrNotFound )

        {

        TPtrC8 dynamicNode = GetDynamicNAPNodeUri( aUri );

        aResult->InsertL( 0, dynamicNode );

        retval = CSmlDmAdapter::EOk;

        }

    OstTrace1( TRACE_NORMAL, CNAPBRANCH_GETUNMODIFIABLEFIELDVALUEL_EXIT,

            "EXIT: CNapBranch::GetUnmodifiableFieldValueL;retval=%{TError}", retval );

    return retval;

    }

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

// CSmlDmAdapter::TErrorCNapBranch::GetLeafData()

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

CSmlDmAdapter::TError CNapBranch::GetLeafDataL(const TDesC8& aURI,

        RCmConnectionMethodExt& aCm, CBufBase* aResult)

    {

    OstTraceExt1( TRACE_NORMAL, CNAPBRANCH_GETLEAFDATAL_ENTRY,

            "ENTRY: CNapBranch::GetLeafDataL;aURI=%s", aURI );

    TUint32 attributeRef( 0 );

    CSmlDmAdapter::TError status = CSmlDmAdapter::EOk;

    HBufC16* resultTmp;

    attributeRef = MapUriToCmAttribute( aURI );

    switch ( attributeRef )

        {

        case CMManager::ECmName:

        case CMManager::EPacketDataIPNameServer1:

        case CMManager::EPacketDataIPNameServer2:

        case CMManager::EPacketDataAPName:

        case CMManager::EPacketDataIFAuthName:

        case CMManager::EPacketDataIPAddr:

        case CMManager::EPacketDataIPNetmask:

        case CMManager::EPacketDataIPGateway:

        resultTmp = aCm.GetStringAttributeL( attributeRef );

        CleanupStack::PushL( resultTmp );

        aResult->InsertL( 0, CUtils::ConvertTo8LC( *resultTmp ) );

        CleanupStack::PopAndDestroy(); // ConvertTo8LC

        CleanupStack::PopAndDestroy( resultTmp );

        break;

        case CMManager::EPacketDataIPAddrFromServer:

        case CMManager::EPacketDataIPDNSAddrFromServer:

        if ( aCm.GetBoolAttributeL( attributeRef ) )

            {

            aResult->InsertL( 0, KTrue );

            }

        else

            {

            aResult->InsertL( 0, KFalse );

            }

        break;

        default:

        status = GetUnmodifiableFieldValueL( aURI, aResult );

        break;

        }

    OstTrace1( TRACE_NORMAL, CNAPBRANCH_GETLEAFDATAL_EXIT,

            "EXIT: CNapBranch::GetLeafDataL;status=%{TError}", status );

    return status;

    }

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

// CNapBranch::GetUnmodifiableFieldAddResult()

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

CSmlDmAdapter::TError CNapBranch::GetUnmodifiableFieldAddResult(

        const TDesC8& aUri, const TDesC8& aObject)

    {

    OstTraceExt1( TRACE_NORMAL, CNAPBRANCH_GETUNMODIFIABLEFIELDADDRESULT_ENTRY,

            "ENTRY: CNapBranch::GetUnmodifiableFieldAddResult;aUri=%s", aUri );

    CSmlDmAdapter::TError retval( CSmlDmAdapter::ENotFound );

    TPtrC8 nodeName = CUtils::GetLastURISeg( aUri );

    if ( nodeName.Match( KCMDdfAddrType ) != KErrNotFound )

        {

        if ( aObject.Match( KGPRSAddrType ) != KErrNotFound )

            {

            retval = CSmlDmAdapter::EOk;

            }

        else

            {

            retval = CSmlDmAdapter::EInvalidObject;

            }

        }

    else if ( nodeName.Match( KCMDdfAuthType ) != KErrNotFound )

        {

        if ( aObject.Match( KGPRSAuthType ) != KErrNotFound )

            {

            retval = CSmlDmAdapter::EOk;

            }

        else

            {

            retval = CSmlDmAdapter::EInvalidObject;

            }

        }

    OstTrace1( TRACE_NORMAL, DUP1_CNAPBRANCH_GETUNMODIFIABLEFIELDADDRESULT_EXIT,

            "EXIT: CNapBranch::GetUnmodifiableFieldAddResult;retval=%{TError}", retval );

    return retval;

    }

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

// CNapBranch::MapUriToCmAttribute(()

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

TUint32 CNapBranch::MapUriToCmAttribute(const TDesC8& aUri)

    {

    OstTraceExt1( TRACE_NORMAL, CNAPBRANCH_MAPURITOCMATTRIBUTE_ENTRY,

            "ENTRY: CNapBranch::MapUriToCmAttribute;aUri=%s", aUri );

    TUint32 retval( 0 );

    TPtrC8 nodeName = CUtils::GetLastURISeg( aUri );

    OstTraceExt1( TRACE_NORMAL, CNAPBRANCH_MAPURITOCMATTRIBUTE_GET_NODE,

            "CNapBranch::MapUriToCmAttribute;nodeName=%s", nodeName );

    if ( nodeName.Match( KCMDdfName ) != KErrNotFound )

        {

        retval = CMManager::ECmName;

        }

    else if ( nodeName.Match( KCMDdfAddr ) != KErrNotFound )

        {

        // IP branch and NAP branch have both "Addr" leaf. Select between them.

        if ( aUri.Match( KNapAddrUri ) != KErrNotFound &&

                aUri.Match( KNapIPv4AddrUri ) == KErrNotFound )

            {

            retval = CMManager::EPacketDataAPName;

            }

        else if ( aUri.Match( KNapDNSAddr1Uri ) != KErrNotFound )

            {

            retval = CMManager::EPacketDataIPNameServer1;

            }

        else if ( aUri.Match( KNapDNSAddr2Uri ) != KErrNotFound )

            {

            retval = CMManager::EPacketDataIPNameServer2;

            }

        }

    else if ( nodeName.Match( KCMDdfBearerType ) != KErrNotFound )

        {

        retval = CMManager::ECmBearerType;

        }

    else if ( nodeName.Match( KCMDdfAuthName ) != KErrNotFound )

        {

        retval = CMManager::EPacketDataIFAuthName;

        }

    else if ( nodeName.Match( KCMDdfAuthSecret ) != KErrNotFound )

        {

        retval = CMManager::EPacketDataIFAuthPass;

        }

    else if ( nodeName.Match( KCMDdfAutoConfig ) != KErrNotFound )

        {

        retval = CMManager::EPacketDataIPAddrFromServer;

        }

    else if ( nodeName.Match( KCMDdfIPAddr ) != KErrNotFound )

        {

        retval = CMManager::EPacketDataIPAddr;

        }

    else if ( nodeName.Match( KCMDdfNetMask ) != KErrNotFound )

        {

        retval = CMManager::EPacketDataIPNetmask;

        }

    else if ( nodeName.Match( KCMDdfGateway ) != KErrNotFound )

        {

        retval = CMManager::EPacketDataIPGateway;

        }

    else if ( nodeName.Match( KCMDdfAutoDNS )!= KErrNotFound )

        {

        retval = CMManager::EPacketDataIPDNSAddrFromServer;

        }

    OstTrace1( TRACE_NORMAL, CNAPBRANCH_MAPURITOCMATTRIBUTE_EXIT,

            "EXIT: CNapBranch::MapUriToCmAttribute;retval=%{TError}", retval );

    return retval;

    }

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

// void CNapBranch::SetLeafData()

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

void CNapBranch::SetLeafDataL(const TDesC8& aURI, const TDesC8& aObject,

        TInt aStatusRef, RCmConnectionMethodExt& aCm)

    {

    OstTraceExt1( TRACE_FLOW, CNAPBRANCH_SETLEAFDATAL_ENTRY,

            "ENTRY: CNapBranch::SetLeafDataL;aURI=%s", aURI );

    TUint32 attributeRef( 0 );

    TBool tmpBool = EFalse;

    CSmlDmAdapter::TError status = CSmlDmAdapter::EOk;

    attributeRef = MapUriToCmAttribute( aURI );

    OstTrace1( TRACE_NORMAL, CNAPBRANCH_SETLEAFDATAL_GET_CMATTRIB,

            "CNapBranch::SetLeafDataL;CM Attribute:;attributeRef=%{TConnectionMethodCommonAttributes}",

            attributeRef );

    switch ( attributeRef )

        {

        case CMManager::ECmName:

        case CMManager::EPacketDataIPNameServer1:

        case CMManager::EPacketDataIPNameServer2:

        case CMManager::EPacketDataAPName:

        case CMManager::EPacketDataIFAuthName:

        case CMManager::EPacketDataIFAuthPass:

        case CMManager::EPacketDataIPAddr:

        case CMManager::EPacketDataIPNetmask:

        case CMManager::EPacketDataIPGateway:

        aCm.SetStringAttributeL( attributeRef, CUtils::ConvertTo16LC( aObject ) );

        CleanupStack::PopAndDestroy(); // ConvertTo16LC

        break;

        case CMManager::EPacketDataIPAddrFromServer:

        case CMManager::EPacketDataIPDNSAddrFromServer:

        if ( CUtils::DesToBool( aObject, tmpBool ) == KErrNone )

            {

            aCm.SetBoolAttributeL( attributeRef, tmpBool );

            }

        else

            {

            status = CSmlDmAdapter::EInvalidObject;

            }

        break;

        case CMManager::ECmBearerType:

        // BearerType is already set when CM was created.

        break;

        default:

        // Attribute field was not from CM. Check if value is hard coded to CM.

        status = GetUnmodifiableFieldAddResult( aURI, aObject );

        break;

        }

    iCallback->SetStatusL( aStatusRef, status );

    OstTrace1( TRACE_NORMAL, CNAPBRANCH_SETLEAFDATAL_EXIT,

            "EXIT: CNapBranch::SetLeafDataL;status=%{TError}", status );

    }

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

// TBool CNapBranch::SetNodeData()

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

void CNapBranch::SetNodeDataL(CConnMoNodeElement* aNode,

        RCmConnectionMethodExt& aCm)

    {

    OstTraceExt1( TRACE_NORMAL, CNAPBRANCH_SETNODEDATAL_ENTRY,

            "ENTRY: CNapBranch::SetNodeDataL;aNode->iUri=%s", aNode->iUri );

    if ( aNode->iParentLUID.Length() == 0 )

        {

        TBuf8<16> addLUID;

        _LIT8( KFormat, "%d" );    

        addLUID.Format( KFormat, aCm.GetIntAttributeL( CMManager::ECmId ) );

        iCallback->SetMappingL( aNode->iUri, addLUID );

        iCallback->SetStatusL( aNode->iStatusRef, CSmlDmAdapter::EOk );

        OstTrace0( TRACE_NORMAL, CNAPBRANCH_SETNODEDATAL_OK,

                "CNapBranch::SetNodeDataL; CSmlDmAdapter::EOk" );

        }

    else

        {

        iCallback->SetStatusL( aNode->iStatusRef, CSmlDmAdapter::EAlreadyExists );

        OstTrace0( TRACE_NORMAL, CNAPBRANCH_SETNODEDATAL_EXISTS,

                "CNapBranch::SetNodeDataL; CSmlDmAdapter::EAlreadyExists" );

        }

    OstTrace0( TRACE_NORMAL, CNAPBRANCH_SETNODEDATAL_EXIT,

            "EXIT: CNapBranch::SetNodeDataL" );

    }

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

// TBool CNapBranch::FindNewCmType

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

TBool CNapBranch::FindNewCmType(TUint32& aBearerType)

    {

    OstTrace0( TRACE_NORMAL, CNAPBRANCH_FINDNEWCMTYPE_ENTRY, "ENTRY: CNapBranch::FindNewCmType" );

    TBool retval = EFalse;

    // Find bearer type for creating a connection methdod

    CConnMoNodeElement* processNode = iBuffer->CacheFind( KNapBearerTypeUri );

    if ( processNode )

        {

        if ( processNode->iObject.Match( KPacketDataBearerType ) != KErrNotFound )

            {

            OstTraceExt1( TRACE_NORMAL, CNAPBRANCH_FINDNEWCMTYPE_3GPP,

                    "CNapBranch::FindNewCmType;Bearer Type: %s", KPacketDataBearerType );

            aBearerType = KUidPacketDataBearerType;

            retval = ETrue;

            }

        else

            {

            aBearerType = KInvalidBearerType;

            }

        }

    OstTrace1( TRACE_NORMAL, CNAPBRANCH_FINDNEWCMTYPE_EXIT,

            "EXIT: CNapBranch::FindNewCmType;retval=%d", retval );

    return retval;

    }

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

// TBool CNapBranch::AllMandatoryNapFieldsFound()

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

TBool CNapBranch::AllMandatoryNapFieldsFound()

    {

    OstTrace0( TRACE_NORMAL, CNAPBRANCH_ALLMANDATORYNAPFIELDSFOUND_ENTRY,

            "ENTRY: CNapBranch::AllMandatoryNapFieldsFound" );

    TBool retval = ETrue;

    // Check that NAP Address addition is found

    if ( !iBuffer->CacheFind( KNapAddrUri ) )

        {

        retval = EFalse;

        }

    // Check that dynamic nap node addition is found

    if ( !iBuffer->CacheFindDynamicNode( KDynamicNapNode ) )

        {

        retval = EFalse;

        }

    OstTrace1( TRACE_NORMAL, CNAPBRANCH_ALLMANDATORYNAPFIELDSFOUND_EXIT,

            "EXIT: CNapBranch::AllMandatoryNapFieldsFound;retval=%d", retval );

    return retval;

    }

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

// TBool CNapBranch::NapChildURIListL

// TBool CNapBranch::NapChildURIList( )

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

void CNapBranch::NapChildURIListL(const TDesC8& aURI, const CArrayFix<

        TSmlDmMappingInfo>& aPreviousURISegmentList, TInt aResultsRef,

        TInt aStatusRef, CBufBase& aCurrentURISegmentList)

    {

    OstTraceExt1( TRACE_NORMAL, CNAPBRANCH_NAPCHILDURILISTL_ENTRY,

            "ENTRY: CNapBranch::NapChildURIListL;aURI=%s", aURI );

    RArray<TUint32> CmArray;

    CleanupClosePushL( CmArray );

    TPtrC8 napTree = CUtils::GetEndOfURIFromSeg( aURI, KCMDdfNAP );

    GetAllConnectionMethodsL( CmArray, *iCmManager );

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

        {

        TBuf8<KBufferExpandSize> addURISeg;

        if ( !CheckPreviousURIList( aPreviousURISegmentList, CmArray[i], addURISeg ) )

            {

            // Connection Method not found in previous URI list                        

            addURISeg.Append( aURI );

            addURISeg.Append( KSlash );

            addURISeg.Append( KDynamicNodePrefix );

            addURISeg.AppendNumFixedWidth( CmArray[i], EDecimal, 3);

            TBuf8<16> addLUID;

            _LIT8( KFormat, "%d" );    

            addLUID.Format( KFormat, CmArray[i] );

            OstTraceExt1( TRACE_NORMAL,

                    CNAPBRANCH_NAPCHILDURILISTL_ADDED_TO_LIST,

                    "CNapBranch::NapChildURIListL;Added to list: URI=%s", addURISeg );

            iCallback->SetMappingL( addURISeg, addLUID );

            }

        // Child is the last segment in uri

        aCurrentURISegmentList.InsertL( aCurrentURISegmentList.Size(),

                CUtils::GetLastURISeg(addURISeg) );

        aCurrentURISegmentList.InsertL( aCurrentURISegmentList.Size(), KSlash );

        }

    iCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EOk );

    iCallback->SetResultsL( aResultsRef, aCurrentURISegmentList, KNullDesC8 );

    CleanupStack::PopAndDestroy( &CmArray );

    OstTrace0( TRACE_NORMAL, CNAPBRANCH_NAPCHILDURILISTL_EXIT,

            "EXIT: CNapBranch::NapChildURIListL" );

    }

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

// CSmlDmAdapter::TError CNapBranch::DeleteObjectL

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

CSmlDmAdapter::TError CNapBranch::DeleteObjectL(const TDesC8& aURI,

        const TDesC8& aLUID)

    {

    OstTrace0( TRACE_NORMAL, CNAPBRANCH_DELETEOBJECTL_PRIVATE_ENTRY,

            "ENTRY: CNapBranch::DeleteObjectL" );

    CSmlDmAdapter::TError status = CSmlDmAdapter::ENotFound;

    // If this is for pre-defined node then get CM id xxx from URI (NAP/NAPIdxxx)

    TInt cmId = GetCmIdFromURIL( aURI );

    RCmConnectionMethodExt cm;

    if( aLUID.Length() > 0 )

        {       

        cmId = CUtils::IntLUID( aLUID );

        }

    // Check, if referred connection method exists           

    if ( GetConnectionMethodLC( *iCmManager, cm, cmId ) )

        {

        cm.DeleteL();

        status = CSmlDmAdapter::EOk;

        OstTrace1( TRACE_NORMAL, CNAPBRANCH_DELETEOBJECTL_PRIVATE_DELETE,

                "CNapBranch::DeleteObjectL; Connection Method=%u deleted.", cmId );

        }