diff -r 000000000000 -r 307788aac0a8 sipplugins/sippdevmgmtsipadapter/src/nsmldmsipadapter.cpp --- /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 +#include // For TImplementationProxy definition +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#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 profileTypes; + CleanupClosePushL( profileTypes ); // CS:1 + + // Get the supported profile types + iSIPManagedProfileRegistry->SupportedProfileTypesL( profileTypes ); + + // Create the profile pointer array. + iProfiles = new ( ELeave ) CArrayPtrFlat( 5 ); + + RPointerArray 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( 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 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 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 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 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 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 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& 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 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 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 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 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 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 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 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