// Copyright (c) 2008-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:

// Name          : sipsecdigestcache.cpp

// Part of       : SIPSec

// Version       : SIP/6.0

//

#include "SipLogs.h"

#include "siperr.h"

#include "SipAssert.h"

#include "sipsecdigestcache.h"

#include "CSIPSecDigestCacheEntry.h"

#include "CSIPSecDigestObserver.h"

#include "CSIPSecUserRecord.h"

#include "CSIPSecSIMRecord.h"

#include "CSIPSecCredentials.h"

#include "CSIPSecChallengeAKA.h"

#include "RSIPSecChallengeResolver.h"

#include "MSIPSecUser.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "siprequest.h"

#include "sipresponse.h"

#include "sipsecdigestcontext.h"

#include "sipauthenticateheaderbase.h"

const TInt TSIPSecDigestCacheEntryIterator::iSIPSecOffset =

	_FOFF( TSIPSecDigestCacheEntryIterator, iLink );

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

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

// CSIPSecDigestCache::NewL

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

//

CSIPSecDigestCache* CSIPSecDigestCache::NewL( MTimerManager& aTimerManager )

	{

	CSIPSecDigestCache* self = NewLC( aTimerManager );

	CleanupStack::Pop( self );

	return self;

	}

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

// CSIPSecDigestCache::NewLC

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

//		

CSIPSecDigestCache* CSIPSecDigestCache::NewLC( MTimerManager& aTimerManager )

	{

	CSIPSecDigestCache* self =

		new ( ELeave ) CSIPSecDigestCache( aTimerManager );

	CleanupStack::PushL( self );

	return self;

	}

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

// CSIPSecDigestCache

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

//	

CSIPSecDigestCache::CSIPSecDigestCache( MTimerManager& aTimerManager ) :

	iProxyList( CSIPSecDigestCacheEntry::iSIPSecOffset ),

	iProxyListIter( iProxyList ),

	iEndpointList( CSIPSecDigestCacheEntry::iSIPSecOffset ),

	iEndpointListIter( iEndpointList ),

	iCredentialsList( CSIPSecUserRecord::iSIPSecOffset ),

	iCredentialsListIter( iCredentialsList ),

#ifdef CPPUNIT_TEST

	// Use granularity 1 to make each append operation to allocate memory.

  	iDigestObservers( 1 ),

#endif

	iTimerManager( aTimerManager )

	{

	}	

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

// ~CSIPSecDigestCache

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

//	

CSIPSecDigestCache::~CSIPSecDigestCache()

	{

	RemoveAllEntries();

	RemoveAllCredentials();

	iDigestObservers.ResetAndDestroy();

	}

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

// CSIPSecDigestCache::InitializeIterator

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

//

void

CSIPSecDigestCache::InitializeIterator( TSIPSecDigestCacheIterator& aIterator )

    {

    iProxyListIter.SetToFirst();

    iEndpointListIter.SetToFirst();

    aIterator.iList.Reset();

    aIterator.iList.AddLast( iProxyListIter );

    aIterator.iList.AddLast( iEndpointListIter );

    aIterator.iListIterator.SetToFirst();

    }

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

// CSIPSecDigestCache::AddEntry

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

//

void CSIPSecDigestCache::AddEntry( CSIPSecDigestCacheEntry* aCacheEntry )

	{

	__SIP_ASSERT_RETURN( aCacheEntry, KErrArgument );

	__SIP_ASSERT_RETURN( !IsEntryInCache( *aCacheEntry ), KErrAlreadyExists );

	SelectCache( *aCacheEntry ).AddLast( *aCacheEntry );

	}

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

// CSIPSecDigestCache::RemoveEntry

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

//

void CSIPSecDigestCache::RemoveEntry( CSIPSecDigestCacheEntry& aCacheEntry )

	{

	__SIP_ASSERT_RETURN( IsEntryInCache( aCacheEntry ), KErrNotFound );

	aCacheEntry.UserData().CredentialsDetach();

    SelectCache( aCacheEntry ).Remove( aCacheEntry );

	delete &aCacheEntry;

	}

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

// CSIPSecDigestCache::RemoveCacheEntry

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

//

TBool CSIPSecDigestCache::RemoveCacheEntry( CSIPSecDigestCacheEntry& aEntry,

											const MSIPSecUser& aUser )

	{

	CSIPSecUserRecord& record = aEntry.UserData();

    RemoveEntry( aEntry );

	if ( record.CredentialsAttached() )

		{

		ChangeRecordUserIfNeeded( record, aUser );

		return EFalse;

		}

	__SIP_LOG( "SIPSecDigestCache:RemoveCacheEntry record not used" )

	__SIP_ASSERT_RETURN_VALUE( IsCredentialsInList( record ), KErrNotFound );

	iCredentialsList.Remove( record );

	delete &record;

	return ETrue;

	}

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

// CSIPSecDigestCache::IsEntryInCache

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

//

TBool CSIPSecDigestCache::IsEntryInCache( CSIPSecDigestCacheEntry& aCacheEntry )

	{

    TSIPSecDigestCacheEntryIterator entryIterator =

		TSIPSecDigestCacheEntryIterator( SelectCache( aCacheEntry ) );

	CSIPSecDigestCacheEntry* entry( NULL );

	TBool found( EFalse );

	while ( !found && ( entry = entryIterator.Next() ) != NULL )

		{

		found = ( entry == &aCacheEntry );

		}

	return found;

	}

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

// CSIPSecDigestCache::SelectCache

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

//

TSglQue< CSIPSecDigestCacheEntry >&

CSIPSecDigestCache::SelectCache( const CSIPSecDigestCacheEntry& aCacheEntry )

	{

	if ( aCacheEntry.Type() == CSIPSecDigest::EEndPoint )

		{

		return iEndpointList;

		}

	return iProxyList;

	}

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

// CSIPSecDigestCache::AddUserCredentials

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

//		

void CSIPSecDigestCache::AddUserCredentials( CSIPSecUserRecord* aCredentials )

	{

	__SIP_ASSERT_RETURN( aCredentials, KErrArgument );

	__SIP_ASSERT_RETURN( !IsCredentialsInList( *aCredentials ),

						 KErrAlreadyExists );

    iCredentialsList.AddLast( *aCredentials );

	}

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

// CSIPSecDigestCache::SearchRecordForResponse

// Cache can have only one entry with matching MSIPSecUser and realm.

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

//

CSIPSecUserRecord*

CSIPSecDigestCache::SearchRecordForResponse( const TDesC8& aRealm,

			  					  			 const MSIPSecUser& aUser,

			  					  			 TRegistrationId aRegistrationId )

	{

	__ASSERT_ALWAYS( aRealm.Length() > 0,

		User::Panic( _L( "DigestCache:SearchRecForResp" ), KErrArgument ) );

	CSIPSecUserRecord* record( NULL );

	iCredentialsListIter.SetToFirst();

	while ( ( record = iCredentialsListIter++ ) != NULL )

		{

		if ( record->IsSameRealm( aRealm ) &&

			 record->CompareUser( aUser, aRegistrationId ) )

			{

			return record;

			}

		}

	return NULL;

	}

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

// CSIPSecDigestCache::SearchRecord

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

//

CSIPSecUserRecord*

CSIPSecDigestCache::SearchRecord( const TDesC8& aRealm,

							      TTransactionId aTransactionId )

	{

	__ASSERT_ALWAYS( aRealm.Length() > 0,

		User::Panic( _L( "DigestCache:SearchRec(id)" ), KErrArgument ) );

	CSIPSecUserRecord* record( NULL );

	iCredentialsListIter.SetToFirst();

	while ( ( record = iCredentialsListIter++ ) != NULL )

		{

		if ( record->IsSameRealm( aRealm ) &&

			 record->TransactionIdPassedToClient() == aTransactionId )

			{

			return record;

			}

		}

	return NULL;

	}

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

// CSIPSecDigestCache::SearchRecord

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

//

CSIPSecUserRecord* CSIPSecDigestCache::SearchRecord( const TDesC8& aRealm,

			  					  					 const MSIPSecUser& aUser )

	{

	__ASSERT_ALWAYS( aRealm.Length() > 0,

		User::Panic( _L( "DigestCache:SearchRec(user)" ), KErrArgument ) );

	CSIPSecUserRecord* record( NULL );

	iCredentialsListIter.SetToFirst();

	while ( ( record = iCredentialsListIter++ ) != NULL )

		{

		if ( record->IsSameRealm( aRealm ) && &aUser == &record->SIPSecUser() )

			{

			return record;

			}

		}

	return NULL;

	}

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

// CSIPSecDigestCache::RemoveAllEntries

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

//

void CSIPSecDigestCache::RemoveAllEntries()

	{

	RemoveAllEntriesFromList( iProxyList );

	RemoveAllEntriesFromList( iEndpointList );

	}

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

// CSIPSecDigestCache::RemoveAllEntriesFromList

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

//

void CSIPSecDigestCache::RemoveAllEntriesFromList(

	TSglQue<CSIPSecDigestCacheEntry>& aList )

	{

	if ( !aList.IsEmpty() )

		{

		CSIPSecDigestCacheEntry* entry( NULL );

    	TSIPSecDigestCacheEntryIterator entryIterator =

    		TSIPSecDigestCacheEntryIterator( aList );

		while ( ( entry = entryIterator.Next() ) != NULL )

			{

			aList.Remove( *entry );

			delete entry;

			}

		}

	}

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

// CSIPSecDigestCache::RemoveAllCredentials

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

//		

void CSIPSecDigestCache::RemoveAllCredentials()

	{

	if ( !iCredentialsList.IsEmpty() )

		{

		CSIPSecUserRecord* record( NULL );

		iCredentialsListIter.SetToFirst();

		while ( ( record = iCredentialsListIter++ ) != NULL )

			{

			iCredentialsList.Remove( *record );

			delete record;

			}

		}		

	}

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

// CSIPSecDigestCache::IsCredentialsInList

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

//

TBool CSIPSecDigestCache::IsCredentialsInList(

	const CSIPSecUserRecord& aCredentials )

	{

	if ( !iCredentialsList.IsEmpty() )

		{

		CSIPSecUserRecord* record( NULL );

		iCredentialsListIter.SetToFirst();

		while ( ( record = iCredentialsListIter++ ) != NULL )

			{

			if ( record == &aCredentials )

				{

				return ETrue;

				}

			}

		}

	return EFalse;

	}

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

// CSIPSecDigestCache::ClearCache

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

//

void CSIPSecDigestCache::ClearCache( const MSIPSecUser& aUser )

	{

	RemoveUsedEntry( iProxyList, aUser );

	RemoveUsedEntry( iEndpointList, aUser );

	}

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

// CSIPSecDigestCache::RemoveUsedEntry

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

//

void

CSIPSecDigestCache::RemoveUsedEntry( TSglQue< CSIPSecDigestCacheEntry >& aList,

								     const MSIPSecUser& aUser )

	{

	if ( !aList.IsEmpty() )

        {

        CSIPSecDigestCacheEntry* entry( NULL );

    	TSIPSecDigestCacheEntryIterator entryIter =

    		TSIPSecDigestCacheEntryIterator( aList );

        while ( ( entry = entryIter.Next() ) != NULL )

            {

            // When removing cache items, do NOT compare trusted user

			if ( &entry->SIPSecUser() == &aUser )

		        {

		        RemoveCacheEntry( *entry, aUser );

		        }

            }

        }

	}

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

// CSIPSecDigestCache::ClearCache

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

//

void CSIPSecDigestCache::ClearCache( CSIPSecUserRecord& aCredentials,

									 TBool aAKAOnly )

	{

	RemoveMatchingEntry( iProxyList, aCredentials, aAKAOnly );

	RemoveMatchingEntry( iEndpointList, aCredentials, aAKAOnly );

	}

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

// CSIPSecDigestCache::RemoveMatchingEntry

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

//

void CSIPSecDigestCache::RemoveMatchingEntry(

	TSglQue< CSIPSecDigestCacheEntry >& aList,

	CSIPSecUserRecord& aCredentials,

	TBool aAKAOnly )

	{

	if ( !aList.IsEmpty() )

        {

        CSIPSecDigestCacheEntry* entry( NULL );

    	TSIPSecDigestCacheEntryIterator entryIter =

    		TSIPSecDigestCacheEntryIterator( aList );

		while ( ( entry = entryIter.Next() ) != NULL )

			{

			if ( entry->HoldsUserData( aCredentials ) &&

				 ( !aAKAOnly ||

				   ( static_cast< CSIPSecCredentials* >( entry )->Challenge().

				       Algorithm().AlgorithmName() ==

				           CSIPSecChallengeAKA::SupportedAlgorithm() ) ) )

			    {

				if ( RemoveCacheEntry( *entry, entry->SIPSecUser() ) )

					{

					// Removed aCredentials, nothing refers to it, so exit loop

					return;

					}

			    }

			}

        }

	}

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

// CSIPSecDigestCache::ClearAKAEntriesWithOldRealm

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

//

void CSIPSecDigestCache::ClearAKAEntriesWithOldRealm( const TDesC8& aRealm )

	{

	CSIPSecUserRecord* record( NULL );

	iCredentialsListIter.SetToFirst();

	while ( ( record = iCredentialsListIter++ ) != NULL )

		{

		if ( !record->IsSameRealm( aRealm ) )

			{

			ClearCache( *record, ETrue );

			}

		}

	}

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

// CSIPSecDigestCache::RegisterObserverL

// Check if aObserver has a matching CSIPSecDigestObserver. If not, create

// CSIPSecDigestObserver for it. Each SIP response has its own aObserver.

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

//

CSIPSecDigestObserver* CSIPSecDigestCache::RegisterObserverL(

	MSIPSecSecurityMechanismObserver& aObserver,

	CSIPSecUserRecord& aUserData )

	{

    CSIPSecDigestObserver* observer( NULL );

    TInt i( 0 );

    while ( !observer && i < iDigestObservers.Count() )

    	{

    	observer = iDigestObservers[ i++ ];

    	observer = observer->HasObserver( aObserver ) ? observer : NULL;

    	}

    if ( !observer )

        {

        observer = aUserData.CreateObserverL( aObserver );

        CleanupStack::PushL( observer );

    	iDigestObservers.AppendL( observer );

    	CleanupStack::Pop( observer );

        }

	return observer;

	}

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

// CSIPSecDigestCache::CancelPendingOperations

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

//

void CSIPSecDigestCache::CancelPendingOperations(

	MSIPSecSecurityMechanismObserver* aObserver )

	{

	CSIPSecUserRecord* record( NULL );

	iCredentialsListIter.SetToFirst();

	while ( ( record = iCredentialsListIter++ ) != NULL )

		{

		record->CancelPendingOperations( aObserver );

		}

	CleanObservers();

	}

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

// CSIPSecDigestCache::Cancel

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

//

TInt CSIPSecDigestCache::Cancel( TTransactionId aTransactionId,

                                 const TDesC8& aRealm,

                                 const MSIPSecUser* aTrustedUser )

	{

	if ( aRealm.Length() == 0 )

    	{

    	return KErrArgument;

    	}

	TInt status( KErrNotFound );

	CSIPSecUserRecord* record( NULL );

	iCredentialsListIter.SetToFirst();

	while ( ( record = iCredentialsListIter++ ) != NULL )

		{

		if ( record->IsSameRealm( aRealm ) &&

			 ( record->TransactionIdPassedToClient() == aTransactionId || 

			   &record->SIPSecUser() == aTrustedUser ) )

			{

			status = KErrNone; // At least one found

            record->CancelPendingOperations( NULL /* cancel all */ );

			}

		}

	CleanObservers();

	return status;

	}

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

// CSIPSecDigestCache::Remove

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