/*

* Copyright (c) 2002-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 SIP Adapter

*

*/

// INCLUDE FILES

#include <utf.h>

#include <ecom/implementationproxy.h> // For TImplementationProxy definition

#include <sipprofile.h>

#include <sipprofiletypeinfo.h>

#include <sipstrings.h>

#include <sipstrconsts.h>

#include <f32file.h>

#include <sysutil.h>

#include <escapeutils.h>

#include <sipmanagedprofile.h>

#include <sipprofileregistryobserver.h>

#include <sipmanagedprofileregistry.h>

#include <sipaddress.h>

#include <nsmldmiapmatcher.h>

#include <mmf/common/mmfcontrollerpluginresolver.h>

#include <cmmanagerext.h>

#include <cmdestinationext.h>

#include <cmmanagerdef.h>

#include "nsmldmsipadapter.h"

#include "smldmsipadapterconstants.h"

#include "smldmsipadapterdebug.h"

// CONSTANTS

_LIT8( KEscaped, "%" );

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

// CNSmlDmSIPAdapter* CNSmlDmSIPAdapter::NewL

//

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

//

CNSmlDmSIPAdapter* CNSmlDmSIPAdapter::NewL(

    MSmlDmCallback* aDmCallback )

    {

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

    CNSmlDmSIPAdapter* self = NewLC( aDmCallback );

    CleanupStack::Pop( self );

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

    return self;

    }

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

// CNSmlDmSIPAdapter* CNSmlDmSIPAdapter::NewLC

//

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

//

CNSmlDmSIPAdapter* CNSmlDmSIPAdapter::NewLC(

    MSmlDmCallback* aDmCallback )

    {

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

    CNSmlDmSIPAdapter* self = new (ELeave) CNSmlDmSIPAdapter( aDmCallback );

    CleanupStack::PushL( self );

    self->ConstructL();

    self->iDmCallback = aDmCallback;

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

    return self;

    }

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

// CNSmlDmSIPAdapter::ConstructL

//

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

//

void CNSmlDmSIPAdapter::ConstructL()

    {

    DBG_PRINT("CNSmlDmSIPAdapter::ConstructL(): begin");

    // Open sip strings for methods that use it.

    SIPStrings::OpenL();

    DBG_PRINT("CNSmlDmSIPAdapter::ConstructL(): end");

    }

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

// CNSmlDmSIPAdapter::~CNSmlDmSIPAdapter

//

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

//

CNSmlDmSIPAdapter::~CNSmlDmSIPAdapter()

    {

    DBG_PRINT("CNSmlDmSIPAdapter::~CNSmlDmSIPAdapter(): begin");

    if ( iProfiles )

        {

        iProfiles->ResetAndDestroy();

        delete iProfiles;

        }

    if ( iSIPManagedProfileRegistry )

        {

        delete iSIPManagedProfileRegistry;

        }

    if ( iResults )

        {

        delete iResults;

        }

    iModifications.Reset();

    SIPStrings::Close();

    DBG_PRINT("CNSmlDmSIPAdapter::~CNSmlDmSIPAdapter(): end");

    }

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

// CNSmlDmSIPAdapter::CNSmlDmSIPAdapter

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CNSmlDmSIPAdapter::CNSmlDmSIPAdapter( TAny* aEcomArguments ) : CSmlDmAdapter( 

    aEcomArguments )

    {

    DBG_PRINT("CNSmlDmSIPAdapter::CNSmlDmSIPAdapter(aEcomArguments): begin");

    DBG_PRINT("CNSmlDmSIPAdapter::CNSmlDmSIPAdapter(aEcomArguments): end"); 

    }

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

// CNSmlDmSIPAdapter::LoadProfilesL

// Loads all profile information to memory.

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

//

void CNSmlDmSIPAdapter::LoadProfilesL()

    {

    DBG_PRINT("CNSmlDmSIPAdapter::LoadProfilesL(): begin");

    // Create needed instances.

    iSIPManagedProfileRegistry  = CSIPManagedProfileRegistry::NewL( *this );

    RArray<TSIPProfileTypeInfo> profileTypes;

    CleanupClosePushL( profileTypes ); // CS:1

     // Get the supported profile types

    iSIPManagedProfileRegistry->SupportedProfileTypesL( profileTypes );

    // Create the profile pointer array.

    iProfiles = new ( ELeave ) CArrayPtrFlat<CSIPManagedProfile>( 5 );    

    RPointerArray<CSIPProfile> profilePointerArray;

    CleanupResetAndDestroyPushL( profilePointerArray ); // CS:2

    // Get all profiles based on profile types.

    const TInt profileTypecount = profileTypes.Count();

    for ( TInt i = 0; i < profileTypecount; i++ )

        {

        iSIPManagedProfileRegistry->ProfilesL( 

            profileTypes[i], profilePointerArray );

        const TInt profileCount = profilePointerArray.Count();

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

            {

            CSIPManagedProfile* profile =

                static_cast<CSIPManagedProfile*>( profilePointerArray[j] );

            iProfiles->AppendL( profile );

            }

        profilePointerArray.Reset();

        }

    // &profilePointerArray, &profileTypes

    CleanupStack::PopAndDestroy( 2, &profileTypes ); // CS:0

    DBG_PRINT("CNSmlDmSIPAdapter::LoadProfilesL(): end");

    }

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

// CNSmlDmSIPAdapter::DDFVersionL

// Inserts DDF version of the adapter to aDDFVersion

// (other items were commented in a header).

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

//

void CNSmlDmSIPAdapter::DDFVersionL(

    CBufBase& aDDFVersion )

    {

    DBG_PRINT("CNSmlDmSIPAdapter::DDFVersionL(TDes& aDDFVersion): begin");

    aDDFVersion.InsertL( 0, KNSmlDMSIPDDFVersion );

    DBG_PRINT("CNSmlDmSIPAdapter::DDFVersionL(TDes& aDDFVersion): end");

    }

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

// CNSmlDmSIPAdapter::DDFStructureL

// Builds the DDF structure of adapter

// (other items were commented in a header).

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

//

void CNSmlDmSIPAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )

    {

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

    TSmlDmAccessTypes accessTypesGet;

    accessTypesGet.SetGet();

    TSmlDmAccessTypes accessTypesGetAdd;

    accessTypesGetAdd.SetGet();

    accessTypesGetAdd.SetAdd();

    TSmlDmAccessTypes accessTypesGetReplaceAdd;

    accessTypesGetReplaceAdd.SetGet();

    accessTypesGetReplaceAdd.SetReplace();

    accessTypesGetReplaceAdd.SetAdd();

    TSmlDmAccessTypes accessTypesReplaceAdd;

    accessTypesReplaceAdd.SetReplace();

    accessTypesReplaceAdd.SetAdd();

    TSmlDmAccessTypes accessTypesAll;

    accessTypesAll.SetGet();

    accessTypesAll.SetDelete();

    accessTypesAll.SetAdd();

    accessTypesAll.SetReplace();

    // SIP

    MSmlDmDDFObject& sip = aDDF.AddChildObjectL( KNSmlDMSIPNodeName );

    sip.SetAccessTypesL( accessTypesGet );

    sip.SetOccurenceL( MSmlDmDDFObject::EOne );

    sip.SetScopeL( MSmlDmDDFObject::EPermanent );

    sip.SetDFFormatL( MSmlDmDDFObject::ENode );

    sip.SetDescriptionL( KNSmlDMSIPNodeNameExp );

    // dynamic settings ID node

    MSmlDmDDFObject& idNode = sip.AddChildObjectGroupL();

    idNode.SetAccessTypesL( accessTypesAll );

    idNode.SetOccurenceL( MSmlDmDDFObject::EZeroOrMore );

    idNode.SetScopeL( MSmlDmDDFObject::EDynamic );

    idNode.SetDFFormatL( MSmlDmDDFObject::ENode );

    idNode.SetDescriptionL( KNSmlDMSIPDynamicNodeExp );

    // SipID

    MSmlDmDDFObject& sipID = idNode.AddChildObjectL( KNSmlDMSIPSipID );

    sipID.SetAccessTypesL( accessTypesGet );

    sipID.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    sipID.SetScopeL( MSmlDmDDFObject::EDynamic );

    sipID.SetDFFormatL( MSmlDmDDFObject::EChr );

    sipID.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    sipID.SetDescriptionL( KNSmlDMSIPSipIDExp );

    // Name

    MSmlDmDDFObject& name = idNode.AddChildObjectL( KNSmlDMSIPName );

    name.SetAccessTypesL( accessTypesGetReplaceAdd );

    name.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    name.SetScopeL( MSmlDmDDFObject::EDynamic );

    name.SetDFFormatL( MSmlDmDDFObject::EChr );

    name.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    name.SetDescriptionL( KNSmlDMSIPNameExp );

    // ProfileType

    MSmlDmDDFObject& profType = idNode.AddChildObjectL( 

        KNSmlDMSIPProfileType );

    profType.SetAccessTypesL( accessTypesGetReplaceAdd );

    profType.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    profType.SetScopeL( MSmlDmDDFObject::EDynamic );

    profType.SetDFFormatL( MSmlDmDDFObject::EChr );

    profType.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    profType.SetDescriptionL( KNSmlDMSIPProfileTypeExp );

    // Address Of Record

    MSmlDmDDFObject& aor = idNode.AddChildObjectL( KNSmlDMSIPAOR );

    aor.SetAccessTypesL( accessTypesGetReplaceAdd );

    aor.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    aor.SetScopeL( MSmlDmDDFObject::EDynamic );

    aor.SetDFFormatL( MSmlDmDDFObject::EChr );

    aor.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    aor.SetDescriptionL( KNSmlDMSIPAORExp );

    // OutboundProxy Node

    MSmlDmDDFObject& obProxy = idNode.AddChildObjectL( 

        KNSmlDMSIPOutboundProxy );

    obProxy.SetAccessTypesL( accessTypesGetAdd );

    obProxy.SetOccurenceL( MSmlDmDDFObject::EOne );

    obProxy.SetScopeL( MSmlDmDDFObject::EDynamic );

    obProxy.SetDFFormatL( MSmlDmDDFObject::ENode );

    obProxy.SetDescriptionL( KNSmlDMSIPOutboundProxyExp );

    // OutboundProxy/Host

    MSmlDmDDFObject& obHost = obProxy.AddChildObjectL( KNSmlDMSIPHost );

    obHost.SetAccessTypesL( accessTypesGetReplaceAdd );

    obHost.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    obHost.SetScopeL( MSmlDmDDFObject::EDynamic );

    obHost.SetDFFormatL( MSmlDmDDFObject::EChr );

    obHost.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    obHost.SetDescriptionL( KNSmlDMSIPHostExp );

    // OutboundProxy/Port

    MSmlDmDDFObject& obPort = obProxy.AddChildObjectL( KNSmlDMSIPPort );

    obPort.SetAccessTypesL( accessTypesGetReplaceAdd );

    obPort.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    obPort.SetScopeL( MSmlDmDDFObject::EDynamic );

    obPort.SetDFFormatL( MSmlDmDDFObject::EInt );

    obPort.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    obPort.SetDescriptionL( KNSmlDMSIPPortExp );

    // OutboundProxy/Transport

    MSmlDmDDFObject& obTransport = obProxy.AddChildObjectL( 

        KNSmlDMSIPTransport );

    obTransport.SetAccessTypesL( accessTypesGetReplaceAdd );

    obTransport.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    obTransport.SetScopeL( MSmlDmDDFObject::EDynamic );

    obTransport.SetDFFormatL( MSmlDmDDFObject::EChr );

    obTransport.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    obTransport.SetDescriptionL( KNSmlDMSIPTransportExp );

    // OutboundProxy/Username

    MSmlDmDDFObject& obUsername = obProxy.AddChildObjectL( 

        KNSmlDMSIPUsername );

    obUsername.SetAccessTypesL( accessTypesGetReplaceAdd );

    obUsername.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    obUsername.SetScopeL( MSmlDmDDFObject::EDynamic );

    obUsername.SetDFFormatL( MSmlDmDDFObject::EChr );

    obUsername.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    obUsername.SetDescriptionL( KNSmlDMSIPUsernameExp );

    // OutboundProxy/Passwd

    MSmlDmDDFObject& obPasswd = obProxy.AddChildObjectL( KNSmlDMSIPPasswd );

    obPasswd.SetAccessTypesL( accessTypesReplaceAdd );

    obPasswd.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    obPasswd.SetScopeL( MSmlDmDDFObject::EDynamic );

    obPasswd.SetDFFormatL( MSmlDmDDFObject::EChr );

    obPasswd.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    obPasswd.SetDescriptionL( KNSmlDMSIPPasswdExp );

    // OutboundProxy/Realm

    MSmlDmDDFObject& obRealm = obProxy.AddChildObjectL( KNSmlDMSIPRealm );

    obRealm.SetAccessTypesL( accessTypesGetReplaceAdd );

    obRealm.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    obRealm.SetScopeL( MSmlDmDDFObject::EDynamic );

    obRealm.SetDFFormatL( MSmlDmDDFObject::EChr );

    obRealm.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    obRealm.SetDescriptionL( KNSmlDMSIPRealmExp );

    // RegistrarServer Node

    MSmlDmDDFObject& regProxy = idNode.AddChildObjectL( 

        KNSmlDMSIPRegistrarServer );

    regProxy.SetAccessTypesL( accessTypesGetAdd );

    regProxy.SetOccurenceL( MSmlDmDDFObject::EOne );

    regProxy.SetScopeL( MSmlDmDDFObject::EDynamic );

    regProxy.SetDFFormatL( MSmlDmDDFObject::ENode );

    regProxy.SetDescriptionL( KNSmlDMSIPRegistrarServerExp );

    // RegistrarServer/Host

    MSmlDmDDFObject& regHost = regProxy.AddChildObjectL( KNSmlDMSIPHost );

    regHost.SetAccessTypesL( accessTypesGetReplaceAdd );

    regHost.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    regHost.SetScopeL( MSmlDmDDFObject::EDynamic );

    regHost.SetDFFormatL( MSmlDmDDFObject::EChr );

    regHost.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    regHost.SetDescriptionL( KNSmlDMSIPHostExp );

     // RegistrarServer/Port

    MSmlDmDDFObject& regPort = regProxy.AddChildObjectL( KNSmlDMSIPPort );

    regPort.SetAccessTypesL( accessTypesGetReplaceAdd );

    regPort.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    regPort.SetScopeL( MSmlDmDDFObject::EDynamic );

    regPort.SetDFFormatL( MSmlDmDDFObject::EInt );

    regPort.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    regPort.SetDescriptionL( KNSmlDMSIPPortExp );

    // RegistrarServer/Transport

    MSmlDmDDFObject& regTransport = regProxy.AddChildObjectL( 

        KNSmlDMSIPTransport );

    regTransport.SetAccessTypesL( accessTypesGetReplaceAdd );

    regTransport.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    regTransport.SetScopeL( MSmlDmDDFObject::EDynamic );

    regTransport.SetDFFormatL( MSmlDmDDFObject::EChr );

    regTransport.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    regTransport.SetDescriptionL( KNSmlDMSIPTransportExp );

    // RegistrarServer/Username

    MSmlDmDDFObject& regUsername = regProxy.AddChildObjectL( 

        KNSmlDMSIPUsername );

    regUsername.SetAccessTypesL( accessTypesGetReplaceAdd );

    regUsername.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    regUsername.SetScopeL( MSmlDmDDFObject::EDynamic );

    regUsername.SetDFFormatL( MSmlDmDDFObject::EChr );

    regUsername.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    regUsername.SetDescriptionL( KNSmlDMSIPUsernameExp );

    // RegistrarServer/PrivateIdentity

    MSmlDmDDFObject& regPrivateIdentity = regProxy.AddChildObjectL( 

        KNSmlDMSIPPrivateIdentity );

    regPrivateIdentity.SetAccessTypesL( accessTypesGetReplaceAdd );

    regPrivateIdentity.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    regPrivateIdentity.SetScopeL( MSmlDmDDFObject::EDynamic );

    regPrivateIdentity.SetDFFormatL( MSmlDmDDFObject::EChr );

    regPrivateIdentity.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    regPrivateIdentity.SetDescriptionL( KNSmlDMSIPPrivateIdentityExp );

    // RegistrarServer/Passwd

    MSmlDmDDFObject& regPasswd = regProxy.AddChildObjectL( KNSmlDMSIPPasswd );

    regPasswd.SetAccessTypesL( accessTypesReplaceAdd );

    regPasswd.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    regPasswd.SetScopeL( MSmlDmDDFObject::EDynamic );

    regPasswd.SetDFFormatL( MSmlDmDDFObject::EChr );

    regPasswd.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    regPasswd.SetDescriptionL( KNSmlDMSIPPasswdExp );

    // RegistrarServer/Realm

    MSmlDmDDFObject& regRealm = regProxy.AddChildObjectL( KNSmlDMSIPRealm );

    regRealm.SetAccessTypesL( accessTypesGetReplaceAdd );

    regRealm.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    regRealm.SetScopeL( MSmlDmDDFObject::EDynamic );

    regRealm.SetDFFormatL( MSmlDmDDFObject::EChr );

    regRealm.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    regRealm.SetDescriptionL( KNSmlDMSIPRealmExp );

    // Default

    MSmlDmDDFObject& def = idNode.AddChildObjectL( KNSmlDMSIPDefault );

    def.SetAccessTypesL( accessTypesGetReplaceAdd );

    def.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    def.SetScopeL( MSmlDmDDFObject::EDynamic );

    def.SetDFFormatL( MSmlDmDDFObject::EBool );

    def.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    def.SetDescriptionL( KNSmlDMSIPDefaultExp );

    // LooseRouting

    MSmlDmDDFObject& lr = idNode.AddChildObjectL( KNSmlDMSIPLooseRouting );

    lr.SetAccessTypesL( accessTypesGetReplaceAdd );

    lr.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    lr.SetScopeL( MSmlDmDDFObject::EDynamic );

    lr.SetDFFormatL( MSmlDmDDFObject::EBool );

    lr.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    lr.SetDescriptionL( KNSmlDMSIPLooseRoutingExp );

    // EnableSecurityNegotiation

    MSmlDmDDFObject& enSecNeg = idNode.AddChildObjectL( 

        KNSmlDMSIPEnableSecurityNegotiation );

    enSecNeg.SetAccessTypesL( accessTypesGetReplaceAdd );

    enSecNeg.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    enSecNeg.SetScopeL( MSmlDmDDFObject::EDynamic );

    enSecNeg.SetDFFormatL( MSmlDmDDFObject::EBool );

    enSecNeg.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    enSecNeg.SetDescriptionL( KNSmlDMSIPEnableSecurityNegotiationExp );

    // EnableSigComp

    MSmlDmDDFObject& enSigComp = idNode.AddChildObjectL( 

        KNSmlDMSIPEnableSigComp );

    enSigComp.SetAccessTypesL( accessTypesGetReplaceAdd );

    enSigComp.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    enSigComp.SetScopeL( MSmlDmDDFObject::EDynamic );

    enSigComp.SetDFFormatL( MSmlDmDDFObject::EBool );

    enSigComp.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    enSigComp.SetDescriptionL( KNSmlDMSIPEnableSigCompExp );

    // EnableAutoRegistration

    MSmlDmDDFObject& enAutoReg = idNode.AddChildObjectL( 

        KNSmlDMSIPEnableAutoRegistration );

    enAutoReg.SetAccessTypesL( accessTypesGetReplaceAdd );

    enAutoReg.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    enAutoReg.SetScopeL( MSmlDmDDFObject::EDynamic );

    enAutoReg.SetDFFormatL( MSmlDmDDFObject::EBool );

    enAutoReg.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    enAutoReg.SetDescriptionL( KNSmlDMSIPEnableAutoRegistrationExp );

    // PrefConRef

    MSmlDmDDFObject& toNapId = idNode.AddChildObjectL( KNSmlDMSIPConRef );

    toNapId.SetAccessTypesL( accessTypesGetReplaceAdd );

    toNapId.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    toNapId.SetScopeL( MSmlDmDDFObject::EDynamic );

    toNapId.SetDFFormatL( MSmlDmDDFObject::EChr );

    toNapId.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    toNapId.SetDescriptionL( KNSmlDMSIPConRefExp );

    // ProfileLock

    MSmlDmDDFObject& profileLock = idNode.AddChildObjectL( 

        KNSmlDMSIPProfileLock );

    profileLock.SetAccessTypesL( accessTypesGetReplaceAdd );

    profileLock.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    profileLock.SetScopeL( MSmlDmDDFObject::EDynamic );

    profileLock.SetDFFormatL( MSmlDmDDFObject::EBool );

    profileLock.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    profileLock.SetDescriptionL( KNSmlDMSIPProfileLockExp );

    // DestinationNetwork

    MSmlDmDDFObject& toSnapId = idNode.AddChildObjectL( KNSmlDMSIPSnap );

    toSnapId.SetAccessTypesL( accessTypesGetReplaceAdd );

    toSnapId.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    toSnapId.SetScopeL( MSmlDmDDFObject::EDynamic );

    toSnapId.SetDFFormatL( MSmlDmDDFObject::EChr );

    toSnapId.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    toSnapId.SetDescriptionL( KNSmlDMSIPSnapExp );

    // SignalingQoS

    MSmlDmDDFObject& sigQos = idNode.AddChildObjectL( KNSmlDMSIPSigQos );

    sigQos.SetAccessTypesL( accessTypesGetReplaceAdd );

    sigQos.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    sigQos.SetScopeL( MSmlDmDDFObject::EDynamic );

    sigQos.SetDFFormatL( MSmlDmDDFObject::EInt );

    sigQos.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

    sigQos.SetDescriptionL( KNSmlDMSIPSigQosExp );

    DBG_PRINT("CNSmlDmSIPAdapter::DDFStructureL(): end");

    }

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

// CNSmlDmSIPAdapter::UpdateLeafObjectL

// Updates value of a leaf object

// (other items were commented in a header).

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

//

void CNSmlDmSIPAdapter::UpdateLeafObjectL( 

    const TDesC8& aURI, 

    const TDesC8& aLUID, 

    const TDesC8& aObject, 

    const TDesC8& /*aType*/, 

    const TInt aStatusRef )

    {

    DBG_PRINT("CNSmlDmSIPAdapter::UpdateLeafObjectL(): begin");

    // Load profile information if not loaded yet

    if ( !iProfiles )

        {

        LoadProfilesL();    

        }

    CSmlDmAdapter::TError status = EOk;

    TPtrC8 lastUriSeg = LastURISeg( aURI );