diff -r 000000000000 -r 094583676ce7 PECengine/ListLibrary2/AuthSrc/CPEngAuthorizationEngine.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/PECengine/ListLibrary2/AuthSrc/CPEngAuthorizationEngine.cpp Thu Dec 17 08:41:52 2009 +0200 @@ -0,0 +1,552 @@ +/* +* Copyright (c) 2005 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: Reactive authorization engine base class. +* +*/ + +// INCLUDE FILES +#include +#include "CPEngAuthorizationEngine.h" +#include "CPEngAuthorizationResponse.h" +#include "CPEngAuthorizationRequest.h" +#include "CPEngAuthorizationItem.h" + +#include "PEngStorageGlobals.h" +#include "MPEngStorageManager.h" +#include "PEngStorageManager.h" +#include "CPEngSessionSlotId.h" +#include "RObjectArray.h" +#include "PresenceDebugPrint.h" + + + +#define ARRAY_ORDER_REQ TLinearOrder (CPEngAuthorizationRequest::Compare) +#define ARRAY_ORDER_STAT TLinearOrder (CPEngAuthorizationResponse::Compare) + + +_LIT( KPEngAuthorizationsSId, "PEngAuthorizations" ); + +// Init size for the store enry fo the authorization engine +// 2x4 bytes for two array counts +static const TInt KInitSizeOfStoreEntry = 8; + + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::CPEngAuthorizationEngine() +// ----------------------------------------------------------------------------- +// +CPEngAuthorizationEngine::CPEngAuthorizationEngine( MPEngListLibFactory& aFactory ) + : CPEngStoreEntry( EPEngMixedCachedVersionCon ), + iFactory( aFactory ), + iAccessCount( 1 ) // init ref count on 1 + { + iSize = KInitSizeOfStoreEntry; + } + + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::ConstructL() +// ----------------------------------------------------------------------------- +// +void CPEngAuthorizationEngine::ConstructL( const CPEngSessionSlotId& aSessionSlot ) + { + iSessionId = aSessionSlot.CloneL(); + + MPEngStorageManager* storageManager = + PEngStorageManager::GetStorageManagerL( *iSessionId ); + CleanupClosePushL( *storageManager ); + + CPEngStoreEntry::BaseConstructL( *storageManager ); + + CleanupStack::PopAndDestroy(); //storageManager + + iStorageManager->RetrieveL( *this ); + } + + +// Destructor +CPEngAuthorizationEngine::~CPEngAuthorizationEngine() + { + iAuthRequests.ResetAndDestroy(); + iAuthStatuses.ResetAndDestroy(); + delete iSessionId; + } + + + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::SessionId() +// ----------------------------------------------------------------------------- +// +const CPEngSessionSlotId& CPEngAuthorizationEngine::SessionId() const + { + return *iSessionId; + } + + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::Open() +// ----------------------------------------------------------------------------- +// +void CPEngAuthorizationEngine::Open() + { + iAccessCount++; + } + + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::UpdateAuthorizationStateL() +// ----------------------------------------------------------------------------- +// +void CPEngAuthorizationEngine::UpdateAuthorizationStateL( + CPEngAuthorizationResponse& aAuthResponse, + TBool aPartialAcceptance ) + { + TInt index( FindUserIdItem( iAuthRequests, aAuthResponse.Id() ) ); + CPEngAuthorizationRequest* authRq = NULL; + + if ( index == KErrNotFound ) + { + CPEngAuthorizationRequest* authRq = CPEngAuthorizationRequest::NewLC( + aAuthResponse.Id(), + iSize ); + + iAuthRequests.InsertInOrderL( authRq, ARRAY_ORDER_REQ ); + CleanupStack::Pop(); + } + else + { + authRq = iAuthRequests[ index ]; + } + + + // update authorization + authRq->SetAuthResponse( + static_cast + ( aAuthResponse.AuthorizationStatus() ) ); + + authRq->SetAuthState( MPEngAuthorizationRequest::EPEngAuthAnswered ); + + // copy authorized attributes + if ( aPartialAcceptance ) + { + authRq->UpdateAuthorizedAttributesL( aAuthResponse.AuthorizedAttributes() ); + } + else + { + authRq->UpdateAuthorizedAttributesL( authRq->RequestedAttributes() ); + } + + StoreL(); + } + + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::RemoveAuthorizationRequestL() +// ----------------------------------------------------------------------------- +// +void CPEngAuthorizationEngine::RemoveAuthorizationRequestL( + CPEngAuthorizationResponse& aAuthResponse ) + { + TInt index( FindUserIdItem( iAuthRequests, aAuthResponse.Id() ) ); + if ( index < 0 ) + { + return; + } + delete iAuthRequests[ index ]; + iAuthRequests.Remove( index ); + + StoreL(); + } + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::AddAuthRequestLX() +// ----------------------------------------------------------------------------- +// +void CPEngAuthorizationEngine::AddAuthRequestLX( + CPEngAuthorizationRequest* aAuthRequest ) + { + TInt err( iAuthRequests.InsertInOrder( aAuthRequest, ARRAY_ORDER_REQ ) ); + if ( err == KErrNone ) + { + CleanupStack::Pop( aAuthRequest ); + } + + if ( err == KErrAlreadyExists ) + { + // it is there already, update set of requested attributes + TInt index( FindUserIdItem( iAuthRequests, aAuthRequest->Id() ) ); + iAuthRequests[ index ]->UpdateRequestedAttributesL( + aAuthRequest->RequestedAttributes() ); + CleanupStack::PopAndDestroy( aAuthRequest ); + err = KErrNone; + } + + User::LeaveIfError( err ); + CPEngStoreEntry::StoreL(); + } + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::AddAuthStatusLX() +// ----------------------------------------------------------------------------- +// +void CPEngAuthorizationEngine::AddAuthStatusLX( + CPEngAuthorizationResponse* aAuthStatus ) + { + TInt err( iAuthStatuses.InsertInOrder( aAuthStatus, ARRAY_ORDER_STAT ) ); + if ( err == KErrNone ) + { + CleanupStack::Pop( aAuthStatus ); // aAuthRequest + } + if ( err == KErrAlreadyExists ) + { + // it is there already, update set of requested attributes + TInt index( FindUserIdItem( iAuthStatuses, aAuthStatus->Id() ) ); + + iAuthStatuses[ index ]->SetAttributesToAuthorizeL( + aAuthStatus->AuthorizedAttributes().Array(), + NULL ); + + CleanupStack::PopAndDestroy( aAuthStatus ); // aAuthRequest + err = KErrNone; + } + + User::LeaveIfError( err ); + CPEngStoreEntry::StoreL(); + } + + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::SizeCounter() +// ----------------------------------------------------------------------------- +// +TInt& CPEngAuthorizationEngine::SizeCounter() + { + return iSize; + } + + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::LockForNetworkPublishing() +// ----------------------------------------------------------------------------- +// +void CPEngAuthorizationEngine::LockForNetworkPublishing() + { + CPEngStoreEntry::Lock( EStorageLockLevelHigh ); + } + + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::UnLockForNetworkPublishing() +// ----------------------------------------------------------------------------- +// +void CPEngAuthorizationEngine::UnLockForNetworkPublishing() + { + CPEngStoreEntry::Unlock(); + } + + + +// ----------------------------------------------------------------------------- +// CPEngContactListMainArray::ExternalizeL() +// ----------------------------------------------------------------------------- +// +void CPEngAuthorizationEngine::ExternalizeL( RWriteStream& aStream, + TPEngStorageType aStorageType ) const + { + switch ( aStorageType ) + { + case EPEngStorageBasicCached: + { + TInt count( iAuthRequests.Count() ); + aStream.WriteInt32L( count ); + for ( TInt x( 0 ) ; x < count ; ++x ) + { + iAuthRequests[ x ]->ExternalizeL( aStream ); + } + + count = iAuthStatuses.Count(); + aStream.WriteInt32L( count ); + for ( TInt y( 0 ) ; y < count ; ++y ) + { + iAuthStatuses[ y ]->ExternalizeL( aStream ); + } + break; + } + + + default: + { + break; + } + } + } + + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::InternalizeL() +// ----------------------------------------------------------------------------- +// +void CPEngAuthorizationEngine::InternalizeL( RReadStream& aStream, + TPEngStorageType aStorageType ) + { + switch ( aStorageType ) + { + case EPEngStorageBasicCached: + { + // authorization requests + RObjectArray authRequests; + CleanupClosePushL( authRequests ); + + TInt count( aStream.ReadInt32L() ); + for ( TInt x( 0 ) ; x < count ; ++x ) + { + CPEngAuthorizationRequest* authRq = + CPEngAuthorizationRequest::NewLC( aStream, + iSize ); + authRequests.AppendL( authRq ); + CleanupStack::Pop( authRq ); // authRq + // adopt flag and clean array + AdoptAndClean( iAuthRequests, *authRq ); + } + AppendRemoveL( iAuthRequests, authRequests ); + CleanupStack::PopAndDestroy(); // authRequests + + + // authorization statuses + RObjectArray authStatuses; + CleanupClosePushL( authStatuses ); + + count = aStream.ReadInt32L(); + for ( TInt y( 0 ) ; y < count ; ++y ) + { + CPEngAuthorizationResponse* authRes = + CPEngAuthorizationResponse::NewLC( aStream, + iSize ); + authStatuses.AppendL( authRes ); + CleanupStack::Pop( authRes ); // authRes + // adopt flag and clean array + AdoptAndClean( iAuthStatuses, *authRes ); + } + AppendRemoveL( iAuthStatuses, authStatuses ); + CleanupStack::PopAndDestroy(); // authStatuses + break; + } + + default: + { + break; + } + } + } + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::StorageId() +// ----------------------------------------------------------------------------- +// +const TDesC& CPEngAuthorizationEngine::StorageId() const + { + return KPEngAuthorizationsSId; + } + + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::EntrySize() +// ----------------------------------------------------------------------------- +// +TUint32 CPEngAuthorizationEngine::EntrySize() const + { + return iSize; + } + + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::HandleSIDsChangeL() +// ----------------------------------------------------------------------------- +// +void CPEngAuthorizationEngine::HandleSIDsChangeL( CPtrCArray& /* aChangedSIDs */ ) + { + iStorageManager->RetrieveL( *this ); + } + + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::HandleSIDNotifyError() +// ----------------------------------------------------------------------------- +// +void CPEngAuthorizationEngine::HandleSIDNotifyError( TInt /* aError */ ) + { + } + + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::AuthorizationRequestCount() +// ----------------------------------------------------------------------------- +// +TInt CPEngAuthorizationEngine::AuthorizationRequestCount() const + { + return iAuthRequests.Count(); + } + + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::AuthorizationRequest() +// ----------------------------------------------------------------------------- +// +CPEngAuthorizationRequest& CPEngAuthorizationEngine::AuthorizationRequest( + TInt aIndex ) + { + return *iAuthRequests[ aIndex ]; + } + + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::AuthorizationStatusCount() +// ----------------------------------------------------------------------------- +// +TInt CPEngAuthorizationEngine::AuthorizationStatusCount() const + { + return iAuthStatuses.Count(); + } + + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::AuthorizationStatus() +// ----------------------------------------------------------------------------- +// +CPEngAuthorizationResponse& CPEngAuthorizationEngine::AuthorizationStatus( + TInt aIndex ) + { + return * iAuthStatuses[ aIndex ]; + } + + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::AuthorizationRequestL() +// ----------------------------------------------------------------------------- +// +CPEngAuthorizationRequest& CPEngAuthorizationEngine::AuthorizationRequestL( + const TDesC& aUserId ) + { + TInt index ( FindUserIdItem( iAuthRequests, aUserId ) ); + User::LeaveIfError( index ); + return *iAuthRequests[ index ]; + } + + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::FindAuthResponse() +// ----------------------------------------------------------------------------- +// +TInt CPEngAuthorizationEngine::FindAuthResponse( + const RPointerArray& aArray, + const TDesC& aUserId ) + { + return FindUserIdItem( aArray, aUserId ); + } + + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::FindUserIdItem() +// ----------------------------------------------------------------------------- +// +template +TInt CPEngAuthorizationEngine::FindUserIdItem( const RPointerArray& aArray, + const TDesC& aUserId ) + { + TInt l( 0 ); + TInt r( aArray.Count() ); + while ( r > l ) + { + TInt inx = ( l + r ) >> 1; + + TInt k ( aUserId.CompareF( aArray[ inx ]->Id() ) ); + if ( k == 0 ) + { + return inx; + } + else if ( k > 0 ) + l = inx + 1; + else + r = inx; + } + return KErrNotFound; + } + + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::AdoptAndClean() +// ----------------------------------------------------------------------------- +// +template +void CPEngAuthorizationEngine::AdoptAndClean( RPointerArray& aArray, + T& aNewItem ) + { + TInt count( aArray.Count() ); + while ( count != 0 ) + { + TInt err( aArray[ 0 ]->Id().CompareF( aNewItem.Id() ) ); + if ( err == KErrNone ) + { + aNewItem.DoUpdateLocalFlags( *( aArray[ 0 ] ) ); + delete aArray[ 0 ]; + aArray.Remove( 0 ); + return; + } + + if ( err > 0 ) // no sense to loop furder in the array + { + return; + } + + // clean array + delete aArray[ 0 ]; + aArray.Remove( 0 ); + count--; + } + } + + +// ----------------------------------------------------------------------------- +// CPEngAuthorizationEngine::AppendRemoveL() +// ----------------------------------------------------------------------------- +// +template +void CPEngAuthorizationEngine::AppendRemoveL( RPointerArray& aTarget, + RPointerArray& aSource ) + { + aTarget.ResetAndDestroy(); + TInt count( aSource.Count() ); + while ( count != 0 ) + { + aTarget.AppendL( aSource[ 0 ] ); + aSource.Remove( 0 ); + count--; + } + } + +// End of File + + + + + + + + + + +