/*

* Copyright (c) 2007-2009 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:  Provides static utility functions for SCP

*

*/

#include <e32property.h>

#include <crcseprofileregistry.h>

#include <ccherror.h>

#include <siperr.h>

#include "scputility.h"

#include "scplogger.h"

const TScpUtility::SCchErrorMapping TScpUtility::iErrorTable[] = 

    {

        { KCCHErrorInvalidSettings, KErrArgument },

        { KCCHErrorAccessPointNotDefined, KErrBadName },

        { KCCHErrorAuthenticationFailed, KErrSIPForbidden }

    };

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

// TScpUtility::ConvertToConnectionEvent

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

//

TScpConnectionEvent TScpUtility::ConvertToConnectionEvent( 

    CScpSipConnection::TConnectionState aState,

    TInt aError )

    {

    TScpConnectionEvent returnEvent( EScpUnknown );    

    switch( aState )

        {

        case CScpSipConnection::ERegistered:

            {

            returnEvent = EScpRegistered;    

            }

            break;

        case CScpSipConnection::ERegistering:

            {

            if( aError == KErrNone )

                {

                returnEvent = EScpNetworkFound;

                }

            else if( aError == KCCHErrorNetworkLost )

                {

                returnEvent = EScpNetworkLost;

                }

            else

                {

                returnEvent = EScpRegistrationFailed;

                }

            }

            break;

        case CScpSipConnection::EDeregistered:

            {

            returnEvent = EScpDeregistered;

            }

            break;

        case CScpSipConnection::EDeregistering:

            {

            returnEvent = EScpNetworkNotFound;

            }

            break;

        default:

            User::Panic( KNullDesC, KErrGeneral );

            break;

        }

    return returnEvent;

    }

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

// TScpUtility::ConvertToConnectionEvent

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

//

TScpConnectionEvent TScpUtility::ConvertToConnectionEvent( 

    TCCHSubserviceState aState )

    {

    TScpConnectionEvent returnEvent( EScpUnknown );    

    switch( aState )

        {

        case ECCHEnabled:

            {

            returnEvent = EScpRegistered;

            }

            break;

        case ECCHConnecting:

            {

            returnEvent = EScpNetworkFound;

            }

            break;

        case ECCHDisabled:

            {

            returnEvent = EScpDeregistered;

            }

            break;

        case ECCHDisconnecting:

            {

            returnEvent = EScpNetworkNotFound;

            }

            break;

        default:

            User::Panic( KNullDesC, KErrGeneral );

            break;

        }

    return returnEvent;

    }

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

// TScpUtility::ResetAndDestroyEntries

// (other items were commented in a header).

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

//

void TScpUtility::ResetAndDestroyEntries( TAny* anArray )

    {

    SCPLOGSTRING( "TScpUtility::ResetAndDestroyEntries" );

    RPointerArray<CRCSEProfileEntry>* array = 

        reinterpret_cast<RPointerArray<CRCSEProfileEntry>*>( anArray );

    if (array)

        {

        array->ResetAndDestroy();

        array->Close();

        }

    }

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

// TScpUtility::ConvertToCchError

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

//

TInt TScpUtility::ConvertToCchError( TInt aErrorCode )

    {

    TInt count = sizeof( iErrorTable ) / sizeof( struct SCchErrorMapping );

    TInt error = KErrUnknown;

    while( count-- )

        {

        if ( iErrorTable[ count ].iProtocolError == aErrorCode )

            {

            error = iErrorTable[ count ].iServiceError;

            break;

            }

        }

    return error; 

    }

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

// TScpUtility::RemovePrefixAndDomain

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

//

TInt TScpUtility::RemovePrefixAndDomain( const TDesC8& aUsername, 

    RBuf8& aFormattedUsername )

    {

    TInt err( KErrNone );

    TInt startPosition = aUsername.Find( KColon() );

    if ( KErrNotFound == startPosition )

        {

        startPosition = 0;

        }

    else

        {

        startPosition = ( startPosition + KColon().Length() );

        }

    TInt endPos = aUsername.Find( KAt() );

    if ( KErrNotFound == endPos )

        {

        endPos = ( aUsername.Length() - startPosition );

        }            

    else

        {

        endPos = ( endPos - startPosition );

        }

    TPtrC8 formatted = aUsername.Mid( startPosition, endPos );            

    err = aFormattedUsername.Create( formatted.Length() );

    if ( KErrNone == err )

        {

        aFormattedUsername.Copy( formatted );

        }

    return err;

    }

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

// TScpUtility::CheckSipUsername

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

//

TBool TScpUtility::CheckSipUsername( const TDesC8& aUsername )

    {

    TInt retval = ETrue;

    if ( KErrNotFound != aUsername.Find( KSipScheme() ) || 

         KErrNotFound != aUsername.Find( KAt() ) )

        {

        SCPLOGSTRING( "TScpUtility::CheckSipUsername: username has prefix or domain" );

        retval = EFalse;

        }

    if( aUsername == KNullDesC8 )

        {

        SCPLOGSTRING( "TScpUtility::CheckSipUsername: username is empty - not allowed" );

        retval = EFalse;

        }

    return retval; 

    }

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

// TScpUtility::CheckSipPassword

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

//

TBool TScpUtility::CheckSipPassword( const TDesC8& /*aPassword*/ )

    {

    TInt retval = ETrue;

    return retval; 

    }

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

// TScpUtility::GetValidPrefix

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

//

void TScpUtility::GetValidPrefix( const TDesC8& aUsername, TDes8& aPrefix )

    {

    // no prefix -> use sip:

    aPrefix.Copy( KSipScheme() );

    TInt index = aUsername.Find( KColon() );

    if ( KErrNotFound != index )

        {

        index += KColon().Length();

        // if prefix isn't sip or sips, prefix isn't valid

        if ( !aUsername.Left( index ).Compare( KSipScheme() ) )

            {

            aPrefix.Copy( KSipScheme() );

            }

        else if ( !aUsername.Left( index ).Compare( KSipsScheme() ) )

            {

            aPrefix.Copy( KSipsScheme() );

            }

        else

            {

            // prefix not valid -> use sip:

            }

        }

    SCPLOGSTRING2( "TScpUtility::GetValidPrefix: %S", &aPrefix );

    }

// ========================== OTHER EXPORTED FUNCTIONS =========================

//  End of File