--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/sipplugins/sippdevmgmtsipadapter/src/nsmldmsipadapter.cpp Tue Feb 02 01:03:15 2010 +0200
@@ -0,0 +1,2949 @@
+/*
+* 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 );
+ TPtrC8 uriTmp = RemoveLastURISeg( aURI );
+ TPtrC8 secondLastUriSeg = LastURISeg( uriTmp );
+ TInt err ( 0 );
+
+ // Check that luid mapping exist
+ if ( !aLUID.Length() > 0 )
+ {
+ iDmCallback->SetStatusL( aStatusRef,CSmlDmAdapter::EError );
+ DBG_PRINT("CNSmlDmSIPAdapter::UpdateLeafObjectL(): no LUID, end");
+ return;
+ }
+
+ // Find profile from array.
+ TInt profileID = FindHexProfile ( aLUID );
+ if ( KErrNotFound == profileID )
+ {
+ status = CSmlDmAdapter::ENotFound;
+ iDmCallback->SetStatusL( aStatusRef, status );
+ DBG_PRINT("CNSmlDmSIPAdapter::UpdateLeafObjectL(): ENotFound end");
+ return;
+ }
+
+ // Check that profile going to be modified is not in use
+ TBool used ( iSIPManagedProfileRegistry->IsInUseL (
+ *iProfiles->At ( profileID )));
+ if ( used )
+ {
+ status = CSmlDmAdapter::EObjectInUse;
+ iDmCallback->SetStatusL( aStatusRef, status );
+ DBG_PRINT("CNSmlDmSIPAdapter::UpdateLeafObjectL(): EObjectInUse end");
+ return;
+ }
+
+ // Check that profile is not allready to be saved.
+ if ( KErrNotFound == iModifications.Find( profileID ) )
+ {
+ iModifications.Insert( profileID, iModifications.Count() );
+ }
+
+ // ==============================
+ // SIP/x/ node
+ // ==============================
+ //
+
+ // SIP/x/Name
+ if ( KNSmlDMSIPName() == lastUriSeg )
+ {
+ if ( aObject.Length() < KMaxProviderNameLength )
+ {
+ err = iProfiles->At( profileID )->SetParameter(
+ KSIPProviderName, aObject );
+ CheckDuplicateNameL( *iProfiles->At( profileID ), profileID );
+ }
+ else
+ {
+ status = CSmlDmAdapter::EInvalidObject;
+ }
+ }
+
+ // SIP/x/ProfileType
+ if ( KNSmlDMSIPProfileType() == lastUriSeg )
+ {
+ RArray<TSIPProfileTypeInfo> profileTypes;
+ CleanupClosePushL( profileTypes ); // CS:1
+
+ // Get the supported profile types
+ iSIPManagedProfileRegistry->SupportedProfileTypesL( profileTypes );
+
+ TSIPProfileTypeInfo type;
+ if ( KPTypeIMS() == aObject )
+ {
+ type.iSIPProfileClass = TSIPProfileTypeInfo::EIms;
+ type.iSIPProfileName = KPTypeIMS;
+ if ( KErrNotFound != profileTypes.Find( type ) )
+ {
+ iProfiles->At( profileID )->SetType( type );
+ }
+ else
+ {
+ status = CSmlDmAdapter::EInvalidObject;
+ }
+ }
+ else if ( KPTypeIETF() == aObject )
+ {
+ type.iSIPProfileClass = TSIPProfileTypeInfo::EInternet;
+ type.iSIPProfileName = KPTypeIETF;
+ if ( KErrNotFound != profileTypes.Find( type ) )
+ {
+ iProfiles->At( profileID )->SetType( type );
+ }
+ else
+ {
+ status = CSmlDmAdapter::EInvalidObject;
+ }
+ }
+ else if ( KPTypeOther() == aObject )
+ {
+ type.iSIPProfileClass = TSIPProfileTypeInfo::EOther;
+ type.iSIPProfileName = KPTypeOther;
+ if ( KErrNotFound != profileTypes.Find( type ) )
+ {
+ iProfiles->At( profileID )->SetType( type );
+ }
+ else
+ {
+ status = CSmlDmAdapter::EInvalidObject;
+ }
+ }
+ else
+ {
+ status = CSmlDmAdapter::EInvalidObject;
+ }
+ CleanupStack::PopAndDestroy( &profileTypes ); // CS:0
+ }
+
+ // SIP/x/AddressOfRecord
+ if ( KNSmlDMSIPAOR() == lastUriSeg )
+ {
+ // Supports one AOR for profile.
+
+ if ( KErrNotFound == aObject.Find( KEscaped() ) )
+ {
+ HBufC8* encoded = EscapeUtils::EscapeEncodeL( aObject,
+ EscapeUtils::EEscapeNormal );
+ err = iProfiles->At( profileID )->SetParameter( KSIPUserAor,
+ *encoded );
+ delete encoded;
+ }
+ else
+ {
+ err = iProfiles->At( profileID )->SetParameter(
+ KSIPUserAor, aObject );
+ }
+ }
+
+ // SIP/x/Default
+ // Only setting as True allowed. SIP stack sets other profiles as False.
+ if ( KNSmlDMSIPDefault() == lastUriSeg )
+ {
+ if ( KNSmlDMSIPValueTrue() == aObject )
+ {
+ err = iProfiles->At( profileID )->SetParameter(
+ KSIPDefaultProfile, ETrue );
+ }
+ else
+ {
+ status = CSmlDmAdapter::EInvalidObject;
+ }
+ }
+
+ // SIP/x/LooseRouting
+ if ( KNSmlDMSIPLooseRouting() == lastUriSeg )
+ {
+ // get OutboundProxy SIP uri.
+ const TDesC8* uri = 0;
+ iProfiles->At( profileID )->GetParameter( KSIPOutboundProxy,
+ KSIPServerAddress, uri );
+ TUriParser8 parser;
+ err = parser.Parse( *uri );
+
+ TBuf8<KUriPathMaxLength> tempPathLr;
+
+ CUri8* tempUri = CUri8::NewLC( parser );
+ tempPathLr.Copy( tempUri->Uri().Extract( EUriPath ) );
+ tempPathLr.LowerCase();
+
+
+ if ( KNSmlDMSIPValueTrue() == aObject )
+ {
+ if ( KErrNotFound == tempPathLr.Find( KSIPlr ) )
+ {
+ tempPathLr.Append( KSIPlr );
+ tempUri->SetComponentL( tempPathLr, EUriPath );
+ }
+ }
+
+ else if ( KNSmlDMSIPValueFalse() == aObject )
+ {
+ TInt pos = tempPathLr.Find( KSIPlr );
+ if ( KErrNotFound != pos )
+ {
+ tempPathLr.Delete( pos, KSIPlr().Length() );
+ tempUri->SetComponentL( tempPathLr, EUriPath );
+ }
+ }
+ else
+ {
+ status = CSmlDmAdapter::EInvalidObject;
+ }
+
+ // Set tempUri back to original sipURI if it validates.
+ if ( status == CSmlDmAdapter::EOk )
+ {
+ // Set outboundproxy parameters according to sipURI.
+ err = iProfiles->At( profileID )->SetParameter( KSIPOutboundProxy,
+ KSIPServerAddress, tempUri->Uri().UriDes() );
+ }
+ else
+ {
+ status = CSmlDmAdapter::EInvalidObject;
+ }
+ CleanupStack::PopAndDestroy( tempUri );
+ }
+
+ // SIP/x/EnableSecurityNegotiation
+ if ( KNSmlDMSIPEnableSecurityNegotiation() == lastUriSeg )
+ {
+ if ( KNSmlDMSIPValueTrue() == aObject )
+ {
+ err = iProfiles->At( profileID )->SetParameter(
+ KSIPSecurityNegotiation, ETrue );
+ }
+ else if ( KNSmlDMSIPValueFalse() == aObject )
+ {
+ err = iProfiles->At( profileID )->SetParameter(
+ KSIPSecurityNegotiation, EFalse );
+ }
+ else
+ {
+ status = CSmlDmAdapter::EInvalidObject;
+ }
+ }
+
+ // SIP/x/EnableSigComp
+ if ( KNSmlDMSIPEnableSigComp() == lastUriSeg )
+ {
+ if ( aObject == KNSmlDMSIPValueTrue )
+ {
+ err = iProfiles->At( profileID )->SetParameter(
+ KSIPSigComp, ETrue );
+ }
+ else if ( aObject == KNSmlDMSIPValueFalse )
+ {
+ err = iProfiles->At( profileID )->SetParameter(
+ KSIPSigComp, EFalse );
+ }
+ else
+ {
+ status = CSmlDmAdapter::EInvalidObject;
+ }
+ }
+
+ // SIP/x/EnableAutoRegistration
+ if ( KNSmlDMSIPEnableAutoRegistration() == lastUriSeg )
+ {
+ if ( KNSmlDMSIPValueTrue() == aObject )
+ {
+ err = iProfiles->At( profileID )->SetParameter(
+ KSIPAutoRegistration, ETrue );
+ }
+ else if ( KNSmlDMSIPValueFalse() == aObject )
+ {
+ err = iProfiles->At( profileID )->SetParameter(
+ KSIPAutoRegistration, EFalse );
+ }
+ else
+ {
+ status = CSmlDmAdapter::EInvalidObject;
+ }
+ }
+
+ // SIP/x/PrefConRef
+ if ( KNSmlDMSIPConRef() == lastUriSeg )
+ {
+ TInt lIAPId = SetConRefL( aObject, profileID ); // IAPid from CommsDB.
+ if ( lIAPId != KErrNotFound )
+ {
+ status = CSmlDmAdapter::EOk;
+ }
+ else
+ {
+ status = CSmlDmAdapter::EInvalidObject;
+ }
+ }
+
+ // SIP/x/ProfileLock
+ if ( KNSmlDMSIPProfileLock() == lastUriSeg )
+ {
+ if ( KNSmlDMSIPValueTrue() == aObject )
+ {
+ err = iProfiles->At( profileID )->SetParameter(
+ KSIPProfileLocked, ETrue );
+ }
+ else if ( KNSmlDMSIPValueFalse() == aObject )
+ {
+ err = iProfiles->At( profileID )->SetParameter(
+ KSIPProfileLocked, EFalse );
+ }
+ else
+ {
+ status = CSmlDmAdapter::EInvalidObject;
+ }
+ }
+
+ // SIP/x/DestinationNetwork
+ if ( KNSmlDMSIPSnap() == lastUriSeg )
+ {
+ TUint32 snapId = SnapIdL( aObject );
+ if ( snapId )
+ {
+ err = iProfiles->At( profileID )->SetParameter(
+ KSIPSnapId, snapId );
+ }
+ else
+ {
+ status = CSmlDmAdapter::EInvalidObject;
+ }
+ }
+ // SIP/x/SignalingQoS
+ if ( KNSmlDMSIPSigQos() == lastUriSeg )
+ {
+ TUint32 sigQos = DesToInt( aObject );
+ if ( sigQos <= KMaxSigQosValue )
+ {
+ // We need to do bitshifting on the IP TOS, because it's the
+ // upper 6 bits that are set and settings provide us the IP TOS as
+ // the lower 6 bits. The lower 2 bits are reserver for explicit
+ // congestion notification.
+ // See also more from:
+ // Symbian DevLib / in_sock.h Global variables / KSoIpTOS
+ sigQos <<= 2;
+ err = iProfiles->At( profileID )->SetParameter(
+ KSIPSoIpTOS, sigQos );
+ }
+ else
+ {
+ status = CSmlDmAdapter::EInvalidObject;
+ }
+ }
+
+ // ==============================
+ // OutboundProxy settings node
+ // ==============================
+ //
+
+ // SIP/x/OutboundProxy
+ if ( KNSmlDMSIPOutboundProxy() == secondLastUriSeg )
+ {
+ status = UpdateOutboundProxyNodeL( profileID, lastUriSeg, aObject );
+ }
+
+ // ==============================
+ // RegistrarServer settings node
+ // ==============================
+ //
+
+ // SIP/x/RegistrarServer
+ if ( KNSmlDMSIPRegistrarServer() == secondLastUriSeg )
+ {
+ status = UpdateRegistrarServerNodeL( profileID, lastUriSeg, aObject );
+ }
+
+ if ( err )
+ {
+ status = CSmlDmAdapter::EError;
+ }
+
+ iDmCallback->SetStatusL( aStatusRef, status );
+ DBG_PRINT("CNSmlDmSIPAdapter::UpdateLeafObjectL(): end");
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::DeleteObjectL
+// Deletes SIP profiles.
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+void CNSmlDmSIPAdapter::DeleteObjectL(
+ const TDesC8& aURI,
+ const TDesC8& aLUID,
+ const TInt aStatusRef )
+ {
+ DBG_PRINT("CNSmlDmSIPAdapter::DeleteObjectL(): begin");
+
+ // Load profile information if not loaded yet
+ if ( !iProfiles )
+ {
+ LoadProfilesL();
+ }
+
+ CSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk;
+ TBuf8 <KNSmlSIPMaxUriLength> uri = aURI;
+
+ // Copy LUID as last segment if exists.
+ if ( 0 != aLUID.Length() )
+ {
+ uri.Copy( aLUID );
+ }
+ else
+ {
+ retValue = CSmlDmAdapter::ENotFound;
+ }
+
+ if ( aLUID.Length() > 0 && NumOfURISegs( aURI ) == 2 )
+ {
+ TInt profileID = FindHexProfile( uri );
+
+ if ( KErrNotFound == profileID )
+ {
+ retValue = CSmlDmAdapter::ENotFound;
+ iDmCallback->SetStatusL( aStatusRef, retValue );
+ DBG_PRINT("CNSmlDmSIPAdapter::DeleteObjectL(): ENotFound end");
+ return;
+ }
+
+ // Delete allowed only if profile is not registered.
+ TBool registered( EFalse );
+ iProfiles->At( profileID )->GetParameter(
+ KSIPProfileRegistered, registered );
+
+ if ( !registered )
+ {
+ // Delete profile from permanent store.
+ iSIPManagedProfileRegistry->DestroyL(
+ *iProfiles->At( profileID ) );
+
+ // Delete profile also from memory and compress array.
+ delete iProfiles->At( profileID );
+ iProfiles->Delete( profileID );
+ iProfiles->Compress();
+ retValue = CSmlDmAdapter::EOk;
+ }
+ else
+ {
+ retValue = CSmlDmAdapter::EObjectInUse;
+ }
+ }
+ else
+ {
+ retValue = CSmlDmAdapter::EInvalidObject;
+ }
+ iDmCallback->SetStatusL( aStatusRef, retValue );
+ DBG_PRINT("CNSmlDmSIPAdapter::DeleteObjectL(): end");
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::FetchLeafObjectL
+// Fetches the values of leaf objects.
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+void CNSmlDmSIPAdapter::FetchLeafObjectL(
+ const TDesC8& aURI,
+ const TDesC8& aLUID,
+ const TDesC8& aType,
+ const TInt aResultsRef,
+ const TInt aStatusRef )
+ {
+ DBG_PRINT("CNSmlDmSIPAdapter::FetchLeafObjectL(): begin");
+
+ // Load profile information if not loaded yet.
+ if ( !iProfiles )
+ {
+ LoadProfilesL();
+ }
+
+ CBufBase *result = CBufFlat::NewL( KDefaultResultSize );
+ CleanupStack::PushL( result );
+ CSmlDmAdapter::TError status = FetchObjectL( aURI, aLUID, *result );
+
+ if ( status == CSmlDmAdapter::EOk )
+ {
+ iDmCallback->SetResultsL( aResultsRef, *result, aType );
+ }
+ iDmCallback->SetStatusL( aStatusRef, status );
+
+ CleanupStack::PopAndDestroy( result );
+ DBG_PRINT("CNSmlDmSIPAdapter::FetchLeafObjectL(): end");
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::FetchObjectL
+// Fetches the values of leaf objects.
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+CSmlDmAdapter::TError CNSmlDmSIPAdapter::FetchObjectL(
+ const TDesC8& aURI,
+ const TDesC8& aLUID,
+ CBufBase& aResult )
+ {
+ DBG_PRINT("CNSmlDmSIPAdapter::FetchObjectL(): begin");
+ CSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk;
+
+ // Check that luid mapping exist
+ if ( !aLUID.Length() > 0 )
+ {
+ DBG_PRINT("CNSmlDmSIPAdapter::FetchObjectL: ENotFound end");
+ return CSmlDmAdapter::ENotFound;
+ }
+
+ TBuf8<KNSmlSIPMaxResultLength> segmentResult;
+ TInt err ( 0 );
+
+ const TDesC8* paramResult = 0;
+ TBool boolVal ( EFalse );
+
+ TPtrC8 lastUriSeg = LastURISeg( aURI );
+ TPtrC8 uriTmp = RemoveLastURISeg( aURI );
+ TPtrC8 secondLastUriSeg = LastURISeg( uriTmp );
+
+ // Find profile from iProfiles. If not found, set error.
+ TInt profileID = FindHexProfile ( aLUID );
+ if ( KErrNotFound == profileID )
+ {
+ retValue = CSmlDmAdapter::ENotFound;
+ DBG_PRINT("CNSmlDmSIPAdapter::FetchObjectL: ENotFound end");
+ return retValue;
+ }
+
+ // SIP/x/SIPId
+ if ( KNSmlDMSIPSipID() == lastUriSeg )
+ {
+ TUint32 val( 0 );
+ err = iProfiles->At( profileID )->GetParameter( KSIPProfileId, val );
+ segmentResult.Num( val );
+ }
+
+ // SIP/x/Provider
+ if ( KNSmlDMSIPName() == lastUriSeg )
+ {
+ err = iProfiles->At( profileID )->
+ GetParameter( KSIPProviderName, paramResult );
+ segmentResult.Copy( *paramResult );
+ }
+
+ // SIP/x/Type
+ if ( KNSmlDMSIPProfileType() == lastUriSeg )
+ {
+ TSIPProfileTypeInfo type;
+ type = iProfiles->At( profileID )->Type();
+ if ( type.iSIPProfileClass == TSIPProfileTypeInfo::EIms )
+ {
+ segmentResult.Copy( KPTypeIMS );
+ }
+ if ( type.iSIPProfileClass == TSIPProfileTypeInfo::EInternet )
+ {
+ segmentResult.Copy( KPTypeIETF );
+ }
+ if ( type.iSIPProfileClass == TSIPProfileTypeInfo::EOther )
+ {
+ segmentResult.Copy( KPTypeOther );
+ }
+ }
+
+ // SIP/x/ProfileLock
+ if ( KNSmlDMSIPProfileLock() == lastUriSeg )
+ {
+ TBool boolVal( EFalse );
+ err = iProfiles->At( profileID )->GetParameter(
+ KSIPProfileLocked, boolVal );
+ if ( boolVal )
+ {
+ segmentResult.Copy( KNSmlDMSIPValueTrue );
+ }
+ else
+ {
+ segmentResult.Copy( KNSmlDMSIPValueFalse );
+ }
+ }
+
+ // SIP/x/AddressOfRecord
+ if ( KNSmlDMSIPAOR() == lastUriSeg )
+ {
+ // Supports one AOR for profile.
+ err = iProfiles->At( profileID )->GetParameter(
+ KSIPUserAor, paramResult );
+ segmentResult.Copy( *paramResult );
+ }
+
+ // SIP/x/OutboundProxy
+ if ( KNSmlDMSIPOutboundProxy() == secondLastUriSeg )
+ {
+ retValue = FetchOutboundProxyNodeL( profileID, lastUriSeg,
+ segmentResult );
+ }
+
+ // SIP/x/RegistrarServer
+ if ( KNSmlDMSIPRegistrarServer() == secondLastUriSeg )
+ {
+ retValue = FetchRegistrarServerNodeL( profileID, lastUriSeg,
+ segmentResult );
+ }
+
+ // SIP/x/Default
+ if ( KNSmlDMSIPDefault() == lastUriSeg )
+ {
+ err = iProfiles->At( profileID )->GetParameter(
+ KSIPDefaultProfile, boolVal );
+ if ( boolVal )
+ {
+ segmentResult.Copy( KNSmlDMSIPValueTrue );
+ }
+ else
+ {
+ segmentResult.Copy( KNSmlDMSIPValueFalse );
+ }
+ }
+
+ // SIP/x/LooseRouting
+ if ( KNSmlDMSIPLooseRouting() == lastUriSeg )
+ {
+ // Get OutboundProxy SIP uri.
+ const TDesC8* uri = 0;
+ err = iProfiles->At( profileID )->GetParameter(
+ KSIPOutboundProxy, KSIPServerAddress, uri );
+
+ CSIPAddress* sipURI = 0;
+ if ( 0 < uri->Length() )
+ {
+ sipURI = CSIPAddress::DecodeL( *uri );
+ }
+ // The whole SIP URI is empty so return ENotFound.
+ else
+ {
+ retValue = CSmlDmAdapter::ENotFound;
+ DBG_PRINT("CNSmlDmSIPAdapter::FetchObjectL: No SIP URI end");
+ return retValue;
+ }
+
+ CleanupStack::PushL( sipURI );
+ TBuf8<KUriPathMaxLength> tempPathLr;
+ tempPathLr.Copy( sipURI->Uri8().Uri().Extract( EUriPath ) );
+ tempPathLr.LowerCase();
+
+ if ( KErrNotFound != sipURI->Uri8().Uri().Extract( EUriPath ).Find(
+ KSIPlr ) )
+ {
+ segmentResult.Copy( KNSmlDMSIPValueTrue );
+ }
+ else
+ {
+ segmentResult.Copy( KNSmlDMSIPValueFalse );
+ }
+ CleanupStack::PopAndDestroy( sipURI );
+ }
+
+ // SIP/x/EnableSecurityNegotiation
+ if ( KNSmlDMSIPEnableSecurityNegotiation() == lastUriSeg )
+ {
+ err = iProfiles->At( profileID )->GetParameter(
+ KSIPSecurityNegotiation, boolVal );
+ if ( boolVal )
+ {
+ segmentResult.Copy( KNSmlDMSIPValueTrue );
+ }
+ else
+ {
+ segmentResult.Copy( KNSmlDMSIPValueFalse );
+ }
+ }
+
+ // SIP/x/EnableSigComp
+ if ( KNSmlDMSIPEnableSigComp() == lastUriSeg )
+ {
+ err = iProfiles->At( profileID )->GetParameter(
+ KSIPSigComp, boolVal );
+ if ( boolVal )
+ {
+ segmentResult.Copy( KNSmlDMSIPValueTrue );
+ }
+ else
+ {
+ segmentResult.Copy( KNSmlDMSIPValueFalse );
+ }
+ }
+
+ // SIP/x/AutoRegistration
+ if ( KNSmlDMSIPEnableAutoRegistration() == lastUriSeg )
+ {
+ err = iProfiles->At( profileID )->GetParameter(
+ KSIPAutoRegistration, boolVal );
+ if ( boolVal )
+ {
+ segmentResult.Copy( KNSmlDMSIPValueTrue );
+ }
+ else
+ {
+ segmentResult.Copy( KNSmlDMSIPValueFalse );
+ }
+ }
+
+ // SIP/x/ConRef
+ if ( KNSmlDMSIPConRef() == lastUriSeg )
+ {
+ TBool conref = GetConRefL( aResult, profileID );
+ if ( !conref )
+ {
+ aResult.Reset();
+ retValue = CSmlDmAdapter::ENotFound;
+ DBG_PRINT("CNSmlDmSIPAdapter::FetchObjectL(): \
+PrefConRef not found end");
+ return retValue;
+ }
+ }
+
+ // SIP/x/DestinationNetwork
+ if ( KNSmlDMSIPSnap() == lastUriSeg )
+ {
+ TUint32 snapId( KErrNone );
+ err = iProfiles->At( profileID )->GetParameter(
+ KSIPSnapId, snapId );
+ if ( snapId )
+ {
+ TBuf8<KNSmlSIPMaxUriLength> snapUri;
+ retValue = GetSnapUriL( snapUri, snapId );
+ if ( CSmlDmAdapter::EOk == retValue )
+ {
+ segmentResult.Copy( snapUri );
+ }
+ else if ( CSmlDmAdapter::ENotFound == retValue )
+ {
+ DBG_PRINT( "CNSmlDmSIPAdapter::FetchObjectL(): \
+SNAP not found end" );
+ return retValue;
+ }
+ }
+ }
+
+ // SIP/x/SignalingQoS
+ if ( KNSmlDMSIPSigQos() == lastUriSeg )
+ {
+ TUint32 sigQos;
+ err = iProfiles->At( profileID )->GetParameter(
+ KSIPSoIpTOS, sigQos );
+ // We need to do bitshifting on the IP TOS, because it's the upper 6
+ // bits that are set and settings provide us the IP TOS as the lower 6
+ // bits. The lower 2 bits are reserver for explicit congestion
+ // notification.
+ // See also more from:
+ // Symbian Developer Library / in_sock.h Global variables / KSoIpTOS
+ sigQos >>= 2;
+ segmentResult.Num( sigQos );
+ }
+
+ // Set error if fetch failed.
+ if ( -1 > err )
+ {
+ retValue = CSmlDmAdapter::EError;
+ }
+
+ if ( EOk == retValue )
+ {
+ aResult.InsertL( aResult.Size(), segmentResult );
+ }
+
+ DBG_PRINT("CNSmlDmSIPAdapter::FetchObjectL(): end");
+ return retValue;
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::FindHexProfile
+// Parses profileID from aURI and returns it in TInt
+// Returns: TInt: profile location in profile array
+// ---------------------------------------------------------------------------
+//
+TInt CNSmlDmSIPAdapter::FindHexProfile(
+ const TDesC8& aURI )
+ {
+ TInt id (0);
+ id = aURI.Find( KSIPHexPrefix );
+ if ( id != KErrNotFound )
+ {
+ TLex8 lexer ( aURI.Mid( id + KSIPPrefix().Length() + 2, 8 ) );
+ TRadix radix = EHex;
+ TUint32 tempVal( 0 );
+ if ( KErrNone == lexer.Val ( tempVal, radix ) )
+ {
+ for ( TInt counter = 0 ; counter < iProfiles->Count() ; counter++ )
+ {
+ TUint32 val ( 0 );
+ iProfiles->At( counter )->GetParameter( KSIPProfileId, val );
+ if ( tempVal == val )
+ {
+ return counter;
+ }
+ }
+ }
+ }
+ return KErrNotFound;
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::ChildURIListL
+// Asks for the list of children objects of the node
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+void CNSmlDmSIPAdapter::ChildURIListL(
+ const TDesC8& aURI,
+ const TDesC8& aLUID,
+ const CArrayFix<TSmlDmMappingInfo>& aPreviousURISegmentList,
+ const TInt aResultsRef,
+ const TInt aStatusRef )
+ {
+ DBG_PRINT( "CNSmlDmSIPAdapter::ChildURIListL(): start" );
+
+ // Load profile information if not loaded yet.
+ if ( !iProfiles )
+ {
+ LoadProfilesL();
+ }
+
+ CSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk;
+
+ CBufBase *currentURISegmentList = CBufFlat::NewL( KDefaultResultSize );
+ CleanupStack::PushL( currentURISegmentList );
+
+ TBuf8 <KNSmlSIPMaxUriLength> uri = aURI;
+
+ // Use LUID mapping if exist.
+ if ( 0 < aLUID.Length() )
+ {
+ uri.Copy( aLUID );
+ }
+
+ // Get last URI segment.
+ TBuf8< KSmlMaxURISegLen > segment = LastURISeg( aURI );
+ TBuf8< KSmlMaxURISegLen > segmentName;
+
+ TInt howManyObjects = iProfiles->Count();
+
+ if ( KNSmlDMSIPNodeName() == segment ) // ./SIP
+ {
+ for ( TInt counter = 0; counter < howManyObjects ; counter++ )
+ {
+ TBool notInList = ETrue;
+ TInt currentline = 0;
+ TUint32 ddId ( 0 );
+ iProfiles->At( counter )->GetParameter( KSIPProfileId, ddId );
+ while ( notInList &&
+ currentline < aPreviousURISegmentList.Count() )
+ {
+ TInt profileLocation = FindHexProfile(
+ aPreviousURISegmentList.At( currentline ).iURISegLUID );
+ TUint32 profileID ( 0 );
+ if ( profileLocation != KErrNotFound )
+ {
+ iProfiles->At( profileLocation )->GetParameter(
+ KSIPProfileId, profileID );
+ }
+ if ( profileID == ddId )
+ {
+ notInList = EFalse;
+ break;
+ }
+ currentline++;
+ }
+ if ( notInList )
+ {
+ // SIP/x
+ TUint32 val ( 0 );
+ iProfiles->At( counter )->GetParameter( KSIPProfileId, val );
+ segmentName.Copy( KSIPPrefix );
+ segmentName.Append( KHexPrefix );
+ segmentName.AppendNumFixedWidthUC( val, EHex, 8 );
+ currentURISegmentList->InsertL( currentURISegmentList->
+ Size(), segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->
+ Size(), KNSmlDMSIPSeparator8 );
+
+ // Set LUID mapping to DM module.
+ TBuf8<KMaxMappingLength> mappingInfo;
+ mappingInfo.Copy ( KSIPPrefix );
+ mappingInfo.Append ( KHexPrefix );
+ mappingInfo.AppendNumFixedWidthUC( val, EHex, 8 );
+ segmentName.Copy( KNSmlDMSIPNodeName );
+ segmentName.Append ( KNSmlDMSIPSeparator8 );
+ segmentName.Append ( KSIPPrefix );
+ segmentName.Append( KHexPrefix );
+ segmentName.AppendNumFixedWidthUC( val, EHex, 8 );
+ iDmCallback->SetMappingL( segmentName, mappingInfo );
+ }
+ else
+ { // Add those in PreviousList which are on database.
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ aPreviousURISegmentList.At(currentline).iURISeg );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+ }
+ }
+ retValue = CSmlDmAdapter::EOk;
+ iDmCallback->SetStatusL( aStatusRef, retValue );
+ iDmCallback->SetResultsL( aResultsRef, *currentURISegmentList,
+ KNullDesC8 );
+ CleanupStack::PopAndDestroy( currentURISegmentList );
+ currentURISegmentList = NULL;
+ DBG_PRINT("CNSmlDmSIPAdapter::ChildURIListL(): end");
+ return;
+ }
+
+ // Find profile from array. Return if not found.
+ TInt profileID = FindHexProfile ( uri );
+ if ( KErrNotFound == profileID )
+ {
+ retValue = CSmlDmAdapter::ENotFound;
+ CleanupStack::PopAndDestroy( currentURISegmentList );
+ iDmCallback->SetStatusL( aStatusRef, retValue );
+ DBG_PRINT("CNSmlDmSIPAdapter::ChildURIListL(): end");
+ return;
+ }
+
+ // SIP/SIPId
+ if ( 2 == NumOfURISegs( aURI ) )
+ {
+ segmentName.Copy( KNSmlDMSIPSipID );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPProfileType );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPAOR );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPOutboundProxy );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPRegistrarServer );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPDefault );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPLooseRouting );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPEnableSecurityNegotiation );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPEnableSigComp );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPEnableAutoRegistration );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPConRef );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPProfileLock );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPSnap );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPSigQos );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+ }
+
+ // SIP/x/OutboundProxy
+ else if ( KNSmlDMSIPOutboundProxy() == LastURISeg( aURI ) )
+ {
+ segmentName.Copy( KNSmlDMSIPHost );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPPort );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPTransport );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPUsername );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPPasswd );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPRealm );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+ }
+
+ // SIP/x/RegistrarServer
+ else if ( KNSmlDMSIPRegistrarServer() == LastURISeg( aURI ) )
+ {
+ segmentName.Copy( KNSmlDMSIPHost );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPPort );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPTransport );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPUsername );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPPrivateIdentity );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPPasswd );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+
+ segmentName.Copy( KNSmlDMSIPRealm );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ segmentName );
+ currentURISegmentList->InsertL( currentURISegmentList->Size(),
+ KNSmlDMSIPSeparator8 );
+ }
+ else
+ {
+ // If none of asked nodes found return error.
+ retValue = CSmlDmAdapter::ENotFound;
+ }
+
+ iDmCallback->SetStatusL( aStatusRef, retValue );
+ iDmCallback->SetResultsL( aResultsRef, *currentURISegmentList,
+ KNullDesC8 );
+ CleanupStack::PopAndDestroy( currentURISegmentList );
+ DBG_PRINT("CNSmlDmSIPAdapter::ChildURIListL(): end");
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::CheckDuplicateNameL
+// Checks if duplicate named sip profiles. Renames if same.
+// ---------------------------------------------------------------------------
+//
+void CNSmlDmSIPAdapter::CheckDuplicateNameL( CSIPManagedProfile& aProfile,
+ const TInt& aProfileId )
+ {
+ DBG_PRINT("CNSmlDmSIPAdapter::CheckDuplicateNameL(): begin");
+ const TDesC8* name;
+ aProfile.GetParameter( KSIPProviderName, name );
+ HBufC8* newName = HBufC8::NewLC( KMaxProviderNameLength );
+ newName->Des().Copy( *name );
+
+ TInt count( iProfiles->Count() );
+
+ for ( TInt n = 0; n < count; n++ )
+ {
+ // Skip profile currently being checked.
+ if ( aProfileId != n )
+ {
+ const TDesC8* existingName;
+ iProfiles->At( n )->GetParameter( KSIPProviderName,
+ existingName );
+ if ( existingName->Compare( *name ) == 0 )
+ {
+ TBool isUnique( EFalse );
+ for ( TInt i = 1; !isUnique; i++ )
+ {
+ TBool found( EFalse );
+ newName->Des().Zero();
+ newName->Des().Append( *name );
+ newName->Des().Append( KOpenParenthesis() );
+ newName->Des().AppendNum( i );
+ newName->Des().Append( KClosedParenthesis() );
+ for ( TInt m = 0; m < count; m++ )
+ {
+ iProfiles->At( m )->GetParameter(
+ KSIPProviderName, existingName );
+ if ( existingName->Compare( newName->Des() ) == 0 )
+ {
+ found = ETrue;
+ }
+ }
+ if ( !found )
+ {
+ isUnique = ETrue;
+ }
+ }
+ }
+ }
+ }
+
+ aProfile.SetParameter( KSIPProviderName, newName->Des() );
+ CleanupStack::PopAndDestroy( newName );
+ DBG_PRINT("CNSmlDmSIPAdapter::CheckDuplicateNameL(): end");
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::AddNodeObjectL
+// Adds a new SIP profile
+// (other items were commented in a header).
+// ---------------------------------------------------------------------------
+//
+void CNSmlDmSIPAdapter::AddNodeObjectL(
+ const TDesC8& aURI,
+ const TDesC8& aParentLUID,
+ const TInt aStatusRef )
+ {
+ DBG_PRINT("CNSmlDmSIPAdapter::AddNodeObjectL(): begin");
+ CSmlDmAdapter::TError status = EOk;
+
+ // Load profile information if not loaded yet.
+ if ( !iProfiles )
+ {
+ LoadProfilesL();
+ }
+
+ // Find profile from array, profile deleted from elsewhere if not found.
+ if ( aParentLUID.Length() > 0 )
+ {
+ TInt profileID = FindHexProfile ( aParentLUID );
+ if ( KErrNotFound == profileID )
+ {
+ status = CSmlDmAdapter::ENotFound;
+ }
+ else
+ {
+ status = CSmlDmAdapter::EAlreadyExists;
+ }
+ }
+
+ if ( NumOfURISegs( aURI ) == 2
+ && ( status == EOk || status == ENotFound ) )
+ {
+ status = EOk;
+ // Check OOD before saving new profile.
+ RFs fs;
+ User::LeaveIfError( fs.Connect() );
+ CleanupClosePushL( fs );
+
+ // SIP settings are stored in one file
+ if ( SysUtil::FFSSpaceBelowCriticalLevelL(
+ &fs, KNSmlDMFatMinimumFileSize ) )
+ {
+ // Prevent writing in OOD.
+ CleanupStack::PopAndDestroy( &fs );
+ iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EDiskFull );
+ DBG_PRINT("CNSmlDmSIPAdapter::AddNodeObjectL(): DISK FULL end");
+ return;
+ }
+ CleanupStack::PopAndDestroy( &fs );
+ TSIPProfileTypeInfo type;
+ type.iSIPProfileClass = TSIPProfileTypeInfo::EInternet;
+ type.iSIPProfileName = KPTypeIETF;
+
+ // Need to create a new profile.
+ CSIPManagedProfile* profile = iSIPManagedProfileRegistry->CreateL(
+ type );
+ CleanupStack::PushL( profile );
+ if ( LastURISeg( aURI ).Length() < KMaxProviderNameLength )
+ {
+ profile->SetParameter( KSIPProviderName, LastURISeg( aURI ) );
+ }
+
+ // Check for name duplicates, this profile has not yet been added to
+ // iProfiles.
+ CheckDuplicateNameL( *profile, KErrNotFound );
+
+ // Default value for Signaling QoS is 40.
+ TUint32 sigQos = 40;
+ // We need to do bitshifting on the IP TOS, because it's the upper 6
+ // bits that are set and settings provide us the IP TOS as the lower 6
+ // bits.
+ // The lower 2 bits are reserver for explicit congestion notification.
+ // See also more from:
+ // Symbian Developer Library / in_sock.h Global variables / KSoIpTOS
+ sigQos <<= 2;
+ profile->SetParameter( KSIPSoIpTOS, sigQos );
+
+ // Add profile to iProfiles and save it also to permanent storage.
+ iSIPManagedProfileRegistry->SaveL( *profile );
+ iProfiles->AppendL( profile );
+
+ // Set LUID mapping to DM module.
+ TUint32 val ( 0 );
+ profile->GetParameter( KSIPProfileId, val );
+ TBuf8<KSmlMaxURISegLen> mappingInfo;
+ mappingInfo.Copy ( KSIPPrefix );
+ mappingInfo.Append ( KHexPrefix );
+ mappingInfo.AppendNumFixedWidthUC( val, EHex, 8 );
+ CleanupStack::Pop( profile );
+ iDmCallback->SetMappingL( aURI, mappingInfo );
+ }
+
+ // Allow add for existing OutboundProxy and RegistrarServer nodes.
+ else if ( aParentLUID.Length() > 0 && NumOfURISegs( aURI ) == 3
+ && ( LastURISeg( aURI ) == KNSmlDMSIPOutboundProxy
+ || LastURISeg( aURI ) == KNSmlDMSIPRegistrarServer ) )
+ {
+ status = CSmlDmAdapter::EOk;
+ }
+
+ iDmCallback->SetStatusL( aStatusRef, status );
+ DBG_PRINT("CNSmlDmSIPAdapter::AddNodeObjectL(): end");
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::DesToInt
+// Converts a 8 bit descriptor to int.
+// Returns: TInt:
+// ---------------------------------------------------------------------------
+//
+TInt CNSmlDmSIPAdapter::DesToInt( const TDesC8& aDes )
+ {
+ TLex8 lex( aDes );
+ TInt value = 0;
+ lex.Val( value );
+ return value;
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::RemoveLastURISeg
+// returns parent uri, i.e. removes last uri segment
+// Returns: TPtrC16: pointer to aURI before last / mark
+// ---------------------------------------------------------------------------
+//
+TPtrC8 CNSmlDmSIPAdapter::RemoveLastURISeg( const TDesC8& aURI )
+ {
+ TInt i ( 0 );
+ // Check that aURI exists.
+ if ( 0 < aURI.Length() )
+ {
+ for ( i = aURI.Length() - 1; i >= 0; i-- )
+ {
+ if ( KDMSIPSeparator == aURI[i] )
+ {
+ break;
+ }
+ }
+ }
+ return aURI.Left( i );
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::NumOfURISegs
+// For getting the number of uri segs
+// Returns: TInt: number of uri segments
+// ---------------------------------------------------------------------------
+//
+TInt CNSmlDmSIPAdapter::NumOfURISegs( const TDesC8& aURI )
+ {
+ TInt numOfURISegs ( 1 );
+ for ( TInt i = 0; i < aURI.Length(); i++ )
+ {
+ if ( KDMSIPSeparator == aURI[i] )
+ {
+ numOfURISegs++;
+ }
+ }
+ return numOfURISegs;
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::LastURISeg
+// Returns only the last uri segment
+// Returns: TPtrC16: pointer to last uri segment
+// ---------------------------------------------------------------------------
+//
+TPtrC8 CNSmlDmSIPAdapter::LastURISeg( const TDesC8& aURI )
+ {
+ TInt i ( 0 );
+ // Check that aURI exists
+ if ( 0 < aURI.Length() )
+ {
+ for ( i = aURI.Length() - 1; i >= 0; i-- )
+ {
+ if ( KDMSIPSeparator == aURI[i] )
+ {
+ break;
+ }
+ }
+ }
+ if ( 0 == i )
+ {
+ return aURI;
+ }
+ else
+ {
+ return aURI.Mid( i+1 );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::RemoveDotSlash
+// return uri without dot and slash in start
+// Returns: TPtrC8: pointer to last uri segment
+// ---------------------------------------------------------------------------
+//
+TPtrC8 CNSmlDmSIPAdapter::RemoveDotSlash( const TDesC8& aURI )
+ {
+ if ( 0 == aURI.Find( KNSmlSIPUriDotSlash ) )
+ {
+ return aURI.Right( aURI.Length()-KNSmlSIPUriDotSlash().Length() );
+ }
+ else
+ {
+ return aURI;
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::GetConRefL
+// Get URI for given accesspoint ID.
+// Returns: TBool: True if connection reference found
+// ---------------------------------------------------------------------------
+//
+TBool CNSmlDmSIPAdapter::GetConRefL( CBufBase& aObject,
+ const TInt& aProfileid )
+ {
+ DBG_PRINT("CNSmlDmSIPAdapter::GetConRefL() : begin");
+ TBool found = EFalse;
+
+ CNSmlDMIAPMatcher* iapmatch = CNSmlDMIAPMatcher::NewL( iDmCallback );
+ CleanupStack::PushL( iapmatch );
+
+ // Get current access point ID.
+ TUint32 profIAPid;
+ iProfiles->At( aProfileid )->GetParameter(
+ KSIPAccessPointId, profIAPid );
+
+ HBufC8* uri8 = iapmatch->URIFromIAPIdL( profIAPid );
+ CleanupStack::PushL( uri8 );
+ if ( uri8 )
+ {
+ aObject.InsertL( aObject.Size(),uri8->Des() );
+ found = ETrue;
+ }
+ CleanupStack::PopAndDestroy( uri8 );
+ CleanupStack::PopAndDestroy( iapmatch );
+ DBG_PRINT("CNSmlDmSIPAdapter::GetConRefL() : end");
+ return found;
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::SetConRefL
+// Set conref value.
+// Status : Draft/Proposal/Approved
+// ---------------------------------------------------------------------------
+//
+TInt CNSmlDmSIPAdapter::SetConRefL( const TDesC8& aObject,
+ const TInt& aProfileid )
+ {
+ DBG_PRINT("CNSmlDmSIPAdapter::SetConRefL() : begin");
+ CNSmlDMIAPMatcher* iapmatch = CNSmlDMIAPMatcher::NewL( iDmCallback );
+ CleanupStack::PushL( iapmatch );
+ TInt lIAPid = iapmatch->IAPIdFromURIL( aObject );
+ if ( lIAPid != KErrNotFound )
+ {
+ iProfiles->At( aProfileid )->SetParameter(
+ KSIPAccessPointId, ( TUint32 )lIAPid );
+ }
+ CleanupStack::PopAndDestroy( iapmatch );
+ DBG_PRINT("CNSmlDmSIPAdapter::SetConRefL() : end");
+ return lIAPid;
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::ExecuteCommandL
+// (Not supported, see smldmadapter.h)
+// ---------------------------------------------------------------------------
+//
+void CNSmlDmSIPAdapter::ExecuteCommandL(
+ const TDesC8& /*aURI*/,
+ const TDesC8& /*aLUID*/,
+ const TDesC8& /*aArgument*/,
+ const TDesC8& /*aType*/,
+ const TInt aStatusRef )
+ {
+ DBG_PRINT("CNSmlDmSIPAdapter::ExecuteCommandL(): begin");
+ iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EError );
+ DBG_PRINT("CNSmlDmSIPAdapter::ExecuteCommandL(): end");
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::ExecuteCommandL
+// (Not supported, see smldmadapter.h)
+// ---------------------------------------------------------------------------
+//
+void CNSmlDmSIPAdapter::ExecuteCommandL(
+ const TDesC8& /*aURI*/,
+ const TDesC8& /*aParentLUID*/,
+ RWriteStream*& /*aStream*/,
+ const TDesC8& /*aType*/,
+ const TInt aStatusRef )
+ {
+ DBG_PRINT("CNSmlDmSIPAdapter::ExecuteCommandL(): stream: begin");
+ iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EError );
+ DBG_PRINT("CNSmlDmSIPAdapter::ExecuteCommandL(): stream: end");
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::CopyCommandL
+// (Not supported, see smldmadapter.h)
+// ---------------------------------------------------------------------------
+//
+void CNSmlDmSIPAdapter::CopyCommandL(
+ const TDesC8& /*aTargetURI*/,
+ const TDesC8& /*aTargetLUID*/,
+ const TDesC8& /*aSourceURI*/,
+ const TDesC8& /*aSourceLUID*/,
+ const TDesC8& /*aType*/,
+ TInt aStatusRef )
+ {
+ DBG_PRINT("CNSmlDmSIPAdapter::CopyCommandL(): begin");
+ iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EError );
+ DBG_PRINT("CNSmlDmSIPAdapter::CopyCommandL(): end");
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::StartAtomicL
+// (Not supported, see smldmadapter.h)
+// ---------------------------------------------------------------------------
+//
+void CNSmlDmSIPAdapter::StartAtomicL()
+ {
+ DBG_PRINT("CNSmlDmSIPAdapter::StartAtomicL(): begin");
+ DBG_PRINT("CNSmlDmSIPAdapter::StartAtomicL(): end");
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::CommitAtomicL
+// (Not supported, see smldmadapter.h)
+// ---------------------------------------------------------------------------
+//
+void CNSmlDmSIPAdapter::CommitAtomicL()
+ {
+ DBG_PRINT("CNSmlDmSIPAdapter::CommitAtomicL(): begin");
+ DBG_PRINT("CNSmlDmSIPAdapter::CommitAtomicL(): end");
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::RollbackAtomicL
+// (Not supported, see smldmadapter.h)
+// ---------------------------------------------------------------------------
+//
+void CNSmlDmSIPAdapter::RollbackAtomicL()
+ {
+ DBG_PRINT("CNSmlDmSIPAdapter::RollbackAtomicL(): begin");
+ DBG_PRINT("CNSmlDmSIPAdapter::RollbackAtomicL(): end");
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::StreamingSupport
+// (Not supported, see smldmadapter.h)
+// ---------------------------------------------------------------------------
+//
+TBool CNSmlDmSIPAdapter::StreamingSupport( TInt& /*aItemSize*/ )
+ {
+ DBG_PRINT("CNSmlDmSIPAdapter::StreamingSupport(): begin");
+ DBG_PRINT("CNSmlDmSIPAdapter::StreamingSupport(): end");
+ return EFalse;
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::StreamCommittedL
+// (Not supported, see smldmadapter.h)
+// ---------------------------------------------------------------------------
+//
+void CNSmlDmSIPAdapter::StreamCommittedL()
+ {
+ DBG_PRINT("CNSmlDmSIPAdapter::StreamCommittedL(): begin");
+ DBG_PRINT("CNSmlDmSIPAdapter::StreamCommittedL(): end");
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::CompleteOutstandingCmdsL
+// Saves modified profiles back to permanent store
+// ---------------------------------------------------------------------------
+//
+void CNSmlDmSIPAdapter::CompleteOutstandingCmdsL()
+ {
+ DBG_PRINT("CNSmlDmSIPAdapter::CompleteOutstandingCmdsL(): begin");
+
+ // Check if profiles exist and some modifications are done.
+ // Save only profiles that have changed.
+ if ( iProfiles )
+ {
+ for (TInt i = 0 ; i < iModifications.Count() ; i++ )
+ {
+ TUint32 tIAPId( 0 );
+ iProfiles->At( iModifications[ i ] )->
+ GetParameter( KSIPAccessPointId, tIAPId );
+
+ TBool autoreg( EFalse );
+ iProfiles->At( iModifications[ i ] )->
+ GetParameter( KSIPAutoRegistration, autoreg );
+
+ // Save changes to permanent storage.
+ iSIPManagedProfileRegistry->SaveL(
+ *iProfiles->At( iModifications[ i ] ) );
+ }
+ iModifications.Reset();
+ }
+ DBG_PRINT("CNSmlDmSIPAdapter::CompleteOutstandingCmdsL(): end");
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::FetchLeafObjectSizeL
+// Fetches size of a leaf object
+// ---------------------------------------------------------------------------
+//
+void CNSmlDmSIPAdapter::FetchLeafObjectSizeL(
+ const TDesC8& aURI,
+ const TDesC8& aLUID,
+ const TDesC8& aType,
+ const TInt aResultsRef,
+ const TInt aStatusRef )
+ {
+ DBG_PRINT("CNSmlDmSIPAdapter::FetchLeafObjectSizeL(): begin");
+
+ CBufBase *object = CBufFlat::NewL( 1 );
+ CleanupStack::PushL( object );
+ CSmlDmAdapter::TError retValue = FetchObjectL( aURI, aLUID, *object );
+
+ TInt objSizeInBytes = object->Size();
+ TBuf8<16> stringObjSizeInBytes;
+ stringObjSizeInBytes.Num( objSizeInBytes );
+ object->Reset();
+ object->InsertL( 0, stringObjSizeInBytes );
+
+ iDmCallback->SetStatusL( aStatusRef, retValue );
+ iDmCallback->SetResultsL( aResultsRef, *object, aType );
+ CleanupStack::PopAndDestroy( object );
+ DBG_PRINT("CNSmlDmSIPAdapter::FetchLeafObjectSizeL(): end");
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::UpdateLeafObjectL
+// (Not supported, see smldmadapter.h)
+// ---------------------------------------------------------------------------
+//
+void CNSmlDmSIPAdapter::UpdateLeafObjectL(
+ const TDesC8& /*aURI*/,
+ const TDesC8& /*aLUID*/,
+ RWriteStream*& /*aStream*/,
+ const TDesC8& /*aType*/,
+ const TInt aStatusRef )
+ {
+ DBG_PRINT("CNSmlDmSIPAdapter::UpdateLeafObjectL(): stream: begin");
+ iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EError );
+ DBG_PRINT("CNSmlDmSIPAdapter::UpdateLeafObjectL(): stream: end");
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::ProfileRegistryEventOccurred
+// for MSIPProfileRegistryObserver
+// ---------------------------------------------------------------------------
+//
+void CNSmlDmSIPAdapter::ProfileRegistryEventOccurred(
+ TUint32 /*aProfileId*/,
+ TEvent /*aEvent*/)
+ {
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::ProfileRegistryEventOccurred
+// for MSIPProfileRegistryObserver
+// ---------------------------------------------------------------------------
+//
+void CNSmlDmSIPAdapter::ProfileRegistryErrorOccurred(
+ TUint32 /*aProfileId*/,
+ TInt /*aError*/)
+ {
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::SnapIdL
+// Gets SNAP ID based on URI.
+// ---------------------------------------------------------------------------
+//
+TUint32 CNSmlDmSIPAdapter::SnapIdL( const TDesC8& aUri )
+ {
+ DBG_PRINT( "CNSmlDmSIPAdapter::SnapIdL - begin" );
+ TUint32 snapId( KErrNone );
+
+ HBufC8* luid = HBufC8::NewLC( KNSmlSIPMaxUriLength ); // CS:1
+ luid->Des().Copy( iDmCallback->GetLuidAllocL( aUri )->Des() );
+
+ if ( luid->Des().Length() )
+ {
+ snapId = DesToInt( LastURISeg( luid->Des() ) );
+ }
+ CleanupStack::PopAndDestroy( luid ); // CS:0
+ DBG_PRINT( "CNSmlDmSIPAdapter::SnapIdL - end" );
+ return snapId;
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::GetSnapUriL
+// Set SNAP URI based on SNAP ID.
+// ---------------------------------------------------------------------------
+//
+MSmlDmAdapter::TError CNSmlDmSIPAdapter::GetSnapUriL( TDes8& aObject,
+ TUint32 aSnapId )
+ {
+ __ASSERT_ALWAYS( iDmCallback != NULL, User::Leave( KErrArgument ) );
+
+ DBG_PRINT( "CNSmlDmSIPAdapter::GetSnapUriL - begin" );
+
+ CBufBase* result = CBufFlat::NewL( 1 );
+ CleanupStack::PushL( result ); // CS:1
+ CSmlDmAdapter::TError status;
+
+ // Get URIs to all SNAP settings.
+ iDmCallback->FetchLinkL( KNSmlDMSIPSnapUriPrefix(), *result, status );
+
+ if ( CSmlDmAdapter::EOk != status )
+ {
+ CleanupStack::PopAndDestroy( result );
+ DBG_PRINT( "CNSmlDmSIPAdapter::GetSnapUriL - Fetch SNAP error end" );
+ return status;
+ }
+
+ result->Compress();
+ HBufC8* childList = HBufC8::NewLC( result->Size() ); // CS:2
+ TInt uriSegCount( 0 );
+
+ if ( result->Size() )
+ {
+ childList->Des().Copy( result->Ptr( 0 ) );
+ uriSegCount = NumOfURISegs( childList->Des() );
+ }
+
+ // Get LUIDs for URIs.
+ for ( TInt index = 0; index < uriSegCount; index++ )
+ {
+ HBufC8* uri = HBufC8::NewLC( KNSmlSIPMaxUriLength ); // CS:3
+ HBufC8* luid = HBufC8::NewLC( KNSmlSIPMaxUriLength ); // CS:4
+
+ uri->Des().Copy( KNSmlDMSIPSnapUriPrefix() );
+ uri->Des().Append( KNSmlDMSIPSeparator8() );
+ uri->Des().Append( LastURISeg( childList->Des() ) );
+ luid->Des().Copy( iDmCallback->GetLuidAllocL( uri->Des() )->Des() );
+ if ( luid->Des().Length() &&
+ aSnapId == DesToInt( LastURISeg( luid->Des() ) ) )
+ {
+ aObject.Copy( uri->Des() );
+ CleanupStack::PopAndDestroy( luid ); // CS:3
+ CleanupStack::PopAndDestroy( uri ); // CS:2
+ break;
+ }
+ childList->Des().Copy( RemoveLastURISeg( childList->Des() ) );
+ CleanupStack::PopAndDestroy( luid ); // CS:3
+ CleanupStack::PopAndDestroy( uri ); // CS:2
+ }
+ CleanupStack::PopAndDestroy( childList ); // CS:1
+ CleanupStack::PopAndDestroy( result ); // CS:0
+ DBG_PRINT( "CNSmlDmSIPAdapter::GetSnapUriL - end" );
+ return status;
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::UpdateOutboundProxyNodeL
+// Updater method for OutboundProxy node.
+// ---------------------------------------------------------------------------
+//
+MSmlDmAdapter::TError CNSmlDmSIPAdapter::UpdateOutboundProxyNodeL(
+ TUint32 aProfileId, const TDesC8& aUri, const TDesC8& aObject )
+ {
+ DBG_PRINT( "CNSmlDmSIPAdapter::UpdateOutboundProxyNodeL - begin" );
+ MSmlDmAdapter::TError status = EOk;
+
+ // Get OutboundProxy SIP URI.
+ const TDesC8* uri = 0;
+ iProfiles->At( aProfileId )->GetParameter( KSIPOutboundProxy,
+ KSIPServerAddress, uri );
+ TUriParser8 parser;
+ TInt err = parser.Parse( *uri );
+ if ( KErrNone != err )
+ {
+ DBG_PRINT( "CNSmlDmSIPAdapter::UpdateOutboundProxyNodeL - URI parse \
+ error end" );
+ return CSmlDmAdapter::EError;
+ }
+ CUri8* tempUri = CUri8::NewLC( parser );
+
+ // Start of outboundproxy parameters.
+
+ // SIP/x/OutboundProxy/Host
+ // When host is cleared, whole proxy address needs to be cleared.
+ if ( KNSmlDMSIPHost() == aUri )
+ {
+ if ( aObject == KNullDesC8 )
+ {
+ tempUri->RemoveComponentL( EUriScheme );
+ tempUri->RemoveComponentL( EUriUserinfo );
+ tempUri->RemoveComponentL( EUriHost );
+ tempUri->RemoveComponentL( EUriPort );
+ tempUri->RemoveComponentL( EUriPath );
+ tempUri->RemoveComponentL( EUriQuery );
+ tempUri->RemoveComponentL( EUriFragment );
+ }
+ else
+ {
+ HBufC8* scheme = HBufC8::NewLC( KMaxSchemeLength );
+ if ( 0 == aObject.Find( KNSmlDMSIPSIPPrefix() ) )
+ {
+ scheme->Des().Copy( KNSmlDMSIPSip() );
+ }
+ else if ( 0 == aObject.Find( KNSmlDMSIPSIPSPrefix() ) )
+ {
+ scheme->Des().Copy( KNSmlDMSIPSips() );
+ }
+ if ( scheme->Des().Length() > 0 )
+ {
+ tempUri->SetComponentL( scheme->Des(), EUriScheme );
+ if ( aObject.Length() > scheme->Des().Length() )
+ {
+ tempUri->SetComponentL( aObject.Mid( scheme->
+ Des().Length() + 1 ), EUriHost );
+ }
+ else
+ {
+ // No host entered at all, remove host component.
+ tempUri->RemoveComponentL( EUriHost );
+ }
+ }
+ else
+ {
+ scheme->Des().Copy( tempUri->Uri().Extract(
+ EUriScheme ) );
+ if ( 0 == scheme->Des().Length() )
+ {
+ scheme->Des().Copy( KNSmlDMSIPSip() );
+ }
+ tempUri->SetComponentL( scheme->Des(), EUriScheme );
+ // Set host component, no scheme in parameter.
+ tempUri->SetComponentL( aObject, EUriHost );
+ }
+ CleanupStack::PopAndDestroy( scheme );
+ }
+ }
+
+ // SIP/x/OutboundProxy/Port
+ if ( KNSmlDMSIPPort() == aUri )
+ {
+ if ( aObject == KNullDesC8 )
+ {
+ tempUri->RemoveComponentL( EUriPort );
+ }
+ else
+ {
+ tempUri->SetComponentL( aObject, EUriPort );
+ }
+ }
+
+ // SIP/x/OutboundProxy/Transport
+ if ( KNSmlDMSIPTransport() == aUri )
+ {
+ TBuf8<KUriPathMaxLength> tempPathTp;
+ tempPathTp.Copy( tempUri->Uri().Extract( EUriPath ) );
+ tempPathTp.LowerCase();
+
+ // SIP/x/OutboundProxy/Transport
+ if ( KNSmlDMSIPTransportTCP() == aObject )
+ {
+ TInt pos = tempPathTp.Find( KSIPTransportPrefix );
+ if ( KErrNotFound != pos )
+ {
+ tempPathTp.Delete( pos, ( tempPathTp.Length() - pos ) );
+ tempPathTp.Append( KSIPTransportTCP );
+ }
+ else
+ {
+ tempPathTp.Append( KSIPTransportTCP );
+ }
+ tempUri->SetComponentL( tempPathTp, EUriPath );
+ }
+
+ // SIP/x/OutboundProxy/Transport
+ else if ( KNSmlDMSIPTransportUDP() == aObject )
+ {
+ TInt pos = tempPathTp.Find( KSIPTransportPrefix );
+ if ( KErrNotFound != pos )
+ {
+ tempPathTp.Delete( pos, ( tempPathTp.Length() - pos ) );
+ tempPathTp.Append( KSIPTransportUDP );
+ }
+ else
+ {
+ tempPathTp.Append( KSIPTransportUDP );
+ }
+ tempUri->SetComponentL( tempPathTp, EUriPath );
+ }
+
+ // SIP/x/OutboundProxy/Transport
+ else if ( KNSmlDMSIPTransportAuto() == aObject )
+ {
+ TInt pos = tempPathTp.Find( KSIPTransportPrefix );
+ if ( KErrNotFound != pos )
+ {
+ tempPathTp.Delete( pos, ( tempPathTp.Length() - pos ) );
+ }
+ tempUri->SetComponentL( tempPathTp, EUriPath );
+ }
+ else
+ {
+ status = CSmlDmAdapter::EInvalidObject;
+ }
+ }
+
+ // SIP/x/OutboundProxy/Username
+ if ( KNSmlDMSIPUsername() == aUri )
+ {
+ TSIPProfileTypeInfo type;
+ type = iProfiles->At( aProfileId )->Type();
+
+ // Set Username if profile type is IETF.
+ if ( type.iSIPProfileClass == TSIPProfileTypeInfo::EInternet )
+ {
+ if ( KErrNotFound == aObject.Find( KEscaped() ) )
+ {
+ HBufC8* encoded = EscapeUtils::EscapeEncodeL( aObject,
+ EscapeUtils::EEscapeNormal );
+ err = iProfiles->At( aProfileId )->SetParameter(
+ KSIPOutboundProxy, KSIPDigestUserName, *encoded );
+ delete encoded;
+ }
+ else
+ {
+ err = iProfiles->At( aProfileId )->SetParameter(
+ KSIPOutboundProxy, KSIPDigestUserName, aObject );
+ }
+ }
+
+ // Set PrivateIdentity if profiletype is IMS or other.
+ else if ( type.iSIPProfileClass == TSIPProfileTypeInfo::EIms ||
+ type.iSIPProfileClass == TSIPProfileTypeInfo::EOther )
+ {
+ if ( KErrNotFound == aObject.Find( KEscaped() ) )
+ {
+ HBufC8* encoded = EscapeUtils::EscapeEncodeL( aObject,
+ EscapeUtils::EEscapeNormal );
+ err = iProfiles->At( aProfileId )->SetParameter(
+ KSIPPrivateIdentity, *encoded );
+ delete encoded;
+ }
+ else
+ {
+ err = iProfiles->At( aProfileId )->SetParameter(
+ KSIPPrivateIdentity, aObject );
+ }
+ }
+
+ else
+ {
+ status = CSmlDmAdapter::EInvalidObject;
+ }
+ }
+
+ // SIP/x/OutboundProxy/Passwd
+ if ( KNSmlDMSIPPasswd() == aUri )
+ {
+ err = iProfiles->At( aProfileId )->SetParameter(
+ KSIPOutboundProxy, KSIPDigestPassword, aObject );
+ }
+
+ // SIP/x/OutboundProxy/Realm
+ if ( KNSmlDMSIPRealm() == aUri )
+ {
+ err = iProfiles->At( aProfileId )->SetParameter(
+ KSIPOutboundProxy, KSIPDigestRealm, aObject );
+ }
+
+ // Set tempUri back to original sipURI.
+ if ( status == CSmlDmAdapter::EOk )
+ {
+ err = iProfiles->At( aProfileId )->SetParameter(
+ KSIPOutboundProxy, KSIPServerAddress,
+ tempUri->Uri().UriDes() );
+ }
+ else
+ {
+ status = CSmlDmAdapter::EError;
+ }
+ CleanupStack::PopAndDestroy( tempUri );
+
+ if ( KErrNone != err )
+ {
+ status = CSmlDmAdapter::EError;
+ }
+
+ DBG_PRINT( "CNSmlDmSIPAdapter::UpdateOutboundProxyNodeL - end" );
+ return status;
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::UpdateRegistrarServerNodeL
+// Updater method for RegistrarServer node.
+// ---------------------------------------------------------------------------
+//
+MSmlDmAdapter::TError CNSmlDmSIPAdapter::UpdateRegistrarServerNodeL(
+ TUint32 aProfileId, const TDesC8& aUri, const TDesC8& aObject )
+ {
+ DBG_PRINT( "CNSmlDmSIPAdapter::UpdateRegistrarServerNodeL - begin" );
+ MSmlDmAdapter::TError status = EOk;
+
+ // Get RegistrarServer SIP URI.
+ const TDesC8* uri = 0;
+ iProfiles->At( aProfileId )->GetParameter ( KSIPRegistrar,
+ KSIPServerAddress, uri );
+ TUriParser8 parser;
+ TInt err = parser.Parse( *uri );
+ if ( KErrNone != err )
+ {
+ DBG_PRINT( "CNSmlDmSIPAdapter::UpdateRegistrarServerNodeL - URI \
+parse error end" );
+ return CSmlDmAdapter::EError;
+ }
+ CUri8* tempUri = CUri8::NewLC( parser );
+
+ // SIP/x/RegistrarServer/Host
+ if ( KNSmlDMSIPHost() == aUri )
+ {
+ if ( aObject == KNullDesC8 )
+ {
+ tempUri->RemoveComponentL( EUriHost );
+ }
+ else
+ {
+ HBufC8* scheme = HBufC8::NewLC( KMaxSchemeLength );
+ if ( 0 == aObject.Find( KNSmlDMSIPSIPPrefix() ) )
+ {
+ scheme->Des().Copy( KNSmlDMSIPSip() );
+ }
+ else if ( 0 == aObject.Find( KNSmlDMSIPSIPSPrefix() ) )
+ {
+ scheme->Des().Copy( KNSmlDMSIPSips() );
+ }
+ if ( scheme->Des().Length() > 0 )
+ {
+ // Set scheme if exists in host parameter.
+ tempUri->SetComponentL( scheme->Des(), EUriScheme );
+ if ( aObject.Length() > scheme->Des().Length() )
+ {
+ tempUri->SetComponentL( aObject.Mid( scheme->
+ Des().Length() + 1 ), EUriHost );
+ }
+ else
+ {
+ // No host entered at all, remove host component.
+ tempUri->RemoveComponentL( EUriHost );
+ }
+ }
+ else
+ {
+ scheme->Des().Copy( tempUri->Uri().Extract(
+ EUriScheme ) );
+ if ( 0 == scheme->Des().Length() )
+ {
+ scheme->Des().Copy( KNSmlDMSIPSip() );
+ }
+ tempUri->SetComponentL( scheme->Des(), EUriScheme );
+ // Set host component, no scheme in parameter.
+ tempUri->SetComponentL( aObject, EUriHost );
+ }
+ CleanupStack::PopAndDestroy( scheme );
+ }
+ }
+
+ // SIP/x/RegistrarServer/Port
+ if ( KNSmlDMSIPPort() == aUri )
+ {
+ if ( aObject == KNullDesC8 )
+ {
+ tempUri->RemoveComponentL( EUriPort );
+ }
+ else
+ {
+ tempUri->SetComponentL( aObject, EUriPort );
+ }
+ }
+
+ // SIP/x/RegistrarServer/Transport
+ if ( KNSmlDMSIPTransport() == aUri )
+ {
+ TBuf8<KUriPathMaxLength> tempPathReg;
+ tempPathReg.Copy( tempUri->Uri().Extract( EUriPath ) );
+ tempPathReg.LowerCase();
+
+ if ( KNSmlDMSIPTransportTCP() == aObject )
+ {
+ TInt pos = tempPathReg.Find( KSIPTransportPrefix );
+ if ( KErrNotFound != pos )
+ {
+ tempPathReg.Delete( pos, ( tempPathReg.Length() - pos ) );
+ tempPathReg.Append( KSIPTransportTCP );
+ }
+ else
+ {
+ tempPathReg.Append( KSIPTransportTCP );
+ }
+ tempUri->SetComponentL( tempPathReg, EUriPath );
+ }
+
+ else if ( KNSmlDMSIPTransportUDP() == aObject )
+ {
+ TInt pos = tempPathReg.Find( KSIPTransportPrefix );
+ if ( KErrNotFound != pos )
+ {
+ tempPathReg.Delete( pos, ( tempPathReg.Length() - pos ) );
+ tempPathReg.Append( KSIPTransportUDP );
+ }
+ else
+ {
+ tempPathReg.Append( KSIPTransportUDP );
+ }
+ tempUri->SetComponentL( tempPathReg, EUriPath );
+ }
+
+ else if ( KNSmlDMSIPTransportAuto() == aObject )
+ {
+ TInt pos = tempPathReg.Find( KSIPTransportPrefix );
+ if ( KErrNotFound != pos )
+ {
+ tempPathReg.Delete( pos, ( tempPathReg.Length() - pos ) );
+ }
+ tempUri->SetComponentL( tempPathReg, EUriPath );
+ }
+
+ else
+ {
+ status = CSmlDmAdapter::EInvalidObject;
+ }
+ }
+
+ // SIP/x/RegistrarServer/Username
+ if ( KNSmlDMSIPUsername() == aUri )
+ {
+ TSIPProfileTypeInfo type;
+ type = iProfiles->At( aProfileId )->Type();
+ if ( type.iSIPProfileClass == TSIPProfileTypeInfo::EInternet )
+ {
+ if ( KErrNotFound == aObject.Find( KEscaped() ) )
+ {
+ HBufC8* encoded = EscapeUtils::EscapeEncodeL( aObject,
+ EscapeUtils::EEscapeNormal );
+ err = iProfiles->At( aProfileId )->SetParameter(
+ KSIPRegistrar, KSIPDigestUserName, *encoded );
+ delete encoded;
+ }
+ else
+ {
+ err = iProfiles->At( aProfileId )->SetParameter(
+ KSIPRegistrar, KSIPDigestUserName, aObject );
+ }
+ }
+ }
+
+ // SIP/x/RegistrarServer/PrivateIdentity
+ if ( KNSmlDMSIPPrivateIdentity() == aUri )
+ {
+ TSIPProfileTypeInfo type;
+ type = iProfiles->At( aProfileId )->Type();
+
+ // Set PrivateIdentity if profiletype is Ims or preIms.
+ if ( type.iSIPProfileClass == TSIPProfileTypeInfo::EIms ||
+ type.iSIPProfileClass == TSIPProfileTypeInfo::EOther )
+ {
+ err = iProfiles->At( aProfileId )->SetParameter(
+ KSIPPrivateIdentity, aObject );
+ }
+ else
+ {
+ status = CSmlDmAdapter::EInvalidObject;
+ }
+ }
+
+ // SIP/x/RegistrarServer/Passwd
+ if ( KNSmlDMSIPPasswd() == aUri )
+ {
+ err = iProfiles->At( aProfileId )->SetParameter( KSIPRegistrar,
+ KSIPDigestPassword, aObject );
+ }
+
+ // SIP/x/RegistrarServer/Realm
+ if ( KNSmlDMSIPRealm() == aUri )
+ {
+ err = iProfiles->At( aProfileId )->SetParameter( KSIPRegistrar,
+ KSIPDigestRealm, aObject );
+ }
+
+ // Set tempUri back to original sipURI.
+ // Allow emptying realm and passwd.
+ if ( status == CSmlDmAdapter::EOk )
+ {
+ err = iProfiles->At( aProfileId )->SetParameter( KSIPRegistrar,
+ KSIPServerAddress, tempUri->Uri().UriDes() );
+ }
+ else
+ {
+ status = CSmlDmAdapter::EError;
+ }
+ CleanupStack::PopAndDestroy( tempUri );
+
+ if ( KErrNone != err )
+ {
+ status = CSmlDmAdapter::EError;
+ }
+
+ DBG_PRINT( "CNSmlDmSIPAdapter::UpdateRegistrarServerNodeL - end" );
+ return status;
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::FetchOutboundProxyNodeL
+// Fetcher method for OutboundProxy node.
+// ---------------------------------------------------------------------------
+//
+MSmlDmAdapter::TError CNSmlDmSIPAdapter::FetchOutboundProxyNodeL(
+ TUint32 aProfileId, const TDesC8& aUri, TDes8& aSegmentResult )
+ {
+ DBG_PRINT( "CNSmlDmSIPAdapter::FetchOutboundProxyNodeL - begin" );
+ MSmlDmAdapter::TError status = CSmlDmAdapter::EOk;
+
+ // Get OutboundProxy SIP URI.
+ const TDesC8* uri = 0;
+ TInt err = iProfiles->At( aProfileId )->GetParameter(
+ KSIPOutboundProxy, KSIPServerAddress, uri );
+
+ CSIPAddress* sipURI = 0;
+ if ( 0 < uri->Length() )
+ {
+ sipURI = CSIPAddress::DecodeL( *uri );
+ }
+ // The whole SIP URI is empty so return ENotFound.
+ else
+ {
+ status = CSmlDmAdapter::ENotFound;
+ DBG_PRINT( "CNSmlDmSIPAdapter::FetchOutboundProxyNodeL - Host not \
+found end" );
+ return status;
+ }
+ CleanupStack::PushL( sipURI );
+
+ // Start of outboundproxy parameters
+ // SIP//OutboundProxy/Host
+ if ( KNSmlDMSIPHost() == aUri )
+ {
+ aSegmentResult.Copy( sipURI->Uri8().Uri().Extract( EUriHost ) );
+ }
+
+ // SIP//OutboundProxy/Port
+ if ( KNSmlDMSIPPort() == aUri )
+ {
+ // Get port if exists.
+ if ( sipURI->Uri8().Uri().IsPresent( EUriPort ) )
+ {
+ aSegmentResult.Copy( sipURI->Uri8().Uri().Extract( EUriPort ) );
+ }
+ else
+ {
+ aSegmentResult.Num( KDefaultPortNumber );
+ }
+ }
+
+ // SIP//OutboundProxy/Transport
+ if ( KNSmlDMSIPTransport() == aUri )
+ {
+ TBuf8<KUriPathMaxLength> tempPathOb;
+ tempPathOb.Copy( sipURI->Uri8().Uri().Extract( EUriPath ) );
+ tempPathOb.LowerCase();
+
+ // Return default transport if none is found.
+ aSegmentResult.Copy( KNSmlDMSIPTransportAuto );
+
+ TInt pos = tempPathOb.Find( KSIPTransportTCP );
+ if ( KErrNotFound != pos )
+ {
+ aSegmentResult.Copy( KNSmlDMSIPTransportTCP );
+ }
+ pos = tempPathOb.Find( KSIPTransportUDP );
+ if ( KErrNotFound != pos )
+ {
+ aSegmentResult.Copy( KNSmlDMSIPTransportUDP );
+ }
+ }
+
+ // SIP/x/OutboundProxy/Username
+ if ( KNSmlDMSIPUsername() == aUri )
+ {
+ TSIPProfileTypeInfo type;
+ type = iProfiles->At( aProfileId )->Type();
+ if ( type.iSIPProfileClass == TSIPProfileTypeInfo::EInternet )
+ {
+ const TDesC8* paramResult = NULL;
+ err = iProfiles->At( aProfileId )->GetParameter(
+ KSIPOutboundProxy, KSIPDigestUserName, paramResult );
+ aSegmentResult.Copy( *paramResult );
+ }
+ else if ( type.iSIPProfileClass == TSIPProfileTypeInfo::EIms ||
+ type.iSIPProfileClass == TSIPProfileTypeInfo::EOther )
+ {
+ const TDesC8* paramResult = NULL;
+ iProfiles->At( aProfileId )->
+ GetParameter( KSIPPrivateIdentity, paramResult );
+ aSegmentResult.Copy( *paramResult );
+ }
+ else
+ {
+ aSegmentResult.Copy( KNullDesC );
+ }
+ }
+
+ // SIP/x/OutboundProxy/Realm
+ if ( KNSmlDMSIPRealm() == aUri )
+ {
+ const TDesC8* paramResult = NULL;
+ err = iProfiles->At( aProfileId )->GetParameter( KSIPOutboundProxy,
+ KSIPDigestRealm, paramResult );
+ aSegmentResult.Copy( *paramResult );
+ }
+ CleanupStack::PopAndDestroy( sipURI );
+
+ if ( KErrNone != err )
+ {
+ status = CSmlDmAdapter::EError;
+ }
+
+ DBG_PRINT( "CNSmlDmSIPAdapter::FetchOutboundProxyNodeL - end" );
+ return status;
+ }
+
+// ---------------------------------------------------------------------------
+// CNSmlDmSIPAdapter::FetchRegistrarServerNodeL
+// Fetcher method for RegistrarServer node.
+// ---------------------------------------------------------------------------
+//
+MSmlDmAdapter::TError CNSmlDmSIPAdapter::FetchRegistrarServerNodeL(
+ TUint32 aProfileId, const TDesC8& aUri, TDes8& aSegmentResult )
+ {
+ DBG_PRINT( "CNSmlDmSIPAdapter::FetchRegistrarServerNodeL - begin" );
+ MSmlDmAdapter::TError status = CSmlDmAdapter::EOk;
+
+ // Start of RegistrarServer parameters.
+ // Get Registrar SIP URI.
+ const TDesC8* uri = 0;
+ TInt err = iProfiles->At( aProfileId )->GetParameter( KSIPRegistrar,
+ KSIPServerAddress, uri );
+
+ CSIPAddress* sipURI = 0;
+ if ( 0 < uri->Length() )
+ {
+ sipURI = CSIPAddress::DecodeL( *uri );
+ }
+ // The whole SIP URI is empty so return ENotFound.
+ else
+ {
+ status = CSmlDmAdapter::ENotFound;
+ DBG_PRINT( "CNSmlDmSIPAdapter::FetchRegistrarServerNodeL - Host not \
+found end" );
+ return status;
+ }
+
+ CleanupStack::PushL( sipURI );
+
+ // SIP/x/RegistrarServer/Host
+ if ( KNSmlDMSIPHost() == aUri )
+ {
+ aSegmentResult.Copy( sipURI->Uri8().Uri().Extract( EUriHost ) );
+ }
+
+ // SIP/x/RegistrarServer/Port
+ if ( KNSmlDMSIPPort() == aUri )
+ {
+ // Get port if exists.
+ if ( sipURI->Uri8().Uri().IsPresent( EUriPort ) )
+ {
+ aSegmentResult.Copy( sipURI->Uri8().Uri().Extract(
+ EUriPort ) );
+ }
+ else
+ {
+ aSegmentResult.Num ( KDefaultPortNumber );
+ }
+ }
+
+ // SIP/x/RegistrarServer/Transport
+ if ( KNSmlDMSIPTransport() == aUri )
+ {
+ TBuf8<KUriPathMaxLength> tempPathReg;
+ tempPathReg.Copy( sipURI->Uri8().Uri().Extract( EUriPath ) );
+ tempPathReg.LowerCase();
+
+ // Return default transport if none is found.
+ aSegmentResult.Copy( KNSmlDMSIPTransportAuto );
+
+ TInt pos = tempPathReg.Find( KSIPTransportTCP );
+ if ( KErrNotFound != pos )
+ {
+ aSegmentResult.Copy( KNSmlDMSIPTransportTCP );
+ }
+ pos = tempPathReg.Find( KSIPTransportUDP );
+ if ( KErrNotFound != pos )
+ {
+ aSegmentResult.Copy( KNSmlDMSIPTransportUDP );
+ }
+ }
+
+ // SIP/x/RegistrarServer/Username
+ if ( KNSmlDMSIPUsername() == aUri )
+ {
+ TSIPProfileTypeInfo type;
+ type = iProfiles->At( aProfileId )->Type();
+ if ( type.iSIPProfileClass == TSIPProfileTypeInfo::EInternet )
+ {
+ const TDesC8* paramResult = NULL;
+ err = iProfiles->At( aProfileId )->GetParameter(
+ KSIPRegistrar, KSIPDigestUserName, paramResult );
+ aSegmentResult.Copy( *paramResult );
+ }
+ else
+ {
+ aSegmentResult.Copy( KNullDesC );
+ }
+ }
+
+ // PrivateIdentity used in IMS or PreIms.
+ if ( KNSmlDMSIPPrivateIdentity() == aUri )
+ {
+ TSIPProfileTypeInfo type;
+ type = iProfiles->At( aProfileId )->Type();
+ if ( type.iSIPProfileClass == TSIPProfileTypeInfo::EIms ||
+ type.iSIPProfileClass == TSIPProfileTypeInfo::EOther )
+ {
+ const TDesC8* paramResult = NULL;
+ iProfiles->At( aProfileId )->
+ GetParameter( KSIPPrivateIdentity, paramResult );
+ aSegmentResult.Copy( *paramResult );
+ }
+ else
+ {
+ aSegmentResult.Copy( KNullDesC );
+ }
+ }
+
+ // SIP/x/RegistrarServer/Realm
+ if ( KNSmlDMSIPRealm() == aUri )
+ {
+ const TDesC8* paramResult = NULL;
+ err = iProfiles->At( aProfileId )->GetParameter(
+ KSIPRegistrar, KSIPDigestRealm, paramResult );
+ aSegmentResult.Copy( *paramResult );
+ }
+ CleanupStack::PopAndDestroy( sipURI );
+
+ if ( KErrNone != err )
+ {
+ status = CSmlDmAdapter::EError;
+ }
+
+ DBG_PRINT( "CNSmlDmSIPAdapter::FetchRegistrarServerNodeL - end" );
+ return status;
+ }
+
+// End of file