/*

* Copyright (c) 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:  Validation methods for checking username etc.

*

*/

// INCLUDE FILES

#include    <StringLoader.h>

#include    <escapeutils.h>

#include    <AknUtils.h>

#include    <sipstrings.h>

#include    <sipaddress.h>

#include    <gssipsettingspluginrsc.rsg> //GUI Resource

#include    "sipserversettingvalidator.h"

#include    "tsipsettingsdata.h"

#include    "gssipprofileutil.h"

#include    "gssippluginlogger.h"

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// SIPServerSettingValidator::SIPServerSettingValidator

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

// might leave.

// -----------------------------------------------------------------------------

//

SIPServerSettingValidator::SIPServerSettingValidator()

    {

    __GSLOGSTRING("SIPServerSettingValidator::SIPServerSettingValidator" )

    }

// -----------------------------------------------------------------------------

// SIPServerSettingValidator::ValidateServerUsernameL

// Validates proxy/registrar server username

// -----------------------------------------------------------------------------

//

TBool SIPServerSettingValidator::ValidateServerUsernameL( 

    TAny* aDes )

    {  

    __GSLOGSTRING("SIPServerSettingValidator::ValidateServerUsernameL" )

    __ASSERT_ALWAYS( aDes != NULL, User::Leave( KErrArgument ) );

    TBool result( EFalse );

    TDes* desPtr = static_cast<TDes*>( aDes );

    TDes& des = *desPtr;

	if ( des.Length() == 0 )    

		{

		return ETrue;

		}

    SIPStrings::OpenL();    // Needed for CSIPAddress.

    AknTextUtils::StripCharacters( des, KAknStripListControlChars );

    // Check that scheme is found from setting data.

    TBool protocolFound( EFalse );

    TBuf<KSIPProtocolHeaderLength + 1> sipHeader( KSIPProtocolHeader );

    sipHeader.Append( KSIPColonSeparator );

    TBuf<KSIPSProtocolHeaderLength + 1> sipsHeader( KSIPSProtocolHeader );

    sipsHeader.Append( KSIPColonSeparator );

    if ( des.Length() > KSIPProtocolHeaderLength )

        {

        if ( !sipHeader.Compare( 

            des.Left( KSIPProtocolHeaderLength + 1 ) ) )

            {

            protocolFound = ETrue;

            }

        }

    if ( des.Length() > KSIPSProtocolHeaderLength )

        {

        if ( !sipsHeader.Compare( 

            des.Left( KSIPSProtocolHeaderLength + 1 ) ) )

            {

            protocolFound = ETrue;

            }

        }   

    // Create address to be validated.

    HBufC8* tmp = EscapeUtils::ConvertFromUnicodeToUtf8L( des );

    CleanupStack::PushL( tmp );

    HBufC8* conv = NULL; 

    if ( !protocolFound )

        {

        conv = HBufC8::NewLC( sipHeader.Length() + tmp->Length() );

        conv->Des().Copy( sipHeader );    

        conv->Des().Append( tmp->Des() );

        }

    else

        {

        conv = EscapeUtils::ConvertFromUnicodeToUtf8L( des );

        CleanupStack::PushL( conv );

        }    

    EscapeUtils::TEscapeMode mode = EscapeUtils::EEscapeNormal;

    HBufC8* enc = EscapeUtils::EscapeEncodeL( conv->Des(), mode );

    CleanupStack::PushL( enc );

    CSIPAddress* addr = CSIPAddress::DecodeL( enc->Des() );

    CleanupStack::PushL( addr );

    // Finally, validate entered host.

    if ( addr->Uri8().Uri().Validate() == KErrNone )

        {

        result = ETrue;

        }

    // PopAndDestroy all items in CleanupStack.

    CleanupStack::PopAndDestroy( addr ); 

    CleanupStack::PopAndDestroy( enc );

    CleanupStack::PopAndDestroy( conv );

    CleanupStack::PopAndDestroy( tmp );

    SIPStrings::Close();

    return result;

    }

// -----------------------------------------------------------------------------

// SIPServerSettingValidator::ValidateServerAddressL

// Validates proxy/registrar server address

// -----------------------------------------------------------------------------

//

TBool SIPServerSettingValidator::ValidateServerAddressL( TAny* aDes )

    {   

    __GSLOGSTRING("SIPServerSettingValidator::ValidateServerAddressL" )

    __ASSERT_ALWAYS( aDes != NULL, User::Leave( KErrArgument ) );

    TBool result( ETrue );

    TBool onlySpaces( ETrue );

    SIPStrings::OpenL();    // Needed for CSIPAddress.

    TDes* desPtr = static_cast<TDes*>( aDes );

    TDes& des = *desPtr;

    AknTextUtils::StripCharacters( des, KAknStripListControlChars );

    // Check that is there other characters than spaces.

    for ( TInt i = 0; i < des.Length() && onlySpaces; i++ )

        {

        const TChar KSpaceCharacter = ' ';

        if ( des[ i ] != KSpaceCharacter )

            {

            onlySpaces = EFalse;

            }

        }

    // Allow user set spaces, spaces are removed elsewhere.

    if ( !onlySpaces )

        {

        HBufC8* finalAddress = HBufC8::NewLC( KMaxProxyLength * 2 );

        // Convert address to 8-bit descriptor format.

        HBufC8* conv = EscapeUtils::ConvertFromUnicodeToUtf8L( des );

        CleanupStack::PushL( conv );

        // Parse address.

        TUriParser8 parser;

        User::LeaveIfError( parser.Parse( conv->Des() ) );

        // Check if scheme included and also if brackets in host correctly.

        TInt sipSchemeIncluded = 

        	GSSIPProfileUtil::SchemeIncluded( conv->Des(), ETrue );

        if ( sipSchemeIncluded == KErrNotFound )

        	{ 

        	// Brackets in host incorrectly.

        	result = EFalse;

        	}

        else if ( !sipSchemeIncluded && parser.IsPresent( EUriScheme ) )

			{

			// Scheme exists but it's not "sip" or "sips" scheme.

			result = EFalse;

			}

		else if ( !sipSchemeIncluded )

		    {

		    // Create address for validation. Scheme is added.

		    finalAddress->Des().Append( KSIPProtocolHeader );

		    finalAddress->Des().Append( KSIPColonSeparator );

		    finalAddress->Des().Append( conv->Des() );

		    if ( GSSIPProfileUtil::URIValid( *finalAddress ) )

		        {

		        result = EFalse;

		        }

		    }

		else

			{

			// Create address for validation.

			finalAddress->Des().Append( conv->Des() );

			if ( GSSIPProfileUtil::URIValid( *finalAddress ) )

				{

				result = EFalse;

				}

			}

		CleanupStack::PopAndDestroy( conv );

		// Validate entered host.

    	if ( result )    	

    		{

    		User::LeaveIfError( parser.Parse( *finalAddress ) );

            if ( parser.Validate() != KErrNone )

                {

                result = EFalse;

                }

    		}

        CleanupStack::PopAndDestroy( finalAddress );

        }

    SIPStrings::Close();

    return result;

    }

//  End of File