/*

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

*

*/

#include <centralrepository.h>

#include <unsafprotocolscrkeys.h>

#include "CTcSIPContext.h"

#include "TCmdUNSAFTimers.h"

#include "SIPConstants.h"

//NOTE: This value must be same as in CUNSAFCRSettings.h

const TInt KMaxServerNameLen = 256;

TInt TCmdUNSAFTimers::ReadTimerValuesL( CRepository& aRepository,

									    TUint32& aKey,

									    TInt& aBindingRequestInterval,

									    TInt& aUdpKeepAliveInterval,

									    TInt& aTcpKeepAliveInterval ) const

	{

	TPtrC8 iapName = ExtractTextL( KParamIAPName, EFalse );

	if( iapName != KNullDesC8 )

		{

		return ReadIapTimersL( aRepository,

							   // Leaves if not found

							   iContext.IAPIdL( iapName ),

							   aKey,

							   aBindingRequestInterval,

							   aUdpKeepAliveInterval,

							   aTcpKeepAliveInterval );

		}

	// Since IAP was not given, domain is mandatory	

	TPtrC8 domainName = ExtractTextL( KParamDomainName, ETrue );

	return ReadDomainTimersL( aRepository,									 

							  domainName,

							  aKey,

							  aUdpKeepAliveInterval,

							  aTcpKeepAliveInterval );	

	}

TInt TCmdUNSAFTimers::ReadIapTimersL( CRepository& aRepository,

									  TInt aIapId,

									  TUint32& aKey,

									  TInt& aBindingRequestInterval,

									  TInt& aUdpKeepAliveInterval,

									  TInt& aTcpKeepAliveInterval ) const

    {

    TInt status = FindIapKeyL( aRepository, aIapId, aKey );

    if ( status == KErrNone )

    	{

    	// It doesn't matter if some parameter doesn't exist

        Read( aRepository,

        	  KUNSAFProtocolsIntervalUDPMask | aKey,

              aUdpKeepAliveInterval );

        Read( aRepository,

        	  KUNSAFProtocolsIntervalTCPMask | aKey,

              aTcpKeepAliveInterval );

        Read( aRepository,

        	  KUNSAFProtocolsSTUNRetransmitTimerMask | aKey,

              aBindingRequestInterval );

    	}

    return status;

    }

TInt TCmdUNSAFTimers::FindIapKeyL( CRepository& aRepository,

								   TInt aIapId,

								   TUint32& aKey ) const

    {

    RArray<TUint32> keys;

    CleanupClosePushL( keys );

    TInt err = aRepository.FindL( KUNSAFProtocolsIAPIdMask,

                                  KUNSAFProtocolsFieldTypeMask,

                                  keys );

	TInt ret = KErrNotFound;

    if ( err == KErrNone && keys.Count() > 0 )

        {

        for ( TInt i = 0; i < keys.Count() && ret == KErrNotFound; i++ )

            {

            TUint32 key = ( KUNSAFProtocolsIAPIdMask ^ ( keys[ i ] ) );

            key |= KUNSAFProtocolsIAPTableMask;

  			TInt iapId( 0 );

            Read( aRepository, KUNSAFProtocolsIAPIdMask | key, iapId );

            if ( iapId == aIapId )

            	{

            	aKey = key;	            

	            ret = KErrNone;

            	}

            }

        }

    CleanupStack::PopAndDestroy( &keys );

    return ret;

    }

TInt TCmdUNSAFTimers::ReadDomainTimersL( CRepository& aRepository,							

										 TPtrC8 aDomain,

										 TUint32& aKey,

										 TInt& aUdpKeepAliveInterval,

										 TInt& aTcpKeepAliveInterval ) const

    {

    TInt status = FindDomainKeyL( aRepository, aDomain, aKey );

    if ( status == KErrNone )

    	{

    	Read( aRepository,

    	  	  KUNSAFProtocolsDomainIntervalUDPMask | aKey,

          	  aUdpKeepAliveInterval );

		Read( aRepository,

    	  	  KUNSAFProtocolsDomainIntervalTCPMask | aKey,

          	  aTcpKeepAliveInterval );

    	}

    return status;

    }

TInt TCmdUNSAFTimers::FindDomainKeyL( CRepository& aRepository,							

									  TPtrC8 aDomain,

									  TUint32& aKey ) const

    {

    RArray<TUint32> keys;

    CleanupClosePushL( keys );

    TInt err = aRepository.FindL( KUNSAFProtocolsDomainMask,

                                  KUNSAFProtocolsFieldTypeMask,

                                  keys );

	TInt ret = KErrNotFound;

    if ( err == KErrNone && keys.Count() > 0 )

        {

        for ( TInt i = 0; i < keys.Count() && ret == KErrNotFound; i++ )

            {

            TUint32 key = ( KUNSAFProtocolsDomainMask ^ ( keys[ i ] ) );

            key |= KUNSAFProtocolsDomainTableMask;

            TBuf8<KMaxServerNameLen> domain;

            if ( ( Read( aRepository,

            		     KUNSAFProtocolsDomainMask | key,

                         domain ) == KErrNone ) &&

                 ( domain == aDomain ) )

        		{

        		aKey = key;     

                ret = KErrNone;

        		}

            }

        }

    CleanupStack::PopAndDestroy( &keys );

    return ret;

    }

void TCmdUNSAFTimers::Read( CRepository& aRepository,

						    const TUint32& aKey,

							TInt& aKeyValue ) const

    {

    TInt tmp( 0 );

    if ( aRepository.Get( aKey, tmp ) == KErrNone )

        {

        aKeyValue = tmp;     

        }    

    }

TInt TCmdUNSAFTimers::Read( CRepository& aRepository,

							const TUint32& aKey,

							TDes8& aKeyValue ) const

    {

    TBuf8<1> tmp;

    TInt actualLength = 0;

    // This Get call returns KErrOverflow, but it doesn't matter as we are only

    // interested in actualLength.

    aRepository.Get( aKey, tmp, actualLength );

	if ( actualLength <= 0 || actualLength > aKeyValue.MaxLength() )

		{

		return KErrOverflow;

		}

    return aRepository.Get( aKey, aKeyValue );

    }

// Allow writing value zero, so that STUN client's behaviour can be tested also

// in such case. If aKeyValue is KErrNotFound, then application didn't provide

// it, and it is not written.

void TCmdUNSAFTimers::WriteL( CRepository& aRepository,

						      const TUint32& aKey,

						      TInt aKeyValue ) const

    {

    if ( aKeyValue != KErrNotFound )

    	{

    	User::LeaveIfError( aRepository.Set( aKey, aKeyValue ) );

    	}    

    }

void TCmdUNSAFTimers::WriteL( CRepository& aRepository,

						      const TUint32& aKey,

						      const TDesC8& aKeyValue ) const

    {

    if ( aKeyValue != KNullDesC8 )

    	{

    	User::LeaveIfError( aRepository.Set( aKey, aKeyValue ) );

    	}    

    }

TUint32 TCmdUNSAFTimers::CreateNewKeyL( CRepository& aRepository,

										TUint32 aKey,

										TUint32 aTable ) const

    {

    const TUint32 KInitialKey = 1;

	TUint32 newKey = KInitialKey;

    RArray<TUint32> keys;

    CleanupClosePushL( keys );

    TInt err = aRepository.FindL( aKey,

                                  KUNSAFProtocolsFieldTypeMask,

                                  keys );

    if ( err != KErrNotFound )

        {

        User::LeaveIfError( err );

        TInt keyCount = keys.Count();

        if ( keyCount != 0 )

            {

            // Find the biggest key and increment it by one

            keys.SortUnsigned();

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

            newKey = maxKey + 1;

            }

        }

    newKey |= aTable;

    CleanupStack::PopAndDestroy( &keys );

    return newKey;

    }

void TCmdUNSAFTimers::RemoveParameterL( CRepository& aRepository,

										TUint32 aKey ) const

	{

	const TUint32 KSingleKeyMask = 0xffffffff;

	TUint32 dummy( 0 );

	TInt status = aRepository.Delete( aKey, KSingleKeyMask, dummy );

	__ASSERT_ALWAYS( status == KErrNone || status == KErrNotFound,

					 User::Leave( status ) );	

	}