1 /*

     2 * Copyright (c) 2002-2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Device Management SIP Adapter

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include <utf.h>

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

    22 #include <sipprofile.h>

    23 #include <sipprofiletypeinfo.h>

    24 #include <sipstrings.h>

    25 #include <sipstrconsts.h>

    26 #include <f32file.h>

    27 #include <sysutil.h>

    28 #include <escapeutils.h>

    29 

    30 #include <sipmanagedprofile.h>

    31 #include <sipprofileregistryobserver.h>

    32 #include <sipmanagedprofileregistry.h>

    33 #include <sipaddress.h>

    34 #include <nsmldmiapmatcher.h>

    35 #include <mmf/common/mmfcontrollerpluginresolver.h>

    36 

    37 #include <cmmanagerext.h>

    38 #include <cmdestinationext.h>

    39 #include <cmmanagerdef.h>

    40 

    41 #include "nsmldmsipadapter.h"

    42 #include "smldmsipadapterconstants.h"

    43 #include "smldmsipadapterdebug.h"

    44 

    45 // CONSTANTS

    46 _LIT8( KEscaped, "%" );

    47 

    48 // ---------------------------------------------------------------------------

    49 // CNSmlDmSIPAdapter* CNSmlDmSIPAdapter::NewL

    50 //

    51 // ---------------------------------------------------------------------------

    52 //

    53 CNSmlDmSIPAdapter* CNSmlDmSIPAdapter::NewL(

    54     MSmlDmCallback* aDmCallback )

    55     {

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

    57     CNSmlDmSIPAdapter* self = NewLC( aDmCallback );

    58     CleanupStack::Pop( self );

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

    60     return self;

    61     }

    62 

    63 // ---------------------------------------------------------------------------

    64 // CNSmlDmSIPAdapter* CNSmlDmSIPAdapter::NewLC

    65 //

    66 // ---------------------------------------------------------------------------

    67 //

    68 CNSmlDmSIPAdapter* CNSmlDmSIPAdapter::NewLC(

    69     MSmlDmCallback* aDmCallback )

    70     {

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

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

    73     CleanupStack::PushL( self );

    74     self->ConstructL();

    75     self->iDmCallback = aDmCallback;

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

    77     return self;

    78     }

    79 

    80 // ---------------------------------------------------------------------------

    81 // CNSmlDmSIPAdapter::ConstructL

    82 //

    83 // ---------------------------------------------------------------------------

    84 //

    85 void CNSmlDmSIPAdapter::ConstructL()

    86     {

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

    88     

    89     // Open sip strings for methods that use it.

    90     SIPStrings::OpenL();

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

    92     }

    93 

    94 // ---------------------------------------------------------------------------

    95 // CNSmlDmSIPAdapter::~CNSmlDmSIPAdapter

    96 //

    97 // ---------------------------------------------------------------------------

    98 //

    99 CNSmlDmSIPAdapter::~CNSmlDmSIPAdapter()

   100     {

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

   102     if ( iProfiles )

   103         {

   104         iProfiles->ResetAndDestroy();

   105         delete iProfiles;

   106         }

   107 

   108     if ( iSIPManagedProfileRegistry )

   109         {

   110         delete iSIPManagedProfileRegistry;

   111         }

   112 

   113     if ( iResults )

   114         {

   115         delete iResults;

   116         }

   117     iModifications.Reset();

   118     SIPStrings::Close();

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

   120     }

   121 

   122 // ---------------------------------------------------------------------------

   123 // CNSmlDmSIPAdapter::CNSmlDmSIPAdapter

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

   125 // might leave.

   126 // ---------------------------------------------------------------------------

   127 //

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

   129     aEcomArguments )

   130     {

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

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

   133     }

   134 

   135 // ---------------------------------------------------------------------------

   136 // CNSmlDmSIPAdapter::LoadProfilesL

   137 // Loads all profile information to memory.

   138 // ---------------------------------------------------------------------------

   139 //

   140 void CNSmlDmSIPAdapter::LoadProfilesL()

   141     {

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

   143 

   144     // Create needed instances.

   145     iSIPManagedProfileRegistry  = CSIPManagedProfileRegistry::NewL( *this );

   146 

   147     RArray<TSIPProfileTypeInfo> profileTypes;

   148     CleanupClosePushL( profileTypes ); // CS:1

   149 

   150      // Get the supported profile types

   151     iSIPManagedProfileRegistry->SupportedProfileTypesL( profileTypes );

   152 

   153     // Create the profile pointer array.

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

   155 

   156     RPointerArray<CSIPProfile> profilePointerArray;

   157     CleanupResetAndDestroyPushL( profilePointerArray ); // CS:2

   158 

   159     // Get all profiles based on profile types.

   160     const TInt profileTypecount = profileTypes.Count();

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

   162         {

   163         iSIPManagedProfileRegistry->ProfilesL( 

   164             profileTypes[i], profilePointerArray );

   165         const TInt profileCount = profilePointerArray.Count();

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

   167             {

   168             CSIPManagedProfile* profile =

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

   170             iProfiles->AppendL( profile );

   171             }

   172         profilePointerArray.Reset();

   173         }

   174     // &profilePointerArray, &profileTypes

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

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

   177     }

   178 

   179 // ---------------------------------------------------------------------------

   180 // CNSmlDmSIPAdapter::DDFVersionL

   181 // Inserts DDF version of the adapter to aDDFVersion

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

   183 // ---------------------------------------------------------------------------

   184 //

   185 void CNSmlDmSIPAdapter::DDFVersionL(

   186     CBufBase& aDDFVersion )

   187     {

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

   189     aDDFVersion.InsertL( 0, KNSmlDMSIPDDFVersion );

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

   191     }

   192 

   193 // ---------------------------------------------------------------------------

   194 // CNSmlDmSIPAdapter::DDFStructureL

   195 // Builds the DDF structure of adapter

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

   197 // ---------------------------------------------------------------------------

   198 //

   199 void CNSmlDmSIPAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )

   200     {

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

   202 

   203     TSmlDmAccessTypes accessTypesGet;

   204     accessTypesGet.SetGet();

   205 

   206     TSmlDmAccessTypes accessTypesGetAdd;

   207     accessTypesGetAdd.SetGet();

   208     accessTypesGetAdd.SetAdd();

   209 

   210     TSmlDmAccessTypes accessTypesGetReplaceAdd;

   211     accessTypesGetReplaceAdd.SetGet();

   212     accessTypesGetReplaceAdd.SetReplace();

   213     accessTypesGetReplaceAdd.SetAdd();

   214 

   215     TSmlDmAccessTypes accessTypesReplaceAdd;

   216     accessTypesReplaceAdd.SetReplace();

   217     accessTypesReplaceAdd.SetAdd();

   218 

   219     TSmlDmAccessTypes accessTypesAll;

   220     accessTypesAll.SetGet();

   221     accessTypesAll.SetDelete();

   222     accessTypesAll.SetAdd();

   223     accessTypesAll.SetReplace();

   224 

   225     // SIP

   226     MSmlDmDDFObject& sip = aDDF.AddChildObjectL( KNSmlDMSIPNodeName );

   227     sip.SetAccessTypesL( accessTypesGet );

   228     sip.SetOccurenceL( MSmlDmDDFObject::EOne );

   229     sip.SetScopeL( MSmlDmDDFObject::EPermanent );

   230     sip.SetDFFormatL( MSmlDmDDFObject::ENode );

   231     sip.SetDescriptionL( KNSmlDMSIPNodeNameExp );

   232 

   233     // dynamic settings ID node

   234     MSmlDmDDFObject& idNode = sip.AddChildObjectGroupL();

   235     idNode.SetAccessTypesL( accessTypesAll );

   236     idNode.SetOccurenceL( MSmlDmDDFObject::EZeroOrMore );

   237     idNode.SetScopeL( MSmlDmDDFObject::EDynamic );

   238     idNode.SetDFFormatL( MSmlDmDDFObject::ENode );

   239     idNode.SetDescriptionL( KNSmlDMSIPDynamicNodeExp );

   240 

   241     // SipID

   242     MSmlDmDDFObject& sipID = idNode.AddChildObjectL( KNSmlDMSIPSipID );

   243     sipID.SetAccessTypesL( accessTypesGet );

   244     sipID.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   245     sipID.SetScopeL( MSmlDmDDFObject::EDynamic );

   246     sipID.SetDFFormatL( MSmlDmDDFObject::EChr );

   247     sipID.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   248     sipID.SetDescriptionL( KNSmlDMSIPSipIDExp );

   249 

   250     // Name

   251     MSmlDmDDFObject& name = idNode.AddChildObjectL( KNSmlDMSIPName );

   252     name.SetAccessTypesL( accessTypesGetReplaceAdd );

   253     name.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   254     name.SetScopeL( MSmlDmDDFObject::EDynamic );

   255     name.SetDFFormatL( MSmlDmDDFObject::EChr );

   256     name.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   257     name.SetDescriptionL( KNSmlDMSIPNameExp );

   258 

   259     // ProfileType

   260     MSmlDmDDFObject& profType = idNode.AddChildObjectL( 

   261         KNSmlDMSIPProfileType );

   262     profType.SetAccessTypesL( accessTypesGetReplaceAdd );

   263     profType.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   264     profType.SetScopeL( MSmlDmDDFObject::EDynamic );

   265     profType.SetDFFormatL( MSmlDmDDFObject::EChr );

   266     profType.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   267     profType.SetDescriptionL( KNSmlDMSIPProfileTypeExp );

   268 

   269     // Address Of Record

   270     MSmlDmDDFObject& aor = idNode.AddChildObjectL( KNSmlDMSIPAOR );

   271     aor.SetAccessTypesL( accessTypesGetReplaceAdd );

   272     aor.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   273     aor.SetScopeL( MSmlDmDDFObject::EDynamic );

   274     aor.SetDFFormatL( MSmlDmDDFObject::EChr );

   275     aor.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   276     aor.SetDescriptionL( KNSmlDMSIPAORExp );

   277 

   278     // OutboundProxy Node

   279     MSmlDmDDFObject& obProxy = idNode.AddChildObjectL( 

   280         KNSmlDMSIPOutboundProxy );

   281     obProxy.SetAccessTypesL( accessTypesGetAdd );

   282     obProxy.SetOccurenceL( MSmlDmDDFObject::EOne );

   283     obProxy.SetScopeL( MSmlDmDDFObject::EDynamic );

   284     obProxy.SetDFFormatL( MSmlDmDDFObject::ENode );

   285     obProxy.SetDescriptionL( KNSmlDMSIPOutboundProxyExp );

   286 

   287     // OutboundProxy/Host

   288     MSmlDmDDFObject& obHost = obProxy.AddChildObjectL( KNSmlDMSIPHost );

   289     obHost.SetAccessTypesL( accessTypesGetReplaceAdd );

   290     obHost.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   291     obHost.SetScopeL( MSmlDmDDFObject::EDynamic );

   292     obHost.SetDFFormatL( MSmlDmDDFObject::EChr );

   293     obHost.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   294     obHost.SetDescriptionL( KNSmlDMSIPHostExp );

   295 

   296     // OutboundProxy/Port

   297     MSmlDmDDFObject& obPort = obProxy.AddChildObjectL( KNSmlDMSIPPort );

   298     obPort.SetAccessTypesL( accessTypesGetReplaceAdd );

   299     obPort.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   300     obPort.SetScopeL( MSmlDmDDFObject::EDynamic );

   301     obPort.SetDFFormatL( MSmlDmDDFObject::EInt );

   302     obPort.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   303     obPort.SetDescriptionL( KNSmlDMSIPPortExp );

   304 

   305     // OutboundProxy/Transport

   306     MSmlDmDDFObject& obTransport = obProxy.AddChildObjectL( 

   307         KNSmlDMSIPTransport );

   308     obTransport.SetAccessTypesL( accessTypesGetReplaceAdd );

   309     obTransport.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   310     obTransport.SetScopeL( MSmlDmDDFObject::EDynamic );

   311     obTransport.SetDFFormatL( MSmlDmDDFObject::EChr );

   312     obTransport.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   313     obTransport.SetDescriptionL( KNSmlDMSIPTransportExp );

   314 

   315     // OutboundProxy/Username

   316     MSmlDmDDFObject& obUsername = obProxy.AddChildObjectL( 

   317         KNSmlDMSIPUsername );

   318     obUsername.SetAccessTypesL( accessTypesGetReplaceAdd );

   319     obUsername.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   320     obUsername.SetScopeL( MSmlDmDDFObject::EDynamic );

   321     obUsername.SetDFFormatL( MSmlDmDDFObject::EChr );

   322     obUsername.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   323     obUsername.SetDescriptionL( KNSmlDMSIPUsernameExp );

   324 

   325     // OutboundProxy/Passwd

   326     MSmlDmDDFObject& obPasswd = obProxy.AddChildObjectL( KNSmlDMSIPPasswd );

   327     obPasswd.SetAccessTypesL( accessTypesReplaceAdd );

   328     obPasswd.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   329     obPasswd.SetScopeL( MSmlDmDDFObject::EDynamic );

   330     obPasswd.SetDFFormatL( MSmlDmDDFObject::EChr );

   331     obPasswd.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   332     obPasswd.SetDescriptionL( KNSmlDMSIPPasswdExp );

   333 

   334     // OutboundProxy/Realm

   335     MSmlDmDDFObject& obRealm = obProxy.AddChildObjectL( KNSmlDMSIPRealm );

   336     obRealm.SetAccessTypesL( accessTypesGetReplaceAdd );

   337     obRealm.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   338     obRealm.SetScopeL( MSmlDmDDFObject::EDynamic );

   339     obRealm.SetDFFormatL( MSmlDmDDFObject::EChr );

   340     obRealm.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   341     obRealm.SetDescriptionL( KNSmlDMSIPRealmExp );

   342 

   343     // RegistrarServer Node

   344     MSmlDmDDFObject& regProxy = idNode.AddChildObjectL( 

   345         KNSmlDMSIPRegistrarServer );

   346     regProxy.SetAccessTypesL( accessTypesGetAdd );

   347     regProxy.SetOccurenceL( MSmlDmDDFObject::EOne );

   348     regProxy.SetScopeL( MSmlDmDDFObject::EDynamic );

   349     regProxy.SetDFFormatL( MSmlDmDDFObject::ENode );

   350     regProxy.SetDescriptionL( KNSmlDMSIPRegistrarServerExp );

   351 

   352     // RegistrarServer/Host

   353     MSmlDmDDFObject& regHost = regProxy.AddChildObjectL( KNSmlDMSIPHost );

   354     regHost.SetAccessTypesL( accessTypesGetReplaceAdd );

   355     regHost.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   356     regHost.SetScopeL( MSmlDmDDFObject::EDynamic );

   357     regHost.SetDFFormatL( MSmlDmDDFObject::EChr );

   358     regHost.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   359     regHost.SetDescriptionL( KNSmlDMSIPHostExp );

   360 

   361      // RegistrarServer/Port

   362     MSmlDmDDFObject& regPort = regProxy.AddChildObjectL( KNSmlDMSIPPort );

   363     regPort.SetAccessTypesL( accessTypesGetReplaceAdd );

   364     regPort.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   365     regPort.SetScopeL( MSmlDmDDFObject::EDynamic );

   366     regPort.SetDFFormatL( MSmlDmDDFObject::EInt );

   367     regPort.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   368     regPort.SetDescriptionL( KNSmlDMSIPPortExp );

   369 

   370     // RegistrarServer/Transport

   371     MSmlDmDDFObject& regTransport = regProxy.AddChildObjectL( 

   372         KNSmlDMSIPTransport );

   373     regTransport.SetAccessTypesL( accessTypesGetReplaceAdd );

   374     regTransport.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   375     regTransport.SetScopeL( MSmlDmDDFObject::EDynamic );

   376     regTransport.SetDFFormatL( MSmlDmDDFObject::EChr );

   377     regTransport.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   378     regTransport.SetDescriptionL( KNSmlDMSIPTransportExp );

   379 

   380     // RegistrarServer/Username

   381     MSmlDmDDFObject& regUsername = regProxy.AddChildObjectL( 

   382         KNSmlDMSIPUsername );

   383     regUsername.SetAccessTypesL( accessTypesGetReplaceAdd );

   384     regUsername.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   385     regUsername.SetScopeL( MSmlDmDDFObject::EDynamic );

   386     regUsername.SetDFFormatL( MSmlDmDDFObject::EChr );

   387     regUsername.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   388     regUsername.SetDescriptionL( KNSmlDMSIPUsernameExp );

   389 

   390     // RegistrarServer/PrivateIdentity

   391     MSmlDmDDFObject& regPrivateIdentity = regProxy.AddChildObjectL( 

   392         KNSmlDMSIPPrivateIdentity );

   393     regPrivateIdentity.SetAccessTypesL( accessTypesGetReplaceAdd );

   394     regPrivateIdentity.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   395     regPrivateIdentity.SetScopeL( MSmlDmDDFObject::EDynamic );

   396     regPrivateIdentity.SetDFFormatL( MSmlDmDDFObject::EChr );

   397     regPrivateIdentity.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   398     regPrivateIdentity.SetDescriptionL( KNSmlDMSIPPrivateIdentityExp );

   399 

   400     // RegistrarServer/Passwd

   401     MSmlDmDDFObject& regPasswd = regProxy.AddChildObjectL( KNSmlDMSIPPasswd );

   402     regPasswd.SetAccessTypesL( accessTypesReplaceAdd );

   403     regPasswd.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   404     regPasswd.SetScopeL( MSmlDmDDFObject::EDynamic );

   405     regPasswd.SetDFFormatL( MSmlDmDDFObject::EChr );

   406     regPasswd.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   407     regPasswd.SetDescriptionL( KNSmlDMSIPPasswdExp );

   408 

   409     // RegistrarServer/Realm

   410     MSmlDmDDFObject& regRealm = regProxy.AddChildObjectL( KNSmlDMSIPRealm );

   411     regRealm.SetAccessTypesL( accessTypesGetReplaceAdd );

   412     regRealm.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   413     regRealm.SetScopeL( MSmlDmDDFObject::EDynamic );

   414     regRealm.SetDFFormatL( MSmlDmDDFObject::EChr );

   415     regRealm.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   416     regRealm.SetDescriptionL( KNSmlDMSIPRealmExp );

   417 

   418     // Default

   419     MSmlDmDDFObject& def = idNode.AddChildObjectL( KNSmlDMSIPDefault );

   420     def.SetAccessTypesL( accessTypesGetReplaceAdd );

   421     def.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   422     def.SetScopeL( MSmlDmDDFObject::EDynamic );

   423     def.SetDFFormatL( MSmlDmDDFObject::EBool );

   424     def.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   425     def.SetDescriptionL( KNSmlDMSIPDefaultExp );

   426 

   427     // LooseRouting

   428     MSmlDmDDFObject& lr = idNode.AddChildObjectL( KNSmlDMSIPLooseRouting );

   429     lr.SetAccessTypesL( accessTypesGetReplaceAdd );

   430     lr.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   431     lr.SetScopeL( MSmlDmDDFObject::EDynamic );

   432     lr.SetDFFormatL( MSmlDmDDFObject::EBool );

   433     lr.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   434     lr.SetDescriptionL( KNSmlDMSIPLooseRoutingExp );

   435 

   436     // EnableSecurityNegotiation

   437     MSmlDmDDFObject& enSecNeg = idNode.AddChildObjectL( 

   438         KNSmlDMSIPEnableSecurityNegotiation );

   439     enSecNeg.SetAccessTypesL( accessTypesGetReplaceAdd );

   440     enSecNeg.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   441     enSecNeg.SetScopeL( MSmlDmDDFObject::EDynamic );

   442     enSecNeg.SetDFFormatL( MSmlDmDDFObject::EBool );

   443     enSecNeg.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   444     enSecNeg.SetDescriptionL( KNSmlDMSIPEnableSecurityNegotiationExp );

   445 

   446     // EnableSigComp

   447     MSmlDmDDFObject& enSigComp = idNode.AddChildObjectL( 

   448         KNSmlDMSIPEnableSigComp );

   449     enSigComp.SetAccessTypesL( accessTypesGetReplaceAdd );

   450     enSigComp.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   451     enSigComp.SetScopeL( MSmlDmDDFObject::EDynamic );

   452     enSigComp.SetDFFormatL( MSmlDmDDFObject::EBool );

   453     enSigComp.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   454     enSigComp.SetDescriptionL( KNSmlDMSIPEnableSigCompExp );

   455 

   456     // EnableAutoRegistration

   457     MSmlDmDDFObject& enAutoReg = idNode.AddChildObjectL( 

   458         KNSmlDMSIPEnableAutoRegistration );

   459     enAutoReg.SetAccessTypesL( accessTypesGetReplaceAdd );

   460     enAutoReg.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   461     enAutoReg.SetScopeL( MSmlDmDDFObject::EDynamic );

   462     enAutoReg.SetDFFormatL( MSmlDmDDFObject::EBool );

   463     enAutoReg.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   464     enAutoReg.SetDescriptionL( KNSmlDMSIPEnableAutoRegistrationExp );

   465 

   466     // PrefConRef

   467     MSmlDmDDFObject& toNapId = idNode.AddChildObjectL( KNSmlDMSIPConRef );

   468     toNapId.SetAccessTypesL( accessTypesGetReplaceAdd );

   469     toNapId.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   470     toNapId.SetScopeL( MSmlDmDDFObject::EDynamic );

   471     toNapId.SetDFFormatL( MSmlDmDDFObject::EChr );

   472     toNapId.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   473     toNapId.SetDescriptionL( KNSmlDMSIPConRefExp );

   474 

   475     // ProfileLock

   476     MSmlDmDDFObject& profileLock = idNode.AddChildObjectL( 

   477         KNSmlDMSIPProfileLock );

   478     profileLock.SetAccessTypesL( accessTypesGetReplaceAdd );

   479     profileLock.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   480     profileLock.SetScopeL( MSmlDmDDFObject::EDynamic );

   481     profileLock.SetDFFormatL( MSmlDmDDFObject::EBool );

   482     profileLock.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   483     profileLock.SetDescriptionL( KNSmlDMSIPProfileLockExp );

   484 

   485     // DestinationNetwork

   486     MSmlDmDDFObject& toSnapId = idNode.AddChildObjectL( KNSmlDMSIPSnap );

   487     toSnapId.SetAccessTypesL( accessTypesGetReplaceAdd );

   488     toSnapId.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   489     toSnapId.SetScopeL( MSmlDmDDFObject::EDynamic );

   490     toSnapId.SetDFFormatL( MSmlDmDDFObject::EChr );

   491     toSnapId.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   492     toSnapId.SetDescriptionL( KNSmlDMSIPSnapExp );

   493 

   494     // SignalingQoS

   495     MSmlDmDDFObject& sigQos = idNode.AddChildObjectL( KNSmlDMSIPSigQos );

   496     sigQos.SetAccessTypesL( accessTypesGetReplaceAdd );

   497     sigQos.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

   498     sigQos.SetScopeL( MSmlDmDDFObject::EDynamic );

   499     sigQos.SetDFFormatL( MSmlDmDDFObject::EInt );

   500     sigQos.AddDFTypeMimeTypeL( KNSmlDMSIPTextPlain );

   501     sigQos.SetDescriptionL( KNSmlDMSIPSigQosExp );

   502 

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

   504     }

   505 

   506 // ---------------------------------------------------------------------------

   507 // CNSmlDmSIPAdapter::UpdateLeafObjectL

   508 // Updates value of a leaf object

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

   510 // ---------------------------------------------------------------------------

   511 //

   512 void CNSmlDmSIPAdapter::UpdateLeafObjectL( 

   513     const TDesC8& aURI, 

   514     const TDesC8& aLUID, 

   515     const TDesC8& aObject, 

   516     const TDesC8& /*aType*/, 

   517     const TInt aStatusRef )

   518     {

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

   520 

   521     // Load profile information if not loaded yet

   522     if ( !iProfiles )

   523         {

   524         LoadProfilesL();    

   525         }

   526 

   527     CSmlDmAdapter::TError status = EOk;

   528     TPtrC8 lastUriSeg = LastURISeg( aURI );

   529     TPtrC8 uriTmp = RemoveLastURISeg( aURI );

   530     TPtrC8 secondLastUriSeg = LastURISeg( uriTmp );

   531     TInt err ( 0 );

   532 

   533     // Check that luid mapping exist 

   534     if ( !aLUID.Length() > 0 )

   535         {

   536         iDmCallback->SetStatusL( aStatusRef,CSmlDmAdapter::EError );

   537         DBG_PRINT("CNSmlDmSIPAdapter::UpdateLeafObjectL(): no LUID, end");

   538         return;

   539         }

   540 

   541     // Find profile from array.

   542     TInt profileID = FindHexProfile ( aLUID );

   543     if ( KErrNotFound == profileID )

   544         {

   545         status = CSmlDmAdapter::ENotFound;

   546         iDmCallback->SetStatusL( aStatusRef, status );

   547         DBG_PRINT("CNSmlDmSIPAdapter::UpdateLeafObjectL(): ENotFound end");

   548         return;

   549         }

   550 

   551     // Check that profile going to be modified is not in use

   552     TBool used ( iSIPManagedProfileRegistry->IsInUseL ( 

   553         *iProfiles->At ( profileID )));

   554     if ( used )

   555         {

   556         status = CSmlDmAdapter::EObjectInUse;

   557         iDmCallback->SetStatusL( aStatusRef, status );

   558         DBG_PRINT("CNSmlDmSIPAdapter::UpdateLeafObjectL(): EObjectInUse end");

   559         return;

   560         }

   561 

   562     // Check that profile is not allready to be saved.

   563     if ( KErrNotFound == iModifications.Find( profileID ) )

   564         {

   565         iModifications.Insert( profileID, iModifications.Count() );

   566         }

   567 

   568     // ==============================

   569     // SIP/x/ node

   570     // ==============================

   571     //

   572 

   573     // SIP/x/Name    

   574     if ( KNSmlDMSIPName() == lastUriSeg )  

   575         {

   576         if ( aObject.Length() < KMaxProviderNameLength )

   577             {

   578             err = iProfiles->At( profileID )->SetParameter( 

   579                 KSIPProviderName, aObject );

   580             CheckDuplicateNameL( *iProfiles->At( profileID ), profileID );

   581             }

   582         else

   583             {

   584             status = CSmlDmAdapter::EInvalidObject;

   585             }

   586         }

   587 

   588     // SIP/x/ProfileType      

   589     if ( KNSmlDMSIPProfileType() == lastUriSeg )  

   590         {

   591         RArray<TSIPProfileTypeInfo> profileTypes;

   592         CleanupClosePushL( profileTypes ); // CS:1

   593 

   594          // Get the supported profile types

   595         iSIPManagedProfileRegistry->SupportedProfileTypesL( profileTypes );

   596 

   597         TSIPProfileTypeInfo type;

   598         if ( KPTypeIMS() == aObject )

   599             {

   600             type.iSIPProfileClass = TSIPProfileTypeInfo::EIms;

   601             type.iSIPProfileName = KPTypeIMS;

   602             if ( KErrNotFound != profileTypes.Find( type ) )

   603                 {

   604                 iProfiles->At( profileID )->SetType( type ); 

   605                 }

   606             else

   607                 {

   608                 status = CSmlDmAdapter::EInvalidObject;

   609                 }

   610             }

   611         else if ( KPTypeIETF() == aObject )

   612             {

   613             type.iSIPProfileClass = TSIPProfileTypeInfo::EInternet;

   614             type.iSIPProfileName = KPTypeIETF;

   615             if ( KErrNotFound != profileTypes.Find( type ) )

   616                 {

   617                 iProfiles->At( profileID )->SetType( type ); 

   618                 }

   619             else

   620                 {

   621                 status = CSmlDmAdapter::EInvalidObject;

   622                 }

   623             }

   624         else if ( KPTypeOther() == aObject )

   625             {

   626             type.iSIPProfileClass = TSIPProfileTypeInfo::EOther;

   627             type.iSIPProfileName = KPTypeOther;

   628             if ( KErrNotFound != profileTypes.Find( type ) )

   629                 {

   630                 iProfiles->At( profileID )->SetType( type ); 

   631                 }

   632             else

   633                 {

   634                 status = CSmlDmAdapter::EInvalidObject;

   635                 }

   636             }

   637         else

   638             {

   639             status = CSmlDmAdapter::EInvalidObject;

   640             } 

   641         CleanupStack::PopAndDestroy( &profileTypes ); // CS:0

   642         }

   643 

   644     // SIP/x/AddressOfRecord      

   645     if ( KNSmlDMSIPAOR() == lastUriSeg )  

   646         {

   647         // Supports one AOR for profile.

   648 

   649         if ( KErrNotFound == aObject.Find( KEscaped() ) )

   650             {

   651             HBufC8* encoded = EscapeUtils::EscapeEncodeL( aObject,

   652                 EscapeUtils::EEscapeNormal );

   653             err = iProfiles->At( profileID )->SetParameter( KSIPUserAor,

   654                 *encoded );

   655             delete encoded;

   656             }

   657         else

   658             {

   659             err = iProfiles->At( profileID )->SetParameter( 

   660                 KSIPUserAor, aObject );

   661             }

   662         }

   663 

   664     // SIP/x/Default

   665     // Only setting as True allowed. SIP stack sets other profiles as False.

   666     if ( KNSmlDMSIPDefault() == lastUriSeg )  

   667         {

   668         if ( KNSmlDMSIPValueTrue() == aObject )

   669             {

   670             err = iProfiles->At( profileID )->SetParameter( 

   671                 KSIPDefaultProfile, ETrue );

   672             }

   673         else

   674             {

   675             status = CSmlDmAdapter::EInvalidObject;    

   676             } 

   677         }

   678 

   679     // SIP/x/LooseRouting

   680     if ( KNSmlDMSIPLooseRouting() == lastUriSeg )

   681         {

   682         // get OutboundProxy SIP uri.

   683         const TDesC8* uri = 0;

   684         iProfiles->At( profileID )->GetParameter( KSIPOutboundProxy, 

   685             KSIPServerAddress, uri );

   686         TUriParser8 parser;

   687         err = parser.Parse( *uri );

   688 

   689         TBuf8<KUriPathMaxLength> tempPathLr;

   690 

   691         CUri8* tempUri = CUri8::NewLC( parser );

   692         tempPathLr.Copy( tempUri->Uri().Extract( EUriPath ) );

   693         tempPathLr.LowerCase();

   694 

   695 

   696         if ( KNSmlDMSIPValueTrue() == aObject )

   697             {

   698             if ( KErrNotFound == tempPathLr.Find( KSIPlr ) )

   699                 {

   700                 tempPathLr.Append( KSIPlr );

   701                 tempUri->SetComponentL( tempPathLr, EUriPath );

   702                 }

   703             }

   704 

   705         else if ( KNSmlDMSIPValueFalse() == aObject )

   706             {

   707             TInt pos = tempPathLr.Find( KSIPlr );

   708             if ( KErrNotFound != pos )

   709                 {

   710                 tempPathLr.Delete( pos, KSIPlr().Length() );

   711                 tempUri->SetComponentL( tempPathLr, EUriPath );

   712                 }

   713             }

   714         else

   715             {

   716             status = CSmlDmAdapter::EInvalidObject;

   717             }

   718 

   719         // Set tempUri back to original sipURI if it validates.

   720         if ( status == CSmlDmAdapter::EOk )

   721             {

   722             // Set outboundproxy parameters according to sipURI.

   723             err = iProfiles->At( profileID )->SetParameter( KSIPOutboundProxy,

   724                 KSIPServerAddress, tempUri->Uri().UriDes() );

   725             }

   726         else

   727             {

   728             status = CSmlDmAdapter::EInvalidObject;

   729             }

   730         CleanupStack::PopAndDestroy( tempUri );

   731         }

   732 

   733     // SIP/x/EnableSecurityNegotiation

   734     if ( KNSmlDMSIPEnableSecurityNegotiation() == lastUriSeg )

   735         {

   736         if ( KNSmlDMSIPValueTrue() == aObject )

   737             {

   738             err = iProfiles->At( profileID )->SetParameter( 

   739                 KSIPSecurityNegotiation, ETrue );

   740             }

   741         else if ( KNSmlDMSIPValueFalse() == aObject )

   742             {

   743             err = iProfiles->At( profileID )->SetParameter( 

   744                 KSIPSecurityNegotiation, EFalse );

   745             }

   746         else

   747             {

   748             status = CSmlDmAdapter::EInvalidObject;

   749             } 

   750         }

   751 

   752     // SIP/x/EnableSigComp

   753     if ( KNSmlDMSIPEnableSigComp() == lastUriSeg )

   754         {

   755         if ( aObject == KNSmlDMSIPValueTrue )

   756             {

   757             err = iProfiles->At( profileID )->SetParameter( 

   758                 KSIPSigComp, ETrue );

   759             }

   760         else if ( aObject == KNSmlDMSIPValueFalse )

   761             {

   762             err = iProfiles->At( profileID )->SetParameter( 

   763                 KSIPSigComp, EFalse );

   764             }

   765         else

   766             {

   767             status = CSmlDmAdapter::EInvalidObject;

   768             } 

   769         }

   770 

   771     // SIP/x/EnableAutoRegistration

   772     if ( KNSmlDMSIPEnableAutoRegistration() == lastUriSeg )

   773         {

   774         if ( KNSmlDMSIPValueTrue() == aObject )

   775             {

   776             err = iProfiles->At( profileID )->SetParameter( 

   777                 KSIPAutoRegistration, ETrue );

   778             }

   779         else if ( KNSmlDMSIPValueFalse() == aObject )

   780             {

   781             err = iProfiles->At( profileID )->SetParameter( 

   782                 KSIPAutoRegistration, EFalse );

   783             }

   784         else

   785             {

   786             status = CSmlDmAdapter::EInvalidObject;

   787             } 

   788         }

   789 

   790     // SIP/x/PrefConRef

   791     if ( KNSmlDMSIPConRef() == lastUriSeg )

   792         {

   793         TInt lIAPId = SetConRefL( aObject, profileID ); // IAPid from CommsDB.

   794         if ( lIAPId != KErrNotFound )

   795             {

   796             status = CSmlDmAdapter::EOk;       

   797             }

   798         else

   799             {

   800             status = CSmlDmAdapter::EInvalidObject;

   801             }

   802         } 

   803 

   804     // SIP/x/ProfileLock

   805     if ( KNSmlDMSIPProfileLock() == lastUriSeg )

   806         {

   807         if ( KNSmlDMSIPValueTrue() == aObject )

   808             {

   809             err = iProfiles->At( profileID )->SetParameter( 

   810                 KSIPProfileLocked, ETrue );

   811             }

   812         else if ( KNSmlDMSIPValueFalse() == aObject )

   813             {

   814             err = iProfiles->At( profileID )->SetParameter( 

   815                 KSIPProfileLocked, EFalse );

   816             }

   817         else

   818             {

   819             status = CSmlDmAdapter::EInvalidObject;

   820             } 

   821         }

   822 

   823     // SIP/x/DestinationNetwork

   824     if ( KNSmlDMSIPSnap() == lastUriSeg )

   825         {

   826         TUint32 snapId = SnapIdL( aObject );

   827         if ( snapId )

   828             {

   829             err = iProfiles->At( profileID )->SetParameter( 

   830                 KSIPSnapId, snapId );

   831             }

   832         else

   833             {

   834             status = CSmlDmAdapter::EInvalidObject;

   835             }

   836         }

   837     // SIP/x/SignalingQoS

   838     if ( KNSmlDMSIPSigQos() == lastUriSeg )

   839         {

   840         TUint32 sigQos = DesToInt( aObject );

   841         if ( sigQos <= KMaxSigQosValue )

   842             {

   843             // We need to do bitshifting on the IP TOS, because it's the

   844             // upper 6 bits that are set and settings provide us the IP TOS as

   845             // the lower 6 bits. The lower 2 bits are reserver for explicit

   846             // congestion notification.

   847             // See also more from:

   848             // Symbian DevLib / in_sock.h Global variables / KSoIpTOS

   849             sigQos <<= 2;

   850             err = iProfiles->At( profileID )->SetParameter( 

   851                 KSIPSoIpTOS, sigQos );

   852             }

   853         else

   854             {

   855             status = CSmlDmAdapter::EInvalidObject;

   856             }

   857         }

   858 

   859     // ==============================

   860     // OutboundProxy settings node

   861     // ==============================

   862     //

   863 

   864     // SIP/x/OutboundProxy

   865     if ( KNSmlDMSIPOutboundProxy() == secondLastUriSeg )  

   866         {

   867         status = UpdateOutboundProxyNodeL( profileID, lastUriSeg, aObject );

   868         }

   869 

   870     // ==============================

   871     // RegistrarServer settings node

   872     // ==============================

   873     //

   874     

   875     // SIP/x/RegistrarServer

   876     if ( KNSmlDMSIPRegistrarServer() == secondLastUriSeg )  

   877         {

   878         status = UpdateRegistrarServerNodeL( profileID, lastUriSeg, aObject );

   879         }

   880 

   881     if ( err )

   882         {

   883         status = CSmlDmAdapter::EError;

   884         }

   885 

   886     iDmCallback->SetStatusL( aStatusRef, status );

   887     DBG_PRINT("CNSmlDmSIPAdapter::UpdateLeafObjectL(): end");

   888     }

   889 

   890 // ---------------------------------------------------------------------------

   891 // CNSmlDmSIPAdapter::DeleteObjectL

   892 // Deletes SIP profiles.

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

   894 // ---------------------------------------------------------------------------

   895 //

   896 void CNSmlDmSIPAdapter::DeleteObjectL( 

   897     const TDesC8& aURI, 

   898     const TDesC8& aLUID, 

   899     const TInt aStatusRef )

   900     {

   901     DBG_PRINT("CNSmlDmSIPAdapter::DeleteObjectL(): begin");

   902 

   903      // Load profile information if not loaded yet

   904     if ( !iProfiles )

   905         {

   906         LoadProfilesL();

   907         }

   908 

   909     CSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk;

   910     TBuf8 <KNSmlSIPMaxUriLength> uri = aURI;

   911 

   912     // Copy LUID as last segment if exists.

   913     if ( 0 != aLUID.Length() )

   914         {

   915         uri.Copy( aLUID );

   916         }

   917     else 

   918         {

   919         retValue = CSmlDmAdapter::ENotFound;

   920         }

   921         

   922     if ( aLUID.Length() > 0 && NumOfURISegs( aURI ) == 2 )

   923         {

   924         TInt profileID = FindHexProfile( uri );

   925 

   926         if ( KErrNotFound == profileID )

   927             {

   928             retValue = CSmlDmAdapter::ENotFound;

   929             iDmCallback->SetStatusL( aStatusRef, retValue );

   930             DBG_PRINT("CNSmlDmSIPAdapter::DeleteObjectL(): ENotFound end");

   931             return;

   932             }

   933 

   934         // Delete allowed only if profile is not registered.

   935         TBool registered( EFalse );

   936         iProfiles->At( profileID )->GetParameter( 

   937             KSIPProfileRegistered, registered );

   938 

   939         if ( !registered )

   940             {

   941             // Delete profile from permanent store.

   942             iSIPManagedProfileRegistry->DestroyL( 

   943                 *iProfiles->At( profileID ) );

   944 

   945             // Delete profile also from memory and compress array.

   946             delete iProfiles->At( profileID );

   947             iProfiles->Delete( profileID );

   948             iProfiles->Compress();

   949             retValue = CSmlDmAdapter::EOk;

   950             }

   951         else

   952             {

   953             retValue = CSmlDmAdapter::EObjectInUse;

   954             }

   955         }

   956     else

   957         {

   958         retValue = CSmlDmAdapter::EInvalidObject;

   959         }

   960     iDmCallback->SetStatusL( aStatusRef, retValue );

   961     DBG_PRINT("CNSmlDmSIPAdapter::DeleteObjectL(): end");

   962     }

   963 

   964 // ---------------------------------------------------------------------------

   965 // CNSmlDmSIPAdapter::FetchLeafObjectL

   966 // Fetches the values of leaf objects.

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

   968 // ---------------------------------------------------------------------------

   969 //

   970 void CNSmlDmSIPAdapter::FetchLeafObjectL( 

   971     const TDesC8& aURI, 

   972     const TDesC8& aLUID, 

   973     const TDesC8& aType, 

   974     const TInt aResultsRef, 

   975     const TInt aStatusRef )

   976     {

   977     DBG_PRINT("CNSmlDmSIPAdapter::FetchLeafObjectL(): begin");

   978 

   979     // Load profile information if not loaded yet.

   980     if ( !iProfiles )

   981         {

   982         LoadProfilesL();

   983         }

   984 

   985     CBufBase *result = CBufFlat::NewL( KDefaultResultSize );

   986     CleanupStack::PushL( result );

   987     CSmlDmAdapter::TError status = FetchObjectL( aURI, aLUID, *result );

   988 

   989     if ( status == CSmlDmAdapter::EOk )

   990         {

   991         iDmCallback->SetResultsL( aResultsRef, *result, aType );

   992         }

   993     iDmCallback->SetStatusL( aStatusRef, status );

   994 

   995     CleanupStack::PopAndDestroy( result );

   996     DBG_PRINT("CNSmlDmSIPAdapter::FetchLeafObjectL(): end");

   997     }

   998 

   999 // ---------------------------------------------------------------------------

  1000 // CNSmlDmSIPAdapter::FetchObjectL

  1001 // Fetches the values of leaf objects.

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

  1003 // ---------------------------------------------------------------------------

  1004 //

  1005 CSmlDmAdapter::TError CNSmlDmSIPAdapter::FetchObjectL( 

  1006     const TDesC8& aURI, 

  1007     const TDesC8& aLUID,

  1008     CBufBase& aResult )

  1009     {

  1010     DBG_PRINT("CNSmlDmSIPAdapter::FetchObjectL(): begin");

  1011     CSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk;

  1012 

  1013     // Check that luid mapping exist 

  1014     if ( !aLUID.Length() > 0 )

  1015         {

  1016         DBG_PRINT("CNSmlDmSIPAdapter::FetchObjectL: ENotFound end");

  1017         return CSmlDmAdapter::ENotFound;

  1018         }

  1019 

  1020     TBuf8<KNSmlSIPMaxResultLength> segmentResult;

  1021     TInt err ( 0 );

  1022 

  1023     const TDesC8* paramResult = 0;

  1024     TBool boolVal ( EFalse );

  1025 

  1026     TPtrC8 lastUriSeg = LastURISeg( aURI );

  1027     TPtrC8 uriTmp = RemoveLastURISeg( aURI );

  1028     TPtrC8 secondLastUriSeg = LastURISeg( uriTmp );

  1029 

  1030     // Find profile from iProfiles. If not found, set error.

  1031     TInt profileID = FindHexProfile ( aLUID );

  1032     if ( KErrNotFound == profileID )

  1033         {

  1034         retValue = CSmlDmAdapter::ENotFound;

  1035         DBG_PRINT("CNSmlDmSIPAdapter::FetchObjectL: ENotFound end");

  1036         return retValue;

  1037         }

  1038 

  1039     // SIP/x/SIPId

  1040     if ( KNSmlDMSIPSipID() == lastUriSeg ) 

  1041         {

  1042         TUint32 val( 0 );

  1043         err = iProfiles->At( profileID )->GetParameter( KSIPProfileId, val );

  1044         segmentResult.Num( val );

  1045         }

  1046 

  1047     // SIP/x/Provider

  1048     if ( KNSmlDMSIPName() == lastUriSeg )

  1049         {

  1050         err = iProfiles->At( profileID )->

  1051             GetParameter( KSIPProviderName, paramResult );

  1052         segmentResult.Copy( *paramResult );

  1053         }

  1054 

  1055     // SIP/x/Type

  1056     if ( KNSmlDMSIPProfileType() == lastUriSeg )

  1057         {

  1058         TSIPProfileTypeInfo type;

  1059         type = iProfiles->At( profileID )->Type();

  1060         if ( type.iSIPProfileClass == TSIPProfileTypeInfo::EIms )

  1061             {

  1062             segmentResult.Copy( KPTypeIMS );

  1063             }

  1064         if ( type.iSIPProfileClass == TSIPProfileTypeInfo::EInternet )

  1065             {

  1066             segmentResult.Copy( KPTypeIETF );

  1067             }

  1068         if ( type.iSIPProfileClass == TSIPProfileTypeInfo::EOther )

  1069             {

  1070             segmentResult.Copy( KPTypeOther );

  1071             }

  1072         }

  1073 

  1074     // SIP/x/ProfileLock

  1075     if ( KNSmlDMSIPProfileLock() == lastUriSeg )

  1076         {

  1077         TBool boolVal( EFalse );

  1078         err = iProfiles->At( profileID )->GetParameter( 

  1079             KSIPProfileLocked, boolVal );

  1080         if ( boolVal )

  1081             {

  1082             segmentResult.Copy( KNSmlDMSIPValueTrue );

  1083             }

  1084         else

  1085             {

  1086             segmentResult.Copy( KNSmlDMSIPValueFalse );

  1087             } 

  1088         }

  1089 

  1090     // SIP/x/AddressOfRecord

  1091     if ( KNSmlDMSIPAOR() == lastUriSeg ) 

  1092         {

  1093         // Supports one AOR for profile.

  1094         err = iProfiles->At( profileID )->GetParameter( 

  1095             KSIPUserAor, paramResult );

  1096         segmentResult.Copy( *paramResult );

  1097         }

  1098 

  1099     // SIP/x/OutboundProxy

  1100     if ( KNSmlDMSIPOutboundProxy() == secondLastUriSeg )  

  1101         {

  1102         retValue = FetchOutboundProxyNodeL( profileID, lastUriSeg, 

  1103             segmentResult );

  1104         } 

  1105 

  1106     // SIP/x/RegistrarServer

  1107     if ( KNSmlDMSIPRegistrarServer() == secondLastUriSeg )

  1108         {

  1109         retValue = FetchRegistrarServerNodeL( profileID, lastUriSeg, 

  1110             segmentResult );

  1111         }  

  1112 

  1113     // SIP/x/Default

  1114     if ( KNSmlDMSIPDefault() == lastUriSeg )

  1115         {

  1116         err = iProfiles->At( profileID )->GetParameter( 

  1117             KSIPDefaultProfile, boolVal );

  1118         if ( boolVal )

  1119             {

  1120             segmentResult.Copy( KNSmlDMSIPValueTrue );

  1121             }

  1122         else

  1123             {

  1124             segmentResult.Copy( KNSmlDMSIPValueFalse );

  1125             }

  1126         }

  1127 

  1128     // SIP/x/LooseRouting

  1129     if ( KNSmlDMSIPLooseRouting() == lastUriSeg )

  1130         {

  1131         // Get OutboundProxy SIP uri.

  1132         const TDesC8* uri = 0;

  1133         err = iProfiles->At( profileID )->GetParameter( 

  1134             KSIPOutboundProxy, KSIPServerAddress, uri );