/*

* Copyright (c) 2005-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:  Device Management NAT-FW Traversal Adapter

*

*/

// INCLUDE FILES

#include <utf.h>

#include <sysutil.h>

#include <f32file.h>

#include <shareddataclient.h>

#include "nsmldmnatfwtraversaladapter.h"

#include "nsmldmiapmatcher.h"

#include "natfwdomainentry.h"

#include "natfwiapentry.h"

#include "natfwdefaults.h" // Default values.

#ifdef VOIP_TRACE_ENABLED

#include <voip_trace.h>

#endif // VOIP_TRACE_ENABLED

// Central Repository keys for NAT-FW Traversal settings

#include "centralrepository.h"

#include <unsafprotocolscrkeys.h>

// Following lines are for enabling debug prints.

#ifdef _DEBUG

#define DBG_PRINT( p ) RDebug::Print( _L( p ) )

#define DBG_PRINT_2( p,i ) RDebug::Print ( _L( p ), i )

#else

#define DBG_PRINT( p )

#define DBG_PRINT_2( p,i )

#endif // _DEBUG

// LOCAL CONSTANTS

const TInt KNSmlNATFWMaxUriLength       = 256;

const TInt KNSmlNATFWMaxResultLength    = 256;

const TInt KDefaultResultSize           = 64;

const TInt KOneSeg                      = 1;

const TInt KTwoSegs                     = 2;

const TInt KThreeSegs                   = 3;

const TInt KFourSegs                    = 4;

const TInt KFiveSegs                    = 5;

const TInt KSixSegs                     = 6;

const TInt KSevenSegs                   = 7;

const TInt KLUIDMaxLength               = 256;

// Reference: OMA_Device_Management_DDF_for_NAT-FW_v1.0.doc

_LIT8( KNSmlDMNATFWDDFVersion,          "1.0" ); 

_LIT8( KNSmlDMNATFWNodeName,            "NATFW" );

// Domain specific settings

_LIT8( KNSmlDMDomainSpecificNodeName,   "DomainSpecific" );

_LIT8( KNSmlDMDomain,                   "Domain" );

_LIT8( KNSmlDMSTUNSrvAddr,              "STUNSrvAddr" );

_LIT8( KNSmlDMSTUNSrvPort,              "STUNSrvPort" );

_LIT8( KNSmlDMDomainNATRefreshTCP,      "NATRefreshTCP" );

_LIT8( KNSmlDMDomainNATRefreshUDP,      "NATRefreshUDP" );

_LIT8( KNSmlDMDomainEnableCRLFRefresh,  "EnableCRLFRefresh" );

// IAP specific settings

_LIT8( KNSmlDMIAPSpecificNodeName,      "IAPSpecific" );

_LIT8( KNSmlDMNATPrefConRef,            "PrefConRef" );

_LIT8( KNSmlDMNATRefreshTCP,            "NATRefreshTCP" );

_LIT8( KNSmlDMNATRefreshUDP,            "NATRefreshUDP" );

_LIT8( KNSmlDMSTUNRetransmit,           "STUNRetransmit" );

// Domain specific settings.

_LIT8( KNSmlDMSTUNUsername,             "STUNUsername" );

_LIT8( KNSmlDMSTUNPassword,             "STUNPassword" );

_LIT8( KNSmlDMSTUNSharedSecret,         "STUNSharedSecret" );

_LIT8( KNSmlDMPortPoolStart,            "PortPoolStartPort" );

_LIT8( KNSmlDMPortPoolEnd,              "PortPoolEndPort" );

_LIT8( KNSmlDMUsedNatProtocol,          "UsedNATProtocol" );

// Domain / STUN specific settings.

_LIT8( KNSmlDMAdditionalSTUNNodeName,   "AdditionalSTUNServer" );

// Domain / ICE specific settings.

_LIT8( KNSmlDMICESpecificNodeName,      "ICESpecific" );

_LIT8( KNSmlDMNatUtilities,             "NATUtilities" );

_LIT8( KNSmlDMHostPref,                 "HostPreference" );

_LIT8( KNSmlDMServerReflexPref,         "ServerReflexivePreference" );

_LIT8( KNSmlDMRelayPref,                "RelayPreference" );

_LIT8( KNSmlDMPeerReflexPref,           "PeerReflexivePreference" );

_LIT8( KNSmlDMIPv4Pref,                 "IPv4Preference" );

_LIT8( KNSmlDMIPv6Pref,                 "IPv6Preference" );

_LIT8( KNSmlDMVpnPref,                  "VPNPreference" );

_LIT8( KNSmlDMUdpPref,                  "UDPPreference" );

_LIT8( KNSmlDMTcpPref,                  "TCPPreference" );

_LIT8( KNSmlDMTcpActivePref,            "TCPActivePreference" );

_LIT8( KNSmlDMTcpPassivePref,           "TCPPassivePreference" );

_LIT8( KNSmlDMTcpSimultPref,            "TCPSimultaneousPreference" );

// Domain / TURN specific settings.

_LIT8( KNSmlDMTURNSpecificNodeName,     "TURNSpecific" );

_LIT8( KNSmlDMTURNServerNodeName,       "TURNServer" );

_LIT8( KNSmlDMTURNSrvAddr,              "TURNSrvAddr" );

_LIT8( KNSmlDMTURNSrvPort,              "TURNSrvPort" );

_LIT8( KNSmlDMTURNUsername,             "TURNUsername" );

_LIT8( KNSmlDMTURNPassword,             "TURNPassword" );

// Explanations of settings

_LIT8( KNSmlDMNATFWNodeNameExp,                 

    "node for NAT-FW Traversal settings" );

_LIT8( KNSmlDMDomainSpecificNodeNameExp,        

    "Domain Specific settings node" );

_LIT8( KNSmlDMDomainSpecificDynamicNodeExp,     

    "placeholder for all domain specific settings" );

_LIT8( KNSmlDMDomainExp,                        

    "Domain field" );

_LIT8( KNSmlDMSTUNSrvAddrExp,                   

    "STUN server address" );

_LIT8( KNSmlDMSTUNSrvPortExp,                   

    "STUN server port" );

_LIT8( KNSmlDMDomainNATRefreshTCPExp,           

    "NAT refresh interval for TCP in domain settings" );

_LIT8( KNSmlDMDomainNATRefreshUDPExp,              

    "NAT refresh interval for UDP in domain settings" );

_LIT8( KNSmlDMDomainEnableCRLFRefreshExp,       

    "For enabling CRLF-based NAT binding refresh" );

_LIT8( KNSmlDMIAPSpecificNodeNameExp,           

    "Access Point Specific settings node" );

_LIT8( KNSmlDMIAPSpecificDynamicNodeExp,        

    "placeholder for all IAP specific settings" );

_LIT8( KNSmlDMNATPrefConRefExp,                 

    "Link to IAP" );

_LIT8( KNSmlDMNATRefreshTCPExp,                 

    "NAT refresh interval for TCP" );

_LIT8( KNSmlDMNATRefreshUDPExp,                 

    "NAT refresh interval for UDP" );

_LIT8( KNSmlDMSTUNRetransmitExp,                

    "STUN request retransmit timer" );

// Domain

_LIT8( KNSmlDMSTUNUsernameExp,

    "STUN server username" );

_LIT8( KNSmlDMSTUNPasswordExp,

    "STUN server password" );

_LIT8( KNSmlDMSTUNSharedSecretExp,

    "STUN shared secret mechanism used or not" );

_LIT8( KNSmlDMPortPoolStartExp,

    "Start port of port pool" );

_LIT8( KNSmlDMPortPoolEndExp,

    "End port of port pool" );

_LIT8( KNSmlDMUsedNatProtocolExp,

    "Used NAT protocol" );

// AdditionalSTUNServer

_LIT8( KNSmlDMAdditionalSTUNNodeNameExp,

    "Additional STUN server settings" );

_LIT8( KNSmlDMAdditionalSTUNDynamicNodeExp,

    "placeholder for additional STUN server settings" );

// ICE

_LIT8( KNSmlDMICESpecificNodeNameExp,

    "ICE specific settings node" );

_LIT8( KNSmlDMNatUtilitiesExp,

    "NAT utilities to be used by ICE" );

_LIT8( KNSmlDMHostPrefExp,

    "HostPreference" );

_LIT8( KNSmlDMServerReflexPrefExp,

    "ServerReflexivePreference" );

_LIT8( KNSmlDMRelayPrefExp,

    "RelayPreference" );

_LIT8( KNSmlDMPeerReflexPrefExp,

    "PeerReflexivePreference" );

_LIT8( KNSmlDMIPv4PrefExp,

    "IPv4Preference" );

_LIT8( KNSmlDMIPv6PrefExp,

    "IPv6Preference" );

_LIT8( KNSmlDMVpnPrefExp,

    "VPNPreference" );

_LIT8( KNSmlDMUdpPrefExp,

    "UDPPreference" );

_LIT8( KNSmlDMTcpPrefExp,

    "TCPPreference" );

_LIT8( KNSmlDMTcpActivePrefExp,

    "TCPActivePreference" );

_LIT8( KNSmlDMTcpPassivePrefExp,

    "TCPPassivePreference" );

_LIT8( KNSmlDMTcpSimultPrefExp,

    "TCPSimultaneousPreference" );

// TURN

_LIT8( KNSmlDMTURNSpecificNodeNameExp,

    "TURN specific settings node" );

_LIT8( KNSmlDMTURNServerNodeNameExp,

    "TURN server settings node" );

_LIT8( KNSmlDMTURNServerDynamicNodeExp,

    "placeholder for TURN server settings" );

_LIT8( KNSmlDMTURNSrvAddrExp,

    "TURN server address" );

_LIT8( KNSmlDMTURNSrvPortExp,

    "TURN server port" );

_LIT8( KNSmlDMTURNUsernameExp,

    "TURN username" );

_LIT8( KNSmlDMTURNPasswordExp,

    "TURN password" );

// Other

_LIT8( KNSmlDMNATFWValueTrue,   "True" );

_LIT8( KNSmlDMNATFWValueFalse,  "False" );

_LIT8( KNSmlDMNATFWValueNotSet, "NotSet" );

_LIT8( KNSmlDMNATFWTextPlain,   "text/plain" );

_LIT8( KNSmlDMNATFWSeparator,   "/" );

_LIT8( KNSmlDMNATFWUriDotSlash, "./" );

//MACROS 

const TUint8 KDMNATFWSeparator = '/';

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

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

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

// CNSmlDmNATFWTraversalAdapter* CNSmlDmNATFWTraversalAdapter::NewL

//

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

//

CNSmlDmNATFWTraversalAdapter* CNSmlDmNATFWTraversalAdapter::NewL( 

    MSmlDmCallback* aDmCallback )

    {

    DBG_PRINT("CNSmlDmNATFWTraversalAdapter::NewL(): begin");

    CNSmlDmNATFWTraversalAdapter* self = NewLC( aDmCallback ); // CS:1

    CleanupStack::Pop( self ); // CS:0

    DBG_PRINT("CNSmlDmNATFWTraversalAdapter::NewL(): end");

    return self;

    }

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

// CNSmlDmNATFWTraversalAdapter* CNSmlDmNATFWTraversalAdapter::NewLC

//

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

//

CNSmlDmNATFWTraversalAdapter* CNSmlDmNATFWTraversalAdapter::NewLC( 

    MSmlDmCallback* aDmCallback )

    {

    DBG_PRINT("CNSmlDmNATFWTraversalAdapter::NewLC(): begin");

    CNSmlDmNATFWTraversalAdapter* self = 

        new ( ELeave ) CNSmlDmNATFWTraversalAdapter( aDmCallback );

    CleanupStack::PushL( self ); // CS:1

    self->iDmCallback = aDmCallback;

    DBG_PRINT("CNSmlDmNATFWTraversalAdapter::NewLC(): end");

    return self;

    }

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

// CNSmlDmNATFWTraversalAdapter::~CNSmlDmNATFWTraversalAdapter

//

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

//

CNSmlDmNATFWTraversalAdapter::~CNSmlDmNATFWTraversalAdapter()

    {

    DBG_PRINT("CNSmlDmNATFWTraversalAdapter::~CNSmlDmNATFWTraversalAdapter():\

 begin");

    if ( iNATFWDomainEntries )

        {

        iNATFWDomainEntries->ResetAndDestroy();

        delete iNATFWDomainEntries;    

        }

    if ( iNATFWIAPEntries )

        {

        iNATFWIAPEntries->ResetAndDestroy();

        delete iNATFWIAPEntries;    

        }

    iNATFWCommandBuffer.Close();

    DBG_PRINT("CNSmlDmNATFWTraversalAdapter::~CNSmlDmNATFWTraversalAdapter():\

 end");

    }

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

// CNSmlDmNATFWTraversalAdapter::CNSmlDmNATFWTraversalAdapter

// 

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

//

CNSmlDmNATFWTraversalAdapter::CNSmlDmNATFWTraversalAdapter(

    TAny* aEcomArguments ) : CSmlDmAdapter( aEcomArguments )

    {

    DBG_PRINT("CNSmlDmNATFWTraversalAdapter::CNSmlDmNATFWTraversalAdapter( \

aEcomArguments ): begin");

    DBG_PRINT("CNSmlDmNATFWTraversalAdapter::CNSmlDmNATFWTraversalAdapter( \

aEcomArguments ): end"); 

    }

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

// CNSmlDmNATFWTraversalAdapter::DDFVersionL

// Inserts DDF version of the adapter to aDDFVersion

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

//

void CNSmlDmNATFWTraversalAdapter::DDFVersionL(

    CBufBase& aDDFVersion )

    {

    DBG_PRINT("CNSmlDmNATFWTraversalAdapter::DDFVersionL(TDes& aDDFVersion):\

 begin");

    aDDFVersion.InsertL( 0, KNSmlDMNATFWDDFVersion );

    DBG_PRINT("CNSmlDmNATFWTraversalAdapter::DDFVersionL(TDes& aDDFVersion):\

 end");

    }

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

// CNSmlDmNATFWTraversalAdapter::DDFStructureL

// Builds the DDF structure of adapter

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

//

void CNSmlDmNATFWTraversalAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )

    {

    DBG_PRINT("CNSmlDmNATFWTraversalAdapter::DDFStructureL(): begin");

    // Default access types.

    TSmlDmAccessTypes accessTypesGet;

    accessTypesGet.SetGet();

    TSmlDmAccessTypes accessTypesGetAdd;

    accessTypesGetAdd.SetGet();

    accessTypesGetAdd.SetAdd();

    TSmlDmAccessTypes accessTypesGetReplaceAdd;

    accessTypesGetReplaceAdd.SetGet();

    accessTypesGetReplaceAdd.SetReplace();

    accessTypesGetReplaceAdd.SetAdd();

    TSmlDmAccessTypes accessTypesAll;

    accessTypesAll.SetGet();

    accessTypesAll.SetDelete();

    accessTypesAll.SetAdd();

    accessTypesAll.SetReplace();

    TSmlDmAccessTypes accessTypesNoDelete;

    accessTypesNoDelete.SetGet();

    accessTypesNoDelete.SetAdd();

    accessTypesNoDelete.SetReplace();

    // NATFWTraversal (./NATFW)

    MSmlDmDDFObject& natFwTraversal = aDDF.AddChildObjectL( 

        KNSmlDMNATFWNodeName );

    natFwTraversal.SetAccessTypesL( accessTypesGetAdd );

    natFwTraversal.SetOccurenceL( MSmlDmDDFObject::EOne );

    natFwTraversal.SetScopeL( MSmlDmDDFObject::EPermanent );

    natFwTraversal.SetDFFormatL( MSmlDmDDFObject::ENode );

    natFwTraversal.SetDescriptionL( KNSmlDMNATFWNodeNameExp );

    // DomainSpecific (./NATFW/DomainSpecific)

    MSmlDmDDFObject& domainSpecific = natFwTraversal.AddChildObjectL( 

        KNSmlDMDomainSpecificNodeName );

    domainSpecific.SetAccessTypesL( accessTypesGetAdd );

    domainSpecific.SetOccurenceL( MSmlDmDDFObject::EOne );

    domainSpecific.SetScopeL( MSmlDmDDFObject::EPermanent );

    domainSpecific.SetDFFormatL( MSmlDmDDFObject::ENode );

    domainSpecific.SetDescriptionL( KNSmlDMDomainSpecificNodeNameExp );

    // dynamic settings ID node ( ./NATFW/DomainSpecific/<x> )

    MSmlDmDDFObject& dynamicDomainNode = 

        domainSpecific.AddChildObjectGroupL();

    dynamicDomainNode.SetAccessTypesL( accessTypesAll );

    dynamicDomainNode.SetOccurenceL( MSmlDmDDFObject::EZeroOrMore );

    dynamicDomainNode.SetScopeL( MSmlDmDDFObject::EDynamic );

    dynamicDomainNode.SetDFFormatL( MSmlDmDDFObject::ENode );

    dynamicDomainNode.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain );

    dynamicDomainNode.SetDescriptionL( KNSmlDMDomainSpecificDynamicNodeExp );

    // DomainSpecific/<x>/Domain

    MSmlDmDDFObject& domain = dynamicDomainNode.AddChildObjectL( 

        KNSmlDMDomain );

    domain.SetAccessTypesL( accessTypesGetReplaceAdd );

    domain.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    domain.SetScopeL( MSmlDmDDFObject::EDynamic );

    domain.SetDFFormatL( MSmlDmDDFObject::EChr );

    domain.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain );

    domain.SetDescriptionL( KNSmlDMDomainExp );

    // DomainSpecific/<x>/STUNSrvAddr

    MSmlDmDDFObject& stunSrvAddr = dynamicDomainNode.AddChildObjectL( 

        KNSmlDMSTUNSrvAddr );

    stunSrvAddr.SetAccessTypesL( accessTypesGetReplaceAdd );

    stunSrvAddr.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    stunSrvAddr.SetScopeL( MSmlDmDDFObject::EDynamic );

    stunSrvAddr.SetDFFormatL( MSmlDmDDFObject::EChr );

    stunSrvAddr.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain );

    stunSrvAddr.SetDescriptionL( KNSmlDMSTUNSrvAddrExp );

    // DomainSpecific/<x>/STUNSrvPort

    MSmlDmDDFObject& stunSrvPort = dynamicDomainNode.AddChildObjectL( 

        KNSmlDMSTUNSrvPort );

    stunSrvPort.SetAccessTypesL( accessTypesGetReplaceAdd );

    stunSrvPort.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    stunSrvPort.SetScopeL( MSmlDmDDFObject::EDynamic );

    stunSrvPort.SetDFFormatL( MSmlDmDDFObject::EInt );

    stunSrvPort.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain );

    stunSrvPort.SetDescriptionL( KNSmlDMSTUNSrvPortExp );

    // DomainSpecific/<x>/NATRefreshTCP

    MSmlDmDDFObject& domainRefreshTCP = dynamicDomainNode.AddChildObjectL( 

        KNSmlDMDomainNATRefreshTCP );

    domainRefreshTCP.SetAccessTypesL( accessTypesGetReplaceAdd );

    domainRefreshTCP.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    domainRefreshTCP.SetScopeL( MSmlDmDDFObject::EDynamic );

    domainRefreshTCP.SetDFFormatL( MSmlDmDDFObject::EInt );

    domainRefreshTCP.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain );

    domainRefreshTCP.SetDescriptionL( KNSmlDMDomainNATRefreshTCPExp );

    // DomainSpecific/<x>/NATRefreshUDP

    MSmlDmDDFObject& domainRefreshUDP = dynamicDomainNode.AddChildObjectL( 

        KNSmlDMDomainNATRefreshUDP );

    domainRefreshUDP.SetAccessTypesL( accessTypesGetReplaceAdd );

    domainRefreshUDP.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    domainRefreshUDP.SetScopeL( MSmlDmDDFObject::EDynamic );

    domainRefreshUDP.SetDFFormatL( MSmlDmDDFObject::EInt );

    domainRefreshUDP.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain );

    domainRefreshUDP.SetDescriptionL( KNSmlDMDomainNATRefreshUDPExp );

    // DomainSpecific/<x>/EnableCRLFRefresh

    MSmlDmDDFObject& enableCRLF = dynamicDomainNode.AddChildObjectL( 

        KNSmlDMDomainEnableCRLFRefresh );

    enableCRLF.SetAccessTypesL( accessTypesGetReplaceAdd );

    enableCRLF.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    enableCRLF.SetScopeL( MSmlDmDDFObject::EDynamic );

    enableCRLF.SetDFFormatL( MSmlDmDDFObject::EInt );

    enableCRLF.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain );

    enableCRLF.SetDescriptionL( KNSmlDMDomainEnableCRLFRefreshExp );

    // DomainSpecific/<x>/STUNUsername

    MSmlDmDDFObject& stunUsername = dynamicDomainNode.AddChildObjectL( 

        KNSmlDMSTUNUsername );

    stunUsername.SetAccessTypesL( accessTypesGetReplaceAdd );

    stunUsername.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    stunUsername.SetScopeL( MSmlDmDDFObject::EDynamic );

    stunUsername.SetDFFormatL( MSmlDmDDFObject::EChr );

    stunUsername.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain );

    stunUsername.SetDescriptionL( KNSmlDMSTUNUsernameExp );

    // DomainSpecific/<x>/STUNPassword

    MSmlDmDDFObject& stunPassword = dynamicDomainNode.AddChildObjectL( 

        KNSmlDMSTUNPassword );

    stunPassword.SetAccessTypesL( accessTypesGetReplaceAdd );

    stunPassword.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    stunPassword.SetScopeL( MSmlDmDDFObject::EDynamic );

    stunPassword.SetDFFormatL( MSmlDmDDFObject::EChr );

    stunPassword.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain );

    stunPassword.SetDescriptionL( KNSmlDMSTUNPasswordExp );

    // DomainSpecific/<x>/AdditionalSTUNServer

    MSmlDmDDFObject& stunSrv = dynamicDomainNode.AddChildObjectL( 

        KNSmlDMAdditionalSTUNNodeName );

    stunSrv.SetAccessTypesL( accessTypesGetAdd );

    stunSrv.SetOccurenceL( MSmlDmDDFObject::EOne );

    stunSrv.SetScopeL( MSmlDmDDFObject::EDynamic );

    stunSrv.SetDFFormatL( MSmlDmDDFObject::ENode );

    stunSrv.SetDescriptionL( KNSmlDMAdditionalSTUNNodeNameExp );

    // DomainSpecific/<x>/AdditionalSTUNServer/<x>

    MSmlDmDDFObject& dynStunSrv = stunSrv.AddChildObjectGroupL();

    dynStunSrv.SetAccessTypesL( accessTypesAll );

    dynStunSrv.SetOccurenceL( MSmlDmDDFObject::EZeroOrMore );

    dynStunSrv.SetScopeL( MSmlDmDDFObject::EDynamic );

    dynStunSrv.SetDFFormatL( MSmlDmDDFObject::ENode );

    dynStunSrv.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain );

    dynStunSrv.SetDescriptionL( KNSmlDMAdditionalSTUNDynamicNodeExp );

    // DomainSpecific/<x>/AdditionalSTUNServer/<x>/STUNSrvAddr

    MSmlDmDDFObject& addStunSrvAddr = dynStunSrv.AddChildObjectL( 

        KNSmlDMSTUNSrvAddr );

    addStunSrvAddr.SetAccessTypesL( accessTypesGetReplaceAdd );

    addStunSrvAddr.SetOccurenceL( MSmlDmDDFObject::EOne );

    addStunSrvAddr.SetScopeL( MSmlDmDDFObject::EDynamic );

    addStunSrvAddr.SetDFFormatL( MSmlDmDDFObject::EChr );

    addStunSrvAddr.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain );

    addStunSrvAddr.SetDescriptionL( KNSmlDMSTUNSrvAddrExp );

    // DomainSpecific/<x>/AdditionalSTUNServer/<x>/STUNSrvPort

    MSmlDmDDFObject& addStunSrvPort = dynStunSrv.AddChildObjectL( 

        KNSmlDMSTUNSrvPort );

    addStunSrvPort.SetAccessTypesL( accessTypesGetReplaceAdd );

    addStunSrvPort.SetOccurenceL( MSmlDmDDFObject::EOne );

    addStunSrvPort.SetScopeL( MSmlDmDDFObject::EDynamic );

    addStunSrvPort.SetDFFormatL( MSmlDmDDFObject::EInt );

    addStunSrvPort.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain );

    addStunSrvPort.SetDescriptionL( KNSmlDMSTUNSrvPortExp );

    // DomainSpecific/<x>/AdditionalSTUNServer/<x>/STUNUsername

    MSmlDmDDFObject& addStunUsername = dynStunSrv.AddChildObjectL( 

        KNSmlDMSTUNUsername );

    addStunUsername.SetAccessTypesL( accessTypesGetReplaceAdd );

    addStunUsername.SetOccurenceL( MSmlDmDDFObject::EOne );

    addStunUsername.SetScopeL( MSmlDmDDFObject::EDynamic );

    addStunUsername.SetDFFormatL( MSmlDmDDFObject::EChr );

    addStunUsername.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain );

    addStunUsername.SetDescriptionL( KNSmlDMSTUNUsernameExp );

    // DomainSpecific/<x>/AdditionalSTUNServer/<x>/STUNPassword

    MSmlDmDDFObject& addStunPassword = dynStunSrv.AddChildObjectL( 

        KNSmlDMSTUNPassword );

    addStunPassword.SetAccessTypesL( accessTypesGetReplaceAdd );

    addStunPassword.SetOccurenceL( MSmlDmDDFObject::EOne );

    addStunPassword.SetScopeL( MSmlDmDDFObject::EDynamic );

    addStunPassword.SetDFFormatL( MSmlDmDDFObject::EChr );

    addStunPassword.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain );

    addStunPassword.SetDescriptionL( KNSmlDMSTUNPasswordExp );

    // DomainSpecific/<x>/STUNSharedSecret

    MSmlDmDDFObject& stunSharedSecret = dynamicDomainNode.AddChildObjectL( 

        KNSmlDMSTUNSharedSecret );

    stunSharedSecret.SetAccessTypesL( accessTypesGetReplaceAdd );

    stunSharedSecret.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    stunSharedSecret.SetScopeL( MSmlDmDDFObject::EDynamic );

    stunSharedSecret.SetDFFormatL( MSmlDmDDFObject::EBool );

    stunSharedSecret.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain );

    stunSharedSecret.SetDescriptionL( KNSmlDMSTUNSharedSecretExp );

    // DomainSpecific/<x>/PortPoolStartPort

    MSmlDmDDFObject& startPort = dynamicDomainNode.AddChildObjectL( 

        KNSmlDMPortPoolStart );

    startPort.SetAccessTypesL( accessTypesGetReplaceAdd );

    startPort.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    startPort.SetScopeL( MSmlDmDDFObject::EDynamic );

    startPort.SetDFFormatL( MSmlDmDDFObject::EInt );

    startPort.AddDFTypeMimeTypeL( KNSmlDMNATFWTextPlain );

    startPort.SetDescriptionL( KNSmlDMPortPoolStartExp );

    // DomainSpecific/<x>/PortPoolEndPort

    MSmlDmDDFObject& endPort = dynamicDomainNode.AddChildObjectL( 

        KNSmlDMPortPoolEnd );