/*

* Copyright (c) 2007 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:   

*

*/

#include <centralrepository.h>

#include <unsafprotocolscrkeys.h>

#include "cnatfwcenrephandler.h"

#include "natsettingslogs.h"

const TInt KAllowedDomainAndIapKeyCount = 1; 

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

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

// CNATFWCenRepHandler::CNATFWCenRepHandler

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

//

CNATFWCenRepHandler::CNATFWCenRepHandler()

    {

    }

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

// CNATFWCenRepHandler::ConstructL

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

//    

void CNATFWCenRepHandler::ConstructL( const TUid& aRepositoryUid )

    {

    iCenRep = CRepository::NewL( aRepositoryUid );

    }

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

// CNATFWCenRepHandler::NewL

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

//

CNATFWCenRepHandler* CNATFWCenRepHandler::NewL( const TUid& aRepositoryUid )

    {

    __NATSETTINGS( "CNATFWCenRepHandler::NewL" )

    CNATFWCenRepHandler* self =

        new( ELeave ) CNATFWCenRepHandler();

    CleanupStack::PushL( self );

    self->ConstructL( aRepositoryUid );

    CleanupStack::Pop( self );

    return self;

    }

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

// CNATFWCenRepHandler::~CNATFWCenRepHandler

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

//

CNATFWCenRepHandler::~CNATFWCenRepHandler()

    {

    __NATSETTINGS( "CNATFWCenRepHandler::~CNATFWNatSettingsImpl" )

    delete iCenRep;

    }

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

// CNATFWCenRepHandler::ReadDomainSettingsKey

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

//  

TInt CNATFWCenRepHandler::ReadDomainSettingsKey(

    const TDesC8& aDomain, TUint32& aDomainKey ) const

    {

    __NATSETTINGS( "CNATFWCenRepHandler::ReadDomainSettingsKeyL" )

    TInt err( 0 );

    RArray<TUint32> keys;

    TRAPD( systemErr, err = iCenRep->FindEqL( KUNSAFProtocolsDomainMask,

        KUNSAFProtocolsFieldTypeMask, aDomain, keys ) );

    if ( KErrNone != systemErr )

        {

        keys.Close();

        return systemErr;

        }

    TInt count = keys.Count();

    if ( KErrNone == err && KAllowedDomainAndIapKeyCount == count )

        {

        aDomainKey = KUNSAFProtocolsDomainMask ^ keys[0];

        }

    if ( count > KAllowedDomainAndIapKeyCount )

        {

        err = KErrCorrupt;

        }

    keys.Close();

    return err;

    }

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

// CNATFWCenRepHandler::ReadIapSettingsKey

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

//  

TInt CNATFWCenRepHandler::ReadIapSettingsKey(

    TInt aIapId, TUint32& aIapKey ) const

    {

    __NATSETTINGS( "CNATFWCenRepHandler::ReadIapSettingsKeyL" )

    TInt err( 0 );

    RArray<TUint32> keys;

    TRAPD( systemErr, err = iCenRep->FindEqL( KUNSAFProtocolsIAPIdMask,

        KUNSAFProtocolsFieldTypeMask, aIapId, keys ) );

    if ( KErrNone != systemErr )

        {

        keys.Close();

        return systemErr;

        }

    TInt count = keys.Count();

    if ( KErrNone == err && KAllowedDomainAndIapKeyCount == count )

        {

        aIapKey = KUNSAFProtocolsIAPIdMask ^ keys[0];

        }

    if ( count > KAllowedDomainAndIapKeyCount )

        {

        err = KErrCorrupt;

        }

    keys.Close();

    return err;

    }

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

// CNATFWCenRepHandler::FindServerKeys

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

//

TInt CNATFWCenRepHandler::FindServerKeys( TUint32 aPartialId,

    RArray<TUint32>& aFoundKeys ) const

    {

    const TUint32 KMaskForAllServerSettingsIds = 0xff000fff;

    TInt error( 0 );

    RArray<TUint32> serverKeys;

    TRAPD( systemErr, error = iCenRep->FindL( aPartialId,

        KMaskForAllServerSettingsIds, serverKeys ) );

    if ( KErrNone != systemErr )    

        {

        serverKeys.Close();

        return systemErr;

        }

    if ( KErrNone == error )

        {

        TInt count = serverKeys.Count();

        for ( TInt i( 0 ); i < count; i++ )

            {

            error = aFoundKeys.Append( serverKeys[i] & KUNSAFProtocolsSubKeyMask );

            }

        for ( TInt j( 0 ); j < aFoundKeys.Count(); j++ )

            {

            for ( TInt i( j + 1 ); i < aFoundKeys.Count(); )

                {

                if ( aFoundKeys[ i ] == aFoundKeys[ j ] )

                    {

                    aFoundKeys.Remove( i );

                    }

                else

                    {

                    i++;

                    }

                }

            }

        }

    serverKeys.Close();

    return error;

    }

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

// CNATFWCenRepHandler::CreateNewKeyL

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

//  

TUint32 CNATFWCenRepHandler::CreateNewKeyL(

    const TUint32 aSettingKeyMask, const TUint32 aField ) const

    {

    TUint32 newKey( 0 );

    RArray<TUint32> keys;

    CleanupClosePushL( keys );

    TInt err( iCenRep->FindL( aSettingKeyMask, aField, keys ) );

    TInt keyCount( keys.Count() );

    if ( KErrNotFound == err )

        {

        newKey = aField + 1;

        }

    else

        {

        User::LeaveIfError( err );

        if ( !keyCount )

            {

            newKey = aField + 1;

            }

        else

            {

            // Find the biggest key and increment it by one

            keys.SortUnsigned();

            TUint32 maxKey = aSettingKeyMask ^ keys[keyCount - 1];  

            newKey = aField + 1 + maxKey;

            }

        }

    newKey |= aField; 

    newKey ^= aField;

    CleanupStack::PopAndDestroy( &keys );

    return newKey;

    }

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

// CNATFWCenRepHandler::ReadL

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

//

HBufC8* CNATFWCenRepHandler::ReadL( const TUint32& aKey ) const

    {

    HBufC8* buffer = NULL;

    TBuf8<1> tmp;

    TInt actualLength( 0 );

    TInt status = iCenRep->Get( aKey, tmp, actualLength );

    if ( ( KErrNone == status || KErrOverflow == status ) )

        {

        if( actualLength )

            {

            buffer = HBufC8::NewLC( actualLength );

            TPtr8 ptr( buffer->Des() );

            User::LeaveIfError( iCenRep->Get( aKey, ptr ) );

            CleanupStack::Pop( buffer );

            }

        else

            {

            buffer = KNullDesC8().AllocL();

            }

        }

    return buffer;

    }

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

// CNATFWCenRepHandler::ReadBoolValue

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

//

TInt CNATFWCenRepHandler::ReadBoolValue(

    const TUint32& aKey, TBool& aKeyValue ) const

    {

    TInt err = KErrNotFound;

    TInt tmp( 0 );

    if ( KErrNone == iCenRep->Get( aKey, tmp ) )

        {

        aKeyValue = ( tmp != 0 );

        err = KErrNone;

        }

    return err;

    }

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

// CNATFWCenRepHandler::Read

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

//

TInt CNATFWCenRepHandler::Read(

    const TUint32& aKey, TUint& aKeyValue ) const

    {

    TInt err = KErrNotFound;

    TInt tmp;

    if ( KErrNone == iCenRep->Get( aKey, tmp ) )

        {

        aKeyValue = static_cast<TUint>( tmp );

        err = KErrNone;

        }

    return err;

    }

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

// CNATFWCenRepHandler::Read

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

//

TInt CNATFWCenRepHandler::Read(

    const TUint32& aKey, TInt& aKeyValue ) const

    {

    TInt readKeyValue( 0 );

    if ( KErrNone == iCenRep->Get( aKey, readKeyValue ) )

        {

        aKeyValue = readKeyValue;

        }

    else

        {

        return KErrNotFound;

        }

    return KErrNone;

    }