diff -r 000000000000 -r 307788aac0a8 sipplugins/sippsipsettingsui/src/gssipprofileutil.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/sipplugins/sippsipsettingsui/src/gssipprofileutil.cpp Tue Feb 02 01:03:15 2010 +0200 @@ -0,0 +1,1133 @@ +/* +* Copyright (c) 2003 - 2005 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: Utility class for manipulating profiles and their attributes +* +*/ + + +// INCLUDE FILES +#include +#include +#include +#include +#include +#include +#include +#include //GUI Resource +#include +#include "gssipprofileutil.h" +#include "tgssipserverdata.h" +#include "tsipsettingsdata.h" +#include "gssippluginlogger.h" + +const TUint32 KDefaultSNAPIdentifier = KMaxTUint32; + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// GSSIPProfileUtil::GSSIPProfileUtil +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +GSSIPProfileUtil::GSSIPProfileUtil() + { + __GSLOGSTRING("GSSIPProfileUtil::GSSIPProfileUtil" ) + } + +// ----------------------------------------------------------------------------- +// GSSIPProfileUtil::CopyProfileAttributesL +// Copies profile attributes from temp data structure to profile +// ----------------------------------------------------------------------------- +// +void GSSIPProfileUtil::CopyProfileAttributesL( + CSIPManagedProfile* aProfile, + const TSIPSettingsData& aProfileData ) + { + __GSLOGSTRING("GSSIPProfileUtil::CopyProfileAttributesL Start" ) + // Service provider name + HBufC8* providerName = + EscapeUtils::ConvertFromUnicodeToUtf8L( aProfileData.iProviderName ); + CleanupStack::PushL( providerName ); + User::LeaveIfError( + aProfile->SetParameter( KSIPProviderName, providerName->Des() ) ); + CleanupStack::PopAndDestroy( providerName ) ; + + // Service profile + aProfile->SetType( aProfileData.iServiceProfile ); + + if ( aProfileData.iSNAPIndex != KDefaultSNAP ) + { + // SNAP index + User::LeaveIfError( aProfile->SetParameter( + KSIPSnapId, (TUint32)aProfileData.iSNAPIndex ) ); + } + else + { + // AP index + User::LeaveIfError( aProfile->SetParameter( + KSIPAccessPointId, (TUint32)aProfileData.iAPIndex ) ); + } + + // Publib username / address of record + if ( aProfileData.iUsername.Length() ) + { + TBool protocolFound( EFalse ); + + TBuf sipHeader( KSIPProtocolHeader ); + sipHeader.Append( KSIPColonSeparator ); + TBuf sipsHeader( KSIPSProtocolHeader ); + sipsHeader.Append( KSIPColonSeparator ); + + EscapeUtils::TEscapeMode mode = EscapeUtils::EEscapeNormal; + HBufC8* conv = + EscapeUtils::ConvertFromUnicodeToUtf8L( aProfileData.iUsername ); + CleanupStack::PushL( conv ); + HBufC8* enc = EscapeUtils::EscapeEncodeL( conv->Des(), mode ); + CleanupStack::PushL( enc ); + + // Set public username if "sip:" was found. + if ( aProfileData.iUsername.Length() > KSIPProtocolHeaderLength ) + { + TBuf lowerCase; + lowerCase.Copy( aProfileData.iUsername.Left( + KSIPProtocolHeaderLength + 1 ) ); + lowerCase.LowerCase(); + + if ( !sipHeader.Compare( lowerCase ) ) + { + User::LeaveIfError( + aProfile->SetParameter( KSIPUserAor, enc->Des() ) ); + protocolFound = ETrue; + } + } + + // Set public username if "sips:" was found. + if ( aProfileData.iUsername.Length() > KSIPSProtocolHeaderLength ) + { + TBuf lowerCase; + lowerCase.Copy( aProfileData.iUsername.Left( + KSIPSProtocolHeaderLength + 1 ) ); + lowerCase.LowerCase(); + + if ( !sipsHeader.Compare( lowerCase ) ) + { + User::LeaveIfError( + aProfile->SetParameter( KSIPUserAor, enc->Des() ) ); + protocolFound = ETrue; + } + } + + // Set scheme and public username + if ( !protocolFound ) + { + TInt length = enc->Length() + sipHeader.Length(); + HBufC8* username = HBufC8::NewLC( length ); + username->Des().Append( sipHeader ); + username->Des().Append( enc->Des() ); + + // Cut some characters if length exceeds max. username length. + if ( length > KMaxUsernameLength ) + { + username->Des().Delete( + KMaxUsernameLength, length - KMaxUsernameLength ); + } + + User::LeaveIfError( + aProfile->SetParameter( KSIPUserAor, username->Des() ) ); + CleanupStack::PopAndDestroy( username ); + } + + CleanupStack::PopAndDestroy( enc ); + CleanupStack::PopAndDestroy( conv ); + } + else + { + User::LeaveIfError( + aProfile->SetParameter( KSIPUserAor, KNullDesC8 ) ); + } + + // Compression setting + TBool compression = ( aProfileData.iCompression == EGSComprYes ); + User::LeaveIfError( aProfile->SetParameter( KSIPSigComp, compression ) ); + + // Registration mode + if ( aProfileData.iRegistrationMode == EGSWhenNeeded ) + { + User::LeaveIfError( + aProfile->SetParameter( KSIPAutoRegistration, EFalse ) ); + } + else + { + User::LeaveIfError( + aProfile->SetParameter( KSIPAutoRegistration, ETrue ) ); + } + + // Security negotiation + TBool security = ( aProfileData.iSecurity == EGSSecurityOn ); + User::LeaveIfError( + aProfile->SetParameter( KSIPSecurityNegotiation, security ) ); + __GSLOGSTRING("GSSIPProfileUtil::CopyProfileAttributesL End" ) + } + +// ----------------------------------------------------------------------------- +// GSSIPProfileUtil::CopyServerAttributesL +// Copies server attributes from temp data structure to profile +// ----------------------------------------------------------------------------- +// +void GSSIPProfileUtil::CopyServerAttributesL( + CSIPManagedProfile* aProfile, + TUint32 aServer, + const TGSSIPServerData& aProfileData ) + { + __GSLOGSTRING("GSSIPProfileUtil::CopyServerAttributesL Start" ) + TInt err( KErrNone ); + EscapeUtils::TEscapeMode mode = EscapeUtils::EEscapeNormal; + + // Digest realm + HBufC8* realm = + EscapeUtils::ConvertFromUnicodeToUtf8L( aProfileData.iRealm ); + CleanupStack::PushL( realm ); + HBufC8* encRealm = EscapeUtils::EscapeEncodeL( realm->Des(), mode ); + ReplaceEscapedSpace( encRealm ); + err = aProfile->SetParameter( + aServer, KSIPDigestRealm, encRealm->Des() ); + delete encRealm; + CleanupStack::PopAndDestroy( realm ); + User::LeaveIfError( err ); + + // Username + HBufC8* uname = + EscapeUtils::ConvertFromUnicodeToUtf8L( aProfileData.iUsername ); + CleanupStack::PushL( uname ); + HBufC8* encUname = EscapeUtils::EscapeEncodeL( uname->Des(), mode ); + err = aProfile->SetParameter( + aServer, KSIPDigestUserName, encUname->Des() ); + delete encUname; + CleanupStack::PopAndDestroy( uname ); + User::LeaveIfError( err ); + + // Password + if ( aProfileData.iPasswordChanged ) + { + HBufC8* passw = + EscapeUtils::ConvertFromUnicodeToUtf8L( aProfileData.iPassword ); + CleanupStack::PushL( passw ); + err = aProfile->SetParameter( + aServer, KSIPDigestPassword, passw->Des() ); + CleanupStack::PopAndDestroy( passw ); + User::LeaveIfError( err ); + } + + // Address + GSSIPProfileUtil::CopyServerURIL( aProfile, aServer, aProfileData ); + __GSLOGSTRING("GSSIPProfileUtil::CopyServerAttributesL End" ) + } + +// ----------------------------------------------------------------------------- +// GSSIPProfileUtil::CopyToTempStructL +// Copies profile attributes from profile to temp data struct +// ----------------------------------------------------------------------------- +// +void GSSIPProfileUtil::CopyToTempStructL( + CSIPManagedProfile* aProfile, + TSIPSettingsData& aProfileData ) + { + __GSLOGSTRING("GSSIPProfileUtil::CopyToTempStructL Start" ) + // Profile ID + TUint32 id( KErrNone ); + aProfile->GetParameter( KSIPProfileId, id ); + aProfileData.iID = id; + + // Service provider name + const TDesC8* providerName; + aProfile->GetParameter( KSIPProviderName, providerName ); + HBufC* providerName16 = + EscapeUtils::ConvertToUnicodeFromUtf8L( *providerName ); + aProfileData.iProviderName.Copy( + providerName16->Des().LeftTPtr( KMaxSIPProviderNameLength ) ); + delete providerName16; + + // Profile type + aProfileData.iServiceProfile = aProfile->Type(); + + // Access Point ID + aProfile->GetParameter( KSIPAccessPointId, id ); + aProfileData.iAPIndex = id; + + // Destination ID + TInt err( KErrNone ); + err = aProfile->GetParameter( KSIPSnapId, id ); + if ( !err && ( static_cast(id) != KErrNotFound) ) + { + aProfileData.iSNAPIndex = id; + } + else + { + aProfileData.iSNAPIndex = KDefaultSNAP; + } + + // Public username / address of record + const TDesC8* userName; + aProfile->GetParameter( KSIPUserAor, userName ); + HBufC8* decodedUsername = EscapeUtils::EscapeDecodeL( *userName ); + CleanupStack::PushL( decodedUsername ); + HBufC* userName16 = + EscapeUtils::ConvertToUnicodeFromUtf8L( decodedUsername->Des() ); + aProfileData.iUsername.Copy( + userName16->Des().LeftTPtr( KMaxUsernameLength ) ); + delete userName16; + CleanupStack::PopAndDestroy( decodedUsername ); + + // Registration mode + TBool mode; + aProfile->GetParameter( KSIPAutoRegistration, mode ); + if ( mode ) + { + aProfileData.iRegistrationMode = EGSAlwaysOn; + } + else + { + aProfileData.iRegistrationMode = EGSWhenNeeded; + } + + // Signal compression + TBool compression; + aProfile->GetParameter( KSIPSigComp, compression ); + if( compression ) + { + aProfileData.iCompression = EGSComprYes; + } + else + { + aProfileData.iCompression = EGSComprNo; + } + + // Security negotiation + TBool negotiation; + aProfile->GetParameter( KSIPSecurityNegotiation,negotiation ); + if( negotiation ) + { + aProfileData.iSecurity = EGSSecurityOn; + } + else + { + aProfileData.iSecurity = EGSSecurityOff; + } + + // Private user identity + const TDesC8* privateIdentity; + aProfile->GetParameter( KSIPPrivateIdentity, privateIdentity ); + HBufC8* decodedIdentity = EscapeUtils::EscapeDecodeL( *privateIdentity ); + CleanupStack::PushL( decodedIdentity ); + HBufC* privateIdentity16 = + EscapeUtils::ConvertToUnicodeFromUtf8L( decodedIdentity->Des() ); + aProfileData.iRegistrar.iPrivateIdentity.Copy( + privateIdentity16->Des().LeftTPtr( KMaxServerPrivateIdentityLength ) ); + delete privateIdentity16; + CleanupStack::PopAndDestroy( decodedIdentity ); + __GSLOGSTRING("GSSIPProfileUtil::CopyToTempStructL End" ) + } + +// ----------------------------------------------------------------------------- +// GSSIPProfileUtil::CopyServerSettingsToTempStructL +// Copies server attributes from profile to temp data struct +// ----------------------------------------------------------------------------- +// +void GSSIPProfileUtil::CopyServerSettingsToTempStructL( + CSIPManagedProfile* aProfile, + TUint32 aServer, + TGSSIPServerData& aProfileData ) + { + __GSLOGSTRING("GSSIPProfileUtil::CopyServerSettingsToTempStructL Start" ) + SIPStrings::OpenL(); + + // Digest realm + const TDesC8* realm; + TInt err = aProfile->GetParameter( aServer, KSIPDigestRealm, realm ); + User::LeaveIfError( err ); + + HBufC8* decodedRealm = EscapeUtils::EscapeDecodeL( *realm ); + CleanupStack::PushL( decodedRealm ); + HBufC* realm16 = + EscapeUtils::ConvertToUnicodeFromUtf8L( decodedRealm->Des() ); + aProfileData.iRealm.Copy( realm16->Des().LeftTPtr( KMaxRealmLength ) ); + delete realm16; + CleanupStack::PopAndDestroy( decodedRealm ); + + // Username + const TDesC8* uName; + err = aProfile->GetParameter( aServer, KSIPDigestUserName, uName ); + User::LeaveIfError( err ); + + HBufC8* decodedUname = EscapeUtils::EscapeDecodeL( *uName ); + CleanupStack::PushL( decodedUname ); + HBufC* uName16 = + EscapeUtils::ConvertToUnicodeFromUtf8L( decodedUname->Des() ); + aProfileData.iUsername.Copy( + uName16->Des().LeftTPtr( KMaxServerUsernameLength ) ); + delete uName16; + CleanupStack::PopAndDestroy( decodedUname ); + + // Server address and other params + const TDesC8* uri; + err = aProfile->GetParameter( aServer, KSIPServerAddress, uri ); + User::LeaveIfError( err ); + + if ( !uri->Length() ) + { + // Set default settings if URI is empty. + aProfileData.iAddress.Zero(); + aProfileData.iPortNumber = KDefaultPortNumber; + aProfileData.iTransportProtocol = EGSTranspProtocolAuto; + if ( aServer == KSIPOutboundProxy ) + { + aProfileData.iLooseRouting = EGSLooseRoutingOn; + } + } + else + { + // Parse uri + TUriParser8 parser; + User::LeaveIfError( parser.Parse( *uri ) ); + aProfileData.iAddress.Zero(); + + // Scheme + if ( parser.IsPresent( EUriScheme ) ) + { + const TDesC8& scheme = parser.Extract( EUriScheme ); + HBufC* scheme16 = EscapeUtils::ConvertToUnicodeFromUtf8L(scheme); + TPtr trimmedScheme ( scheme16->Des().LeftTPtr( + KMaxProxyLength-aProfileData.iAddress.Length() ) ); + aProfileData.iAddress.Append( trimmedScheme ); + aProfileData.iAddress.Append( KSIPColonSeparator ); + delete scheme16; + } + else + { + aProfileData.iAddress.Append( KSIPProtocolHeader ); + aProfileData.iAddress.Append( KSIPColonSeparator ); + } + + // Host + if ( parser.IsPresent( EUriHost ) ) + { + const TDesC8& host = parser.Extract( EUriHost ); + UriUtils::TUriHostType type = UriUtils::HostType( host ); + if ( type == UriUtils::EIPv6Host ) + { + HBufC8* ipv6Host8 = HBufC8::NewLC( host.Length() + 2 ); + ipv6Host8->Des().Copy( host ); + GSSIPProfileUtil::AddBrackets( ipv6Host8->Des() ); + HBufC* ipv6Host16 = + EscapeUtils::ConvertToUnicodeFromUtf8L( *ipv6Host8 ); + TPtr trimmedHost ( ipv6Host16->Des().LeftTPtr( + KMaxProxyLength-aProfileData.iAddress.Length() ) ); + aProfileData.iAddress.Append( trimmedHost ); + delete ipv6Host16; + CleanupStack::PopAndDestroy( ipv6Host8 ); + } + else + { + HBufC* ipv4Host16 = + EscapeUtils::ConvertToUnicodeFromUtf8L( host ); + TPtr trimmedHost ( ipv4Host16->Des().LeftTPtr( + KMaxProxyLength-aProfileData.iAddress.Length() ) ); + aProfileData.iAddress.Append( trimmedHost ); + delete ipv4Host16; + } + } + + // Port + if ( parser.IsPresent( EUriPort ) ) + { + const TDesC8& port = parser.Extract( EUriPort ); + TLex8 lex( port ); + lex.Val( aProfileData.iPortNumber ); + + if ( aProfileData.iPortNumber < 0 ) + { + aProfileData.iPortNumber = KDefaultPortNumber; + } + } + else + { + aProfileData.iPortNumber = KDefaultPortNumber; + } + + // Loose routing and transport + if ( parser.IsPresent( EUriPath ) ) + { + const TDesC8& path = parser.Extract( EUriPath ); + + TDelimitedPathSegmentParser8 pathSegmentParser; + pathSegmentParser.Parse( path ); + TPtrC8 segment; + + // Set temporary values for loose routing and transport. + aProfileData.iLooseRouting = EGSLooseRoutingOff; + aProfileData.iTransportProtocol = EGSTranspProtocolAuto; + + while( pathSegmentParser.GetNext( segment ) == KErrNone ) + { + TBuf seg; + seg.Copy( segment ); + seg.LowerCase(); + // Loose routing + if ( !seg.Compare( KLooseRoutingParam ) ) + { + aProfileData.iLooseRouting = EGSLooseRoutingOn; + } + // Transport + if ( !seg.Find( KTransportParamPrefix ) ) + { + seg.UpperCase(); + if ( !seg.Right( KTCP().Length() ).Compare( KTCP ) ) + { + aProfileData.iTransportProtocol = EGSTranspProtocolTCP; + } + if ( !seg.Right( KUDP().Length() ).Compare( KUDP ) ) + { + aProfileData.iTransportProtocol = EGSTranspProtocolUDP; + } + } + } + } + } + + SIPStrings::Close(); + __GSLOGSTRING("GSSIPProfileUtil::CopyServerSettingsToTempStructL End" ) + } + +// ----------------------------------------------------------------------------- +// GSSIPProfileUtil::ProfileModificationsL +// Compares profile attributes with the ones on the temporary structure +// ----------------------------------------------------------------------------- +// +TBool GSSIPProfileUtil::ProfileModificationsL( + CSIPManagedProfile* aProfile, + const TSIPSettingsData& aProfileData ) + { + __GSLOGSTRING("GSSIPProfileUtil::ProfileModificationsL Start" ) + TInt err( KErrNone ); + TBool modifs = EFalse; + + // Service provider name + const TDesC8* pName; + HBufC8* providerName = + EscapeUtils::ConvertFromUnicodeToUtf8L( aProfileData.iProviderName ); + CleanupStack::PushL( providerName ); + aProfile->GetParameter( KSIPProviderName, pName ); + User::LeaveIfError( err ); + TBool nameComp = providerName->Des().Compare( *pName ) != 0; + CleanupStack::PopAndDestroy( providerName ); + + // Public username / address of record + const TDesC8* aor; + HBufC8* userName = + EscapeUtils::ConvertFromUnicodeToUtf8L( aProfileData.iUsername ); + CleanupStack::PushL( userName ); + err = aProfile->GetParameter( KSIPUserAor, aor ); + User::LeaveIfError( err ); + HBufC8* decodedAor = EscapeUtils::EscapeDecodeL( *aor ); + TBool uNameComp = userName->Des().Compare( decodedAor->Des() ) != 0; + delete decodedAor; + CleanupStack::PopAndDestroy( userName ); + + // Destination + TUint32 snapid; + TBool snapComp = EFalse; + TBool snapUsed = EFalse; + + err = aProfile->GetParameter( KSIPSnapId, snapid ); + if ( err == KErrNotFound ) + { + if ( aProfileData.iSNAPIndex != KDefaultSNAP ) + { + snapComp = ETrue; + } + } + else + { + if(snapid == KDefaultSNAPIdentifier && aProfileData.iSNAPIndex == KDefaultSNAP) + { + snapUsed=EFalse; + snapComp=EFalse; + } + else + { + User::LeaveIfError( err ); + snapUsed = ETrue; + snapComp = TUint( aProfileData.iSNAPIndex ) != snapid; + } + } + + // Access Point + TUint32 apid; + err = aProfile->GetParameter( KSIPAccessPointId, apid ); + User::LeaveIfError( err ); + + TBool iapComp (EFalse); + if ( !snapUsed ) + { + iapComp = TUint( aProfileData.iAPIndex ) != apid; + } + + // Signaling compression + TBool sigcomp; + err = aProfile->GetParameter( KSIPSigComp, sigcomp ); + User::LeaveIfError( err ); + TBool comprComp = + aProfileData.iCompression == (TInt)sigcomp ? EFalse : ETrue; + + // Registration method + TBool registration; + TBool registrationComp = EFalse; + err = aProfile->GetParameter( KSIPAutoRegistration, registration ); + User::LeaveIfError( err ); + if ( aProfileData.iRegistrationMode == EGSWhenNeeded ) + { + if ( registration ) + { + registrationComp = ETrue; + } + } + else if ( aProfileData.iRegistrationMode == EGSAlwaysOn ) + { + if ( !registration ) + { // was WhenNeeded or 'only on home network' + registrationComp = ETrue; + } + } + + // Security negotiation + TBool negation; + err = aProfile->GetParameter( KSIPSecurityNegotiation, negation ); + User::LeaveIfError( err ); + TBool securityComp = + aProfileData.iSecurity == (TInt)negation ? EFalse : ETrue; + + TBool serviceComp = ( aProfileData.iServiceProfile.iSIPProfileName != + aProfile->Type().iSIPProfileName ) || + ( aProfileData.iServiceProfile.iSIPProfileClass != + aProfile->Type().iSIPProfileClass ); + + if ( nameComp || iapComp || snapComp || comprComp || registrationComp || + securityComp || uNameComp || serviceComp ) + { + modifs = ETrue; + } + __GSLOGSTRING("GSSIPProfileUtil::ProfileModificationsL End" ) + return modifs; + } + +// ----------------------------------------------------------------------------- +// GSSIPProfileUtil::ServerModifciationsL +// Compares server attributes with the ones on the temporary structure +// ----------------------------------------------------------------------------- +// +TBool GSSIPProfileUtil::ServerModificationsL( + CSIPManagedProfile* aProfile, + TUint32 aServer, + const TGSSIPServerData& aData ) + { + __GSLOGSTRING("GSSIPProfileUtil::ServerModificationsL" ) + TGSSIPServerData serverData; + + GSSIPProfileUtil::CopyServerSettingsToTempStructL( + aProfile, aServer, serverData ); + + TBool addrComp = serverData.iAddress != aData.iAddress; + TBool lrComp = ( serverData.iLooseRouting != aData.iLooseRouting && + aServer != KSIPRegistrar ); + TBool realmComp = serverData.iRealm != aData.iRealm; + TBool uNameComp = serverData.iUsername != aData.iUsername; + + TBool tpComp = serverData.iTransportProtocol != aData.iTransportProtocol; + TBool portComp = serverData.iPortNumber != aData.iPortNumber; + + return ( addrComp || lrComp || realmComp || uNameComp || aData.iPasswordChanged || + tpComp || portComp ); + } + +// ----------------------------------------------------------------------------- +// GSSIPProfileUtil::CopyProfileL +// Copies profile attributes from one profile to another +// ----------------------------------------------------------------------------- +// +void GSSIPProfileUtil::CopyProfileL( + CSIPManagedProfile* aOrigProfile, + CSIPManagedProfile* aCopiedProfile ) + { + __GSLOGSTRING("GSSIPProfileUtil::CopyProfileL Start" ) + TInt err( KErrNone ); + // Copy profile settings + aCopiedProfile->SetType( aOrigProfile->Type() ); + + TUint32 apid; + err = aOrigProfile->GetParameter( KSIPAccessPointId, apid ); + User::LeaveIfError( err ); + err = aCopiedProfile->SetParameter( KSIPAccessPointId, apid ); + User::LeaveIfError( err ); + + const TDesC8* aor; + err = aOrigProfile->GetParameter( KSIPUserAor, aor ); + User::LeaveIfError( err ); + err = aCopiedProfile->SetParameter( KSIPUserAor, *aor ); + User::LeaveIfError( err ); + + const TDesC8* identity; + err = aOrigProfile->GetParameter(KSIPPrivateIdentity, identity ); + User::LeaveIfError( err ); + err = aCopiedProfile->SetParameter( KSIPPrivateIdentity, *identity ); + User::LeaveIfError( err ); + + const TDesC8* provider; + err = aOrigProfile->GetParameter( KSIPProviderName, provider ); + User::LeaveIfError( err ); + err = aCopiedProfile->SetParameter(KSIPProviderName, *provider ); + User::LeaveIfError( err ); + + TBool sigcomp; + err = aOrigProfile->GetParameter( KSIPSigComp,sigcomp ); + User::LeaveIfError( err ); + err = aCopiedProfile->SetParameter( KSIPSigComp,sigcomp ); + User::LeaveIfError( err ); + + TBool autoregistration; + err = aOrigProfile->GetParameter( KSIPAutoRegistration,autoregistration ); + User::LeaveIfError( err ); + err = aCopiedProfile->SetParameter( KSIPAutoRegistration,autoregistration ); + User::LeaveIfError( err ); + + TBool negation; + err = aOrigProfile->GetParameter( KSIPSecurityNegotiation, negation ); + User::LeaveIfError( err ); + err = aCopiedProfile->SetParameter( KSIPSecurityNegotiation, negation ); + User::LeaveIfError( err ); + + TBool defaultValue; + err = aOrigProfile->GetParameter( KSIPDefaultProfile, defaultValue ); + User::LeaveIfError( err ); + if ( defaultValue ) + { + err = aCopiedProfile->SetParameter( KSIPDefaultProfile, defaultValue ); + User::LeaveIfError( err ); + } + + // Copy Proxy settings + const TDesC8* address; + err = aOrigProfile->GetParameter( KSIPOutboundProxy, KSIPServerAddress, address ); + User::LeaveIfError( err ); + err = aCopiedProfile->SetParameter( KSIPOutboundProxy, KSIPServerAddress, *address ); + User::LeaveIfError( err ); + + const TDesC8* realm; + err = aOrigProfile->GetParameter( KSIPOutboundProxy, KSIPDigestRealm, realm ); + User::LeaveIfError( err ); + err = aCopiedProfile->SetParameter( KSIPOutboundProxy, KSIPDigestRealm, *realm ); + User::LeaveIfError( err ); + + const TDesC8* user; + err = aOrigProfile->GetParameter( KSIPOutboundProxy, KSIPDigestUserName, user ); + User::LeaveIfError( err ); + err = aCopiedProfile->SetParameter( KSIPOutboundProxy, KSIPDigestUserName, *user ); + User::LeaveIfError( err ); + + // Copy Registrar server settings + err = aOrigProfile->GetParameter( KSIPRegistrar, KSIPServerAddress, address ); + User::LeaveIfError( err ); + err = aCopiedProfile->SetParameter( KSIPRegistrar, KSIPServerAddress, *address ); + User::LeaveIfError( err ); + + err = aOrigProfile->GetParameter( KSIPRegistrar, KSIPDigestRealm, realm ); + User::LeaveIfError( err ); + err = aCopiedProfile->SetParameter( KSIPRegistrar, KSIPDigestRealm, *realm ); + User::LeaveIfError( err ); + + err = aOrigProfile->GetParameter( KSIPRegistrar, KSIPDigestUserName, user ); + User::LeaveIfError( err ); + err = aCopiedProfile->SetParameter( KSIPRegistrar, KSIPDigestUserName, *user ); + User::LeaveIfError( err ); + __GSLOGSTRING("GSSIPProfileUtil::CopyProfileL End" ) + } + +// ----------------------------------------------------------------------------- +// GSSIPProfileUtil::CopyServerURIL +// Copies server URI to the profile +// ----------------------------------------------------------------------------- +// +void GSSIPProfileUtil::CopyServerURIL( + CSIPManagedProfile* aProfile, + TUint32 aServer, + const TGSSIPServerData& aProfileData ) + { + __GSLOGSTRING("GSSIPProfileUtil::CopyServerURIL Start" ) + SIPStrings::OpenL(); + + // Set settings to KSIPServerAddress param. + if ( aProfileData.iAddress.Length() > 0 ) + { + HBufC8* finalAddress = HBufC8::NewLC( KMaxProxyLength * 2 ); + + // Convert address to 8-bit descriptor format. + TPtrC addr = aProfileData.iAddress; + HBufC8* conv = EscapeUtils::ConvertFromUnicodeToUtf8L( addr ); + CleanupStack::PushL( conv ); + + // Parse address. + TUriParser8 parser; + User::LeaveIfError( parser.Parse( conv->Des() ) ); + // Append scheme to final address if needed. + if ( !parser.IsPresent( EUriScheme ) ) + { + finalAddress->Des().Append( KSIPProtocolHeader ); + finalAddress->Des().Append( KSIPColonSeparator ); + } + // Append proxy/registrar address to final address. + finalAddress->Des().Append( conv->Des() ); + // Check host type. Add brackets for ipv6 type of address. + TUriParser8 parser2; + User::LeaveIfError( parser2.Parse( finalAddress->Des() ) ); + if ( parser2.IsPresent( EUriHost ) ) + { + const TDesC8& scheme = parser2.Extract( EUriScheme ); + const TDesC8& host = parser2.Extract( EUriHost ); + UriUtils::TUriHostType type = UriUtils::HostType( host ); + if ( type == UriUtils::EIPv6Host ) + { + HBufC8* ipv6Address = HBufC8::NewL( KMaxProxyLength ); + ipv6Address->Des().Append( host ); + GSSIPProfileUtil::AddBrackets( ipv6Address->Des() ); + TBuf8<1> colon ( KNullDesC8 ); + colon.Copy( KSIPColonSeparator ); + ipv6Address->Des().Insert( 0, colon ); + ipv6Address->Des().Insert( 0, scheme ); + finalAddress->Des().Copy( ipv6Address->Des() ); + delete ipv6Address; + } + } + CleanupStack::PopAndDestroy( conv ); + + // Set used port if it's not default one. + if ( aProfileData.iPortNumber != KDefaultPortNumber ) + { + TBuf8 port; + port.Num( aProfileData.iPortNumber ); + finalAddress->Des().Append( KSIPColonSeparator ); + finalAddress->Des().Append( port ); + } + + // Set uri path part if there is something to be added. + HBufC8* finalPath = HBufC8::NewLC( KMaxLengthForPath ); + ParseUriPathL( aProfile, aServer, aProfileData, finalPath ); + finalAddress->Des().Append( finalPath->Des() ); + CleanupStack::PopAndDestroy( finalPath ); + + // Set final address to profile. + TInt err = aProfile->SetParameter( + aServer, KSIPServerAddress, finalAddress->Des() ); + User::LeaveIfError( err ); + + CleanupStack::PopAndDestroy( finalAddress ); + } + // If host is set to empty, empty KSIPServerAddress param. + else + { + TInt err = aProfile->SetParameter( + aServer, KSIPServerAddress, KNullDesC8 ); + User::LeaveIfError( err ); + } + + SIPStrings::Close(); + __GSLOGSTRING("GSSIPProfileUtil::CopyServerURIL End" ) + } + +// ----------------------------------------------------------------------------- +// GSSIPProfileUtil::ParseUriPathL +// Parses uri path. +// ----------------------------------------------------------------------------- +// +void GSSIPProfileUtil::ParseUriPathL( + CSIPManagedProfile* aProfile, + TUint32 aServer, + const TGSSIPServerData& aProfileData, + HBufC8* aFinalPath ) + { + __GSLOGSTRING("GSSIPProfileUtil::ParseUriPathL Start" ) + TInt err( KErrNone ); + + // Add Loose routing param. (if needed) + if ( aServer != KSIPRegistrar && + aProfileData.iLooseRouting == EGSLooseRoutingOn ) + { + aFinalPath->Des().Append( KSegmentSeparator ); + aFinalPath->Des().Append( KLooseRoutingParam ); + } + + // Add Transport param TCP. (if needed) + if ( aProfileData.iTransportProtocol == EGSTranspProtocolTCP ) + { + aFinalPath->Des().Append( KSegmentSeparator ); + aFinalPath->Des().Append( KTransportParamPrefix ); + aFinalPath->Des().Append( KTCP ); + } + + // Add Transport param UDP. (if needed) + if ( aProfileData.iTransportProtocol == EGSTranspProtocolUDP ) + { + aFinalPath->Des().Append( KSegmentSeparator ); + aFinalPath->Des().Append( KTransportParamPrefix ); + aFinalPath->Des().Append( KUDP ); + } + + // Get path data from saved profile. + const TDesC8* serverTxt; + err = aProfile->GetParameter( aServer, KSIPServerAddress, serverTxt ); + User::LeaveIfError( err ); + + if ( serverTxt->Length() ) + { + // Parse address. + TUriParser8 parser; + User::LeaveIfError( parser.Parse( *serverTxt ) ); + if ( parser.IsPresent( EUriPath ) ) + { + const TDesC8& path = parser.Extract( EUriPath ); + + // Put any other params than lr and transport back to string. + TDelimitedPathSegmentParser8 pathSegmentParser; + pathSegmentParser.Parse( path ); + TPtrC8 segment; + while( pathSegmentParser.GetNext( segment ) == KErrNone ) + { + TBuf seg; + seg.Copy( segment ); + seg.LowerCase(); + + if ( seg.Compare( KLooseRoutingParam ) && + seg.Find( KTransportParamPrefix ) ) + { + aFinalPath->Des().Append( KSegmentSeparator ); + aFinalPath->Des().Append( seg ); + } + } + } + } + __GSLOGSTRING("GSSIPProfileUtil::ParseUriPathL End" ) + } + +// ----------------------------------------------------------------------------- +// GSSIPProfileUtil::SchemeIncluded +// Checks if sip or sips scheme included. +// ----------------------------------------------------------------------------- +// +TInt GSSIPProfileUtil::SchemeIncluded( const TDesC8& aAddr, + TBool aHostBrackets ) + { + __GSLOGSTRING("GSSIPProfileUtil::SchemeIncluded" ) + TLex8 lex( aAddr ); + lex.Mark(); + TUint chrCount = 0; + TChar chr = lex.Get(); + while ( chr != 0 && chr != ':' ) + { + chrCount++; + chr = lex.Get(); + } + + TBool sipSchemeIncluded( EFalse ); + if ( chr != 0 ) + { + chrCount++; //include ':' too + TPtrC8 remainder = lex.RemainderFromMark(); + _LIT8(KSIPScheme, "sip:"); + _LIT8(KSIPSScheme, "sips:"); + + // set scheme to lovercase because of comparing + HBufC8* scheme = HBufC8::New( chrCount ); + scheme->Des().Copy( remainder.Left( chrCount ) ); + scheme->Des().LowerCase(); + + if ( !scheme->Compare( KSIPScheme ) || + !scheme->Compare( KSIPSScheme ) ) + { + sipSchemeIncluded = ETrue; + } + + delete scheme; + + if ( aHostBrackets ) + { // check host brackets + if ( sipSchemeIncluded ) + { // scheme separated from uri, check host + if( GSSIPProfileUtil::BracketsIncluded( + remainder.Right( aAddr.Length() - chrCount ) ) == -1 ) + { + sipSchemeIncluded = -1; + } + } + else + { // scheme not included, check host == aAddr + if( GSSIPProfileUtil::BracketsIncluded( aAddr ) == -1) + { + sipSchemeIncluded = -1; + } + } + } + } + + return sipSchemeIncluded; + } + +// ----------------------------------------------------------------------------- +// GSSIPProfileUtil::BracketsIncluded +// Check if brackets included correctly in IPv6 reference. +// ----------------------------------------------------------------------------- +// +TInt GSSIPProfileUtil::BracketsIncluded( TPtrC8 aHost ) + { + __GSLOGSTRING("GSSIPProfileUtil::BracketsIncluded" ) + TBool ret ( ETrue ); + UriUtils::TUriHostType type = UriUtils::HostType( aHost ); + if ( type == UriUtils::EIPv6Host ) + { + TLex8 lex( aHost ); + lex.Mark(); + TUint chrCount = 0; + TChar chr = lex.Get(); + TInt lBracket( KErrNotFound ); + TInt rBracket( KErrNotFound ); + TInt separator( KErrNotFound ); + + while ( chr != 0 ) + { + if ( chr == '[' ) + { + lBracket = chrCount; + } + else if ( chr == ']' ) + { + rBracket = chrCount; + } + else if ( chr == '@' ) + { + separator = chrCount; + } + else + { + } + chrCount++; + chr = lex.Get(); + } + chrCount--; // the last character + + if ( lBracket == KErrNotFound && rBracket == KErrNotFound ) + { //bracets not included, add them + ret = EFalse; + } + else if ( ( lBracket == KErrNotFound && rBracket != KErrNotFound) || + ( lBracket != KErrNotFound && rBracket == KErrNotFound ) ) + { // both brackets not found + ret = KErrNotFound; + } + else if ( lBracket != KErrNotFound && rBracket != KErrNotFound ) + { //brackets are found + if ( !( lBracket == 0 && rBracket == chrCount ) && + !( separator > 0 && lBracket == separator + 1 + && rBracket == chrCount ) ) + { // brackets are placed incorrectly + ret = KErrNotFound; + } + } + else + { + } + } + return ret; + + } + +// ----------------------------------------------------------------------------- +// GSSIPProfileUtil::AddBrackets +// Adds brackets into IPv6 reference. +// ----------------------------------------------------------------------------- +// +void GSSIPProfileUtil::AddBrackets( TPtr8 aHost ) + { + __GSLOGSTRING("GSSIPProfileUtil::AddBrackets" ) + _LIT8( KLBracket, "[" ); + _LIT8( KRBracket, "]" ); + + aHost.Insert( 0, KLBracket ); + aHost.Append( KRBracket ); + } + +// ----------------------------------------------------------------------------- +// GSSIPProfileUtil::RemoveBrackets +// Remove brackets from IPv6 reference. +// ----------------------------------------------------------------------------- +// +void GSSIPProfileUtil::RemoveBrackets( TPtr8 aHost ) + { + __GSLOGSTRING("GSSIPProfileUtil::RemoveBrackets" ) + TInt index; + + index = aHost.Locate( '[' ); + if ( index != KErrNotFound ) + { + aHost.Delete( index, 1 ); + } + + index = aHost.Locate( ']' ); + if ( index != KErrNotFound ) + { + aHost.Delete( index, 1 ); + } + } + +// ----------------------------------------------------------------------------- +// GSSIPProfileUtil::URIValid +// Checks if reference is valid URI. +// ----------------------------------------------------------------------------- +// +TInt GSSIPProfileUtil::URIValid( const TDesC8& aValue ) + { + __GSLOGSTRING("GSSIPProfileUtil::URIValid" ) + TUriParser8 parser; + return parser.Parse(aValue); + } + +// ----------------------------------------------------------------------------- +// GSSIPProfileUtil::ReplaceEscapedSpace +// Replace %20 to ' '. +// ----------------------------------------------------------------------------- +// +void GSSIPProfileUtil::ReplaceEscapedSpace( HBufC8* aValue ) + { + __GSLOGSTRING("GSSIPProfileUtil::ReplaceEscapedSpace" ) + _LIT8( KEscapedSpace, "%20" ); + _LIT8( KSpace, " " ); + TInt pos = KErrNone; + while ( pos != KErrNotFound ) + { + pos = aValue->Des().Find( KEscapedSpace ); + if ( pos != KErrNotFound ) + { + aValue->Des().Replace( pos, 3, KSpace ); + } + } + } + +// End of File