/*

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

 * 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 <e32base.h>

#include <cmconnectionmethoddef.h>

#include <nsmldmtreedbclient.h>

#include "ProxyBranch.h"

#include "Utils.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "ProxyBranchTraces.h"

#endif

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

// Constants

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

_LIT8( KCMProxyDdf,             "Proxy" );

_LIT8( KCMProxyDdfProxyId,      "ProxyId" );

_LIT8( KCMProxyDdfName,         "Name" );

_LIT8( KCMProxyDdfAddr,         "Addr" );

_LIT8( KCMProxyDdfToConRef,     "ToConRef" );

_LIT8( KCMProxyDdfConRef,       "ConRef" );

_LIT8( KCMProxyDdfPorts,        "Ports" );

_LIT8( KCMProxyDdfPortNbr,      "PortNbr" );

_LIT8( KCMProxyDdfProxyParams,  "ProxyParams" );

_LIT8( KCMProxyDdfProxyType,    "ProxyType" );

_LIT8( KCMProxyDdfWap,          "WAP" );

_LIT8( KCMProxyDdfStartpg,      "Startpg" );

_LIT8( KCMProxyFields,          "ProxyId/Addr/ToConRef/Ports/ProxyType/ProxyParams" );

_LIT8( KCMProxyParamsFields,    "WAP" );

_LIT8( KCMProxyWapFields,       "Startpg" );

_LIT8( KCMProxyNodeSeparator,   "/" );

_LIT8( KDynamicProxyNodePattern,            "Proxy/*" );

_LIT8( KDynamicProxyNodeChildUri,           "Proxy/*/*" );

_LIT8( KDynamicToConrefNode,                "Proxy/*/ToConRef" ); 

_LIT8( KDynamicToConrefNodeChildUri,        "Proxy/*/ToConRef/*" ); 

_LIT8( KDynamicToConrefNodeChildUriNodes,   "Proxy/*/ToConRef/*/*" );

_LIT8( KDynamicPortsNode,                   "Proxy/*/Ports" );

_LIT8( KDynamicPortsNodeChildUri,           "Proxy/*/Ports/*" );

_LIT8( KDynamicPortsNodeChildUriNodes,      "Proxy/*/Ports/*/*" );

_LIT8( KDynamicProxyParamsNode,             "Proxy/*/ProxyParams" );

_LIT8( KDynamicProxyParamsNodeChildUri,     "Proxy/*/ProxyParams/*" );

_LIT8( KDynamicProxyParamsWapNode,          "Proxy/*/ProxyParams/WAP" );

_LIT8( KProxyAddrUri,                     "Proxy/*/Addr");

_LIT8( KProxyConrefUri,                   "Proxy/*/ConRef");

_LIT8( KRoot,                             "./");

TInt const KBufferExpandSize = 128;

TInt const KNumOfProxyNodes = 8;

_LIT8( KDynamicNodePrefix,                  "ProxyId");

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

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

// CSmlDmAdapter::TError CProxyBranch::FetchLeafObjectL()

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

CSmlDmAdapter::TError CProxyBranch::FetchLeafObjectL( const TDesC8& aURI,

                                                      const TDesC8& aLUID,

                                                      CBufBase& aLeafObject )

    {

    OstTraceExt1( TRACE_NORMAL, CPROXYBRANCH_FETCHLEAFOBJECTL_ENTRY, 

                  "ENTRY: CProxyBranch::FetchLeafObjectL;aURI=%s", aURI );

    RCmConnectionMethodExt cm;    

    CSmlDmAdapter::TError status = CSmlDmAdapter::ENotAllowed;

    TPtrC8 leafNode = CUtils::GetLastURISeg( aURI );

    TInt cmId( KErrNotFound );

    if ( aLUID.Length() > 0 )

         {

         cmId = CUtils::IntLUID( aLUID );         

         }

     else

         {

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

         cmId = GetCmIdFromURIL( aURI );

         }

    if ( cmId == KErrNotFound || !GetConnectionMethodLC( *iCmManager, cm, cmId ) || 

            !cm.GetBoolAttributeL(CMManager::ECmProxyUsageEnabled) )

        {

        if ( cmId != KErrNotFound )

            {

            CleanupStack::PopAndDestroy( &cm );

            }

        status = CSmlDmAdapter::ENotFound;

        OstTrace1( TRACE_NORMAL, CPROXYBRANCH_FETCHLEAFOBJECTL_NOT_FOUND, 

                   "CProxyBranch::FetchLeafObjectL;status=%{TError}", status );

        return status;

        }

    if ( leafNode.Compare( KCMProxyDdfAddr ) == 0 )

        {

        HBufC* serverName = cm.GetStringAttributeL( CMManager::ECmProxyServerName );

        CleanupStack::PushL( serverName );

        aLeafObject.InsertL( 0, CUtils::ConvertTo8LC( *serverName ) );

        CleanupStack::PopAndDestroy(); // CUtils::ConvertTo8LC

        CleanupStack::PopAndDestroy( serverName );

        status = CSmlDmAdapter::EOk;

        }

    else if ( leafNode.Compare( KCMProxyDdfConRef ) == 0 )

        {

        TBuf8<KBufferExpandSize> conRef;

        TBuf8<KBufferExpandSize> napChildList;

        CBufBase* napChildListBuf = CBufFlat::NewL( KSmlMaxURISegLen );

        CleanupStack::PushL( napChildListBuf );      

        // Get all NAP node childs

        iCallback->FetchLinkL( _L8("./NAP"), *napChildListBuf,  status );

        napChildListBuf->Read( 0, napChildList, napChildListBuf->Size() );

        if ( status == CSmlDmAdapter::EOk)

            {

            // Reset operation end status 

            status = CSmlDmAdapter::EError;

            // Find correct Uri

            while ( napChildList.Length() > 0 && status != CSmlDmAdapter::EOk )

                {

                conRef.Append( _L("NAP/") );

                CUtils::AppendFirstURISeg( napChildList, conRef );

                HBufC8* napLuid = iCallback->GetLuidAllocL( conRef );

                if ( cmId == CUtils::IntLUID( *napLuid ) )

                    {

                    status = CSmlDmAdapter::EOk;

                    aLeafObject.InsertL( 0, conRef );

                    }

                delete napLuid;

                conRef.Delete( 0, conRef.Length() );

                }

            }

        CleanupStack::PopAndDestroy( napChildListBuf );

        }

    else if ( leafNode.Compare( KCMProxyDdfPortNbr ) == 0 )

        {

        TInt proxyPort = cm.GetIntAttributeL( CMManager::ECmProxyPortNumber );

        aLeafObject.InsertL( 0, CUtils::IntToCharL( proxyPort ) );

        CleanupStack::PopAndDestroy();

        status = CSmlDmAdapter::EOk;

        }

    else if ( leafNode.Compare( KCMProxyDdfStartpg ) == 0 )

        {

        HBufC* startPage = cm.GetStringAttributeL( CMManager::ECmStartPage );

        CleanupStack::PushL( startPage );

        aLeafObject.InsertL( 0, CUtils::ConvertTo8LC( *startPage ) );

        CleanupStack::PopAndDestroy(); // CUtils::ConvertTo8LC

        CleanupStack::PopAndDestroy( startPage );

        status = CSmlDmAdapter::EOk;

        }

    else if ( leafNode.Compare( KCMProxyDdfProxyType ) == 0 )

        {

        HBufC* protocolName = cm.GetStringAttributeL( CMManager::ECmProxyProtocolName );

        CleanupStack::PushL( protocolName );

        aLeafObject.InsertL( 0, CUtils::ConvertTo8LC( *protocolName ) );

        CleanupStack::PopAndDestroy(); // CUtils::ConvertTo8LC

        CleanupStack::PopAndDestroy( protocolName );

        status = CSmlDmAdapter::EOk;

        }

    else if ( leafNode.Compare( KCMProxyDdfProxyId ) == 0 )

        {

        TPtrC8 dynamicNode = GetDynamicProxyNodeUri( aURI );

        aLeafObject.InsertL( 0, dynamicNode );

        status = CSmlDmAdapter::EOk;

        }

    CleanupStack::PopAndDestroy( &cm );

    OstTrace1( TRACE_NORMAL, CPROXYBRANCH_FETCHLEAFOBJECTL_EXIT, 

               "EXIT: CProxyBranch::FetchLeafObjectL;status=%{TError}", status );

    return status;

    }

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

// TUint32 CProxyBranch::CheckForUnmodifiableField()

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

CSmlDmAdapter::TError CProxyBranch::CheckForUnmodifiableField(const TDesC8& aUri)

    {

    OstTraceExt1( TRACE_NORMAL, CPROXYBRANCH_CHECKFORUNMODIFIABLEFIELD_ENTRY, 

                  "ENTRY: CProxyBranch::CheckForUnmodifiableField;aUri=%s", aUri );

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

    TPtrC8 nodeName = CUtils::GetLastURISeg(aUri);

    if ( nodeName.Match(KCMProxyDdfName) != KErrNotFound ||

         nodeName.Match(KCMProxyDdfConRef) != KErrNotFound  )

        {

        retval = CSmlDmAdapter::EOk;

        }

    OstTrace1( TRACE_NORMAL, CPROXYBRANCH_CHECKFORUNMODIFIABLEFIELD_EXIT, 

               "EXIT: CProxyBranch::CheckForUnmodifiableField;retval=%{TError}", retval );

    return retval;

    }

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

// TBool CProxyBranch::MapUriToCmAttribute()

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

TUint32 CProxyBranch::MapUriToCmAttribute( const TDesC8& aUri )

    {

    OstTraceExt1( TRACE_NORMAL, CPROXYBRANCH_MAPURITOCMATTRIBUTE_ENTRY, 

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

    TUint32 retval(0);

    TPtrC8 nodeName = CUtils::GetLastURISeg( aUri );

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

        {

        retval = CMManager::ECmProxyServerName;

        }

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

        {

        retval = CMManager::ECmProxyPortNumber; 

        }

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

        {

        retval = CMManager::ECmStartPage;

        }

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

            {

            retval = CMManager::ECmProxyProtocolName;

            }

    OstTrace1( TRACE_NORMAL, CPROXYBRANCH_MAPURITOCMATTRIBUTE_EXIT, 

               "EXIT: CProxyBranch::MapUriToCmAttribute;retval=%{TConnectionMethodCommonAttributes}", 

               retval );

    return retval;

    }

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

// TInt32 CProxyBranch::FindConnectionMethodL()

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

TInt32 CProxyBranch::FindConnectionMethodL()

    {

    OstTrace0( TRACE_NORMAL, CPROXYBRANCH_FINDCONNECTIONMETHODL_ENTRY, 

               "ENTRY: CProxyBranch::FindConnectionMethod" );

    TInt32 retval = KErrNotFound;

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

    if ( processNode )

        {

        HBufC8* luid;

        // Ignore root part ("./") of the URI if present in the beginning

        if ( processNode->iObject.Mid( 0, 2 ).Match( KRoot ) != KErrNotFound )

            {

            luid = iCallback->GetLuidAllocL( processNode->iObject.Mid( 2 ) );

            }

        else

            {

            luid = iCallback->GetLuidAllocL( processNode->iObject );

            }

        retval = CUtils::IntLUID( *luid );

        delete luid;

        }

    OstTrace1( TRACE_NORMAL, CPROXYBRANCH_FINDCONNECTIONMETHODL_EXIT, 

               "EXIT: CProxyBranch::FindConnectionMethod;CmId=%d", retval );

    return retval;

    }

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

// TBool CProxyBranch::AllMandatoryProxyFieldsFound()

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

TBool CProxyBranch::AllMandatoryProxyFieldsFound()

    {

    OstTrace0( TRACE_NORMAL, CPROXYBRANCH_ALLMANDATORYPROXYFIELDSFOUND_ENTRY, 

               "ENTRY: CProxyBranch::AllMandatoryProxyFieldsFound" );

    TBool retval = ETrue;

    // Check that NAP Address addition is found

    if ( !iBuffer->CacheFind(KProxyAddrUri) )

        {

        retval = EFalse;

        }

    if ( !iBuffer->CacheFind(KProxyConrefUri) )

        {

        retval = EFalse;

        }

    // Check that dynamic nap node addition is found

    if ( !iBuffer->CacheFindDynamicNode(KDynamicProxyNodePattern) )

        {

        retval = EFalse;

        }

    OstTrace1( TRACE_NORMAL, CPROXYBRANCH_ALLMANDATORYPROXYFIELDSFOUND_EXIT, 

               "EXIT: CProxyBranch::AllMandatoryProxyFieldsFound;retval=%d", retval );

    return retval;

    }

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

// TBool CProxyBranch::SetLeafData()

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

void CProxyBranch::SetLeafDataL(const TDesC8& aURI, 

                                const TDesC8& /*aLUID*/,

                                const TDesC8& aObject, 

                                 TInt aStatusRef, 

                                 RCmConnectionMethodExt& aCm)

    {

    OstTraceExt1( TRACE_NORMAL, CPROXYBRANCH_SETLEAFDATAL_ENTRY, 

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

    TUint32 attributeRef = ( 0 );

    TLex8 lex( aObject );

    TInt value = 0;

    CSmlDmAdapter::TError status = CSmlDmAdapter::EOk;

    attributeRef = MapUriToCmAttribute( aURI );

    switch ( attributeRef )

        {

        case CMManager::ECmProxyServerName:

        case CMManager::ECmStartPage:

        case CMManager::ECmProxyProtocolName:

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

            CleanupStack::PopAndDestroy(); // CUtils::ConvertTo16LC

            break;

        case CMManager::ECmProxyPortNumber:        

            if ( lex.Val( value ) == KErrNone )

                {

                aCm.SetIntAttributeL( attributeRef, value );

                }

            else

                {

                status = CSmlDmAdapter::EInvalidObject;

                }

            break;

        default:

            status = CheckForUnmodifiableField( aURI );

            break;

        }

    iCallback->SetStatusL( aStatusRef, status );

    OstTrace1( TRACE_NORMAL, CPROXYBRANCH_SETLEAFDATAL_EXIT, 

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

    }

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

// TBool CProxyBranch::SetNodeData()

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

void CProxyBranch::SetNodeDataL(CConnMoNodeElement* aNode, RCmConnectionMethodExt& aCm)

    {

    OstTraceExt1( TRACE_NORMAL, CPROXYBRANCH_SETNODEDATAL_ENTRY, "ENTRY: CProxyBranch::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 );

        }

    else

        {

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

        }

    OstTrace0( TRACE_NORMAL, CPROXYBRANCH_SETNODEDATAL_EXIT, "EXIT: CProxyBranch::SetNodeDataL" );

    }

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

//  void CProxyBranch::GetAllDynamicProxyNodes()

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

void CProxyBranch::GetAllDynamicProxyNodesL( const TDesC8& aURI,

                                             const CArrayFix<TSmlDmMappingInfo>& aPreviousURISegmentList,

                                             TInt aResultsRef, 

                                             TInt aStatusRef,

                                             CBufBase& aCurrentURISegmentList )

    {

    OstTraceExt1( TRACE_NORMAL, CPROXYBRANCH_GETALLDYNAMICPROXYNODESL_ENTRY, 

                  "ENTRY: CProxyBranch::GetAllDynamicProxyNodesL;aURI=%s", aURI );

    // Array for connection methods

    RArray <TUint32> cmArray;

    CleanupClosePushL( cmArray );

    cmArray.Reset();

    GetAllConnectionMethodsL( cmArray, *iCmManager );

    // Loop through all connection methods

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

        {

        RCmConnectionMethodExt cm = iCmManager->ConnectionMethodL( cmArray[i] );

        CleanupClosePushL( cm );

        // If proxy is enabled for connection method

        if ( cm.GetBoolAttributeL( CMManager::ECmProxyUsageEnabled ) )

            {

            OstTrace1( TRACE_NORMAL, CPROXYBRANCH_GETALLDYNAMICPROXYNODESL_PROXY, 

                        "CProxyBranch::GetAllDynamicProxyNodesL;Proxy enabled for Cm Id=%u", 

                        cmArray[i] );

            TBuf8<KSmlMaxURISegLen>addCmName;

            // Check if node exists in aPreviousURISegmentList

            if ( !CheckPreviousURIList( aPreviousURISegmentList, cmArray[i], addCmName ) )

                {

                // Connection Method not found in previous URI list                        

                addCmName.Append( aURI );

                addCmName.Append( KCMProxyNodeSeparator );

                addCmName.Append( KDynamicNodePrefix );

                addCmName.AppendNumFixedWidth( cmArray[i], EDecimal, 3); 

                TBuf8<16> addLUID;

                _LIT8( KFormat, "%d" );    

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

                OstTraceExt1( TRACE_NORMAL, 

                           CPROXYBRANCH_GETALLDYNAMICPROXYNODES_ADDED_TO_LIST, 

                           "CProxyBranch::GetAllDynamicProxyNodesL;Added to list: URI=%s", addCmName );

                iCallback->SetMappingL( addCmName, addLUID );

                }

            aCurrentURISegmentList.InsertL( aCurrentURISegmentList.Size(), CUtils::GetLastURISeg( addCmName ) );

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

            }

        CleanupStack::PopAndDestroy( &cm );

        }

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

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

    CleanupStack::PopAndDestroy( &cmArray );

    OstTrace0( TRACE_NORMAL, CPROXYBRANCH_GETALLDYNAMICPROXYNODESL_EXIT, 

               "EXI: CProxyBranch::GetAllDynamicProxyNodesLT" );  

    }

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

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

// CProxyBranch* CProxyBranch::NewL( )

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

CProxyBranch* CProxyBranch::NewL(MSmlDmCallback* aDmCallback, 

                                 CAddBuffer* aBuffer, 

                                 RCmManagerExt* aCmManagerExt  )

    {

    OstTraceFunctionEntry1( CPROXYBRANCH_NEWL_ENTRY, ( TUint )( aDmCallback ) );

    CProxyBranch* self = new (ELeave) CProxyBranch(aDmCallback, aBuffer, aCmManagerExt );

    OstTraceFunctionExit1( CPROXYBRANCH_NEWL_EXIT, ( TUint )( self ) );

    return self;

    }

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

// CProxyBranch::CProxyBranch()

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

CProxyBranch::CProxyBranch(MSmlDmCallback* aDmCallback, 

                           CAddBuffer* aBuffer,

                           RCmManagerExt* aCmManagerExt )

    : CBranchBase( aDmCallback )

    {

    OstTraceFunctionEntry1( CPROXYBRANCH_CONSTRUCTOR_ENTRY, this );

    iCallback = aDmCallback;

    iBuffer = aBuffer;

    iCmManager = aCmManagerExt;

    OstTraceFunctionExit1( CPROXYBRANCH_CONSTRUCTOR_EXIT, this );

    }

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

// CProxyBranch::~CProxyBranch()

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

CProxyBranch::~CProxyBranch()

    {

    OstTraceFunctionEntry1( CPROXYBRANCH_DESTRUCTOR_ENTRY, this );

    OstTraceFunctionExit1( CPROXYBRANCH_DESTRUCTOR_EXIT, this );

    }

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

//  void CProxyBranch::DDFStructureL()

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

void CProxyBranch::DDFStructureL( MSmlDmDDFObject& aDDF )

    {

    OstTraceFunctionEntry0( CPROXYBRANCH_DDFSTRUCTUREL_ENTRY );

    //

    // Set rest acceptable operations for data itself

    //

    TSmlDmAccessTypes aclTypesNoDelete;

    aclTypesNoDelete.SetGet();

    aclTypesNoDelete.SetReplace();

    aclTypesNoDelete.SetAdd();

    TSmlDmAccessTypes aclTypesAddGet;