/*

* 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    <escapeutils.h>

#include    <delimitedpathsegment8.h> 

#include    <sipmanagedprofile.h>

#include    <StringLoader.h>

#include 	<uriutils.h>

#include    <sipstrings.h>

#include    <sipaddress.h>

#include    <gssipsettingspluginrsc.rsg> //GUI Resource

#include	<e32const.h>

#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<KSIPProtocolHeaderLength + 1> sipHeader( KSIPProtocolHeader );

        sipHeader.Append( KSIPColonSeparator );

        TBuf<KSIPSProtocolHeaderLength + 1> 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<KSIPProtocolHeaderLength + 1> 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<KSIPSProtocolHeaderLength + 1> 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<TInt>(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<KMaxSegmentLength> 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 =