diff -r 000000000000 -r 1bce908db942 multimediacommsengine/tsrc/testdriver/siptester/src/TCmdUNSAFTimers.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/multimediacommsengine/tsrc/testdriver/siptester/src/TCmdUNSAFTimers.cpp	Tue Feb 02 01:04:58 2010 +0200
@@ -0,0 +1,252 @@
+/*
+* 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 ) );	
+	}