--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/policymanagement/dmutilserver/src/ACLStorage.cpp Thu Dec 17 09:07:52 2009 +0200
@@ -0,0 +1,1373 @@
+/*
+* Copyright (c) 2000 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 of policymanagement components
+*
+*/
+
+
+// INCLUDES
+
+#ifdef __TARM_SYMBIAN_CONVERGENCY
+ #include <devman.h>
+ #include <dmtreenode.h>
+#else
+ #include <nsmldmdbhandler.h>
+#endif
+
+#include "ACLStorage.h"
+#include "debug.h"
+
+
+// CONSTANTS
+
+_LIT( KStorageFile, "C:\\private\\10207843\\aclnodes.ini");
+_LIT( KStorageTempFile, "C:\\private\\10207843\\aclnodes.tmp");
+_LIT( KStorageBackupFile, "C:\\private\\10207843\\aclnodes.bak");
+
+
+
+#ifdef __TARM_SYMBIAN_CONVERGENCY
+_LIT8(KNSmlDmAclAddEqual, "Add=");
+_LIT8(KNSmlDmAclGetEqual, "Get=");
+_LIT8(KNSmlDmAclDeleteEqual, "Delete=");
+_LIT8(KNSmlDmAclReplaceEqual, "Replace=");
+_LIT8(KNSmlDmAclSeparator, "&");
+_LIT8(KNSmlDmAclExecEqual, "Exec=");
+#else
+ const TInt KStatusRef = 0;
+ const TInt KResultRef = 1;
+#endif
+
+
+
+namespace
+{
+ TBool CompareCertInfos( const TCertInfo& aCertInfo1, const TCertInfo& aCertInfo2)
+ {
+
+ TBool retVal = ( aCertInfo1.iSerialNo == aCertInfo2.iSerialNo ) &&
+ ( aCertInfo1.iFingerprint == aCertInfo2.iFingerprint ) &&
+ ( aCertInfo1.iIssuerDNInfo.iCommonName == aCertInfo2.iIssuerDNInfo.iCommonName ) &&
+ ( aCertInfo1.iIssuerDNInfo.iCountry == aCertInfo2.iIssuerDNInfo.iCountry ) &&
+ ( aCertInfo1.iIssuerDNInfo.iLocality == aCertInfo2.iIssuerDNInfo.iLocality ) &&
+ ( aCertInfo1.iIssuerDNInfo.iOrganization == aCertInfo2.iIssuerDNInfo.iOrganization ) &&
+ ( aCertInfo1.iIssuerDNInfo.iOrganizationUnit == aCertInfo2.iIssuerDNInfo.iOrganizationUnit );
+
+ return retVal;
+ }
+
+ TBool CompareCommands( const CCommand& aCommand1, const CCommand& aCommand2)
+ {
+ TBool match = EFalse;
+
+ if ( aCommand1.iCommand == aCommand2.iCommand)
+ {
+ if ( aCommand1.iServerId && *aCommand1.iServerId == *aCommand2.iServerId)
+ {
+ match = ETrue;
+ }
+ else
+ {
+ //Compare certficates
+ match = CompareCertInfos( aCommand1.iCertInfo, aCommand2.iCertInfo);
+ }
+ }
+
+ return match;
+ }
+}
+
+
+
+// ----------------------------------------------------------------------------------------
+// CCommand::NewL()
+// ----------------------------------------------------------------------------------------
+CCommand* CCommand::NewL( const TCertInfo& aCertInfo, const TAclCommands& aCommand)
+{
+ CCommand * self = new (ELeave) CCommand();
+ self->iCertInfo = aCertInfo;
+ self->iCommand = aCommand;
+
+ return self;
+}
+
+
+// ----------------------------------------------------------------------------------------
+// CCommand::NewL()
+// ----------------------------------------------------------------------------------------
+CCommand* CCommand::NewL( const TDesC8& aServerUid, const TAclCommands& aCommand)
+{
+ CCommand * self = new (ELeave) CCommand();
+
+ CleanupStack::PushL( self);
+ self->iServerId = aServerUid.AllocL();
+ self->iCommand = aCommand;
+ CleanupStack::Pop( self);
+
+ return self;
+}
+
+
+// ----------------------------------------------------------------------------------------
+// CCommand::NewL()
+// ----------------------------------------------------------------------------------------
+
+void CCommand::CommandString( TDes8& aStr)
+{
+ switch ( iCommand)
+ {
+ case EACLAdd:
+ aStr.Append( KNSmlDmAclAddEqual);
+ break;
+ case EACLDelete:
+ aStr.Append( KNSmlDmAclDeleteEqual);
+ break;
+ case EACLExec:
+ aStr.Append( KNSmlDmAclExecEqual);
+ break;
+ case EACLGet:
+ aStr.Append( KNSmlDmAclGetEqual);
+ break;
+ case EACLReplace:
+ aStr.Append( KNSmlDmAclReplaceEqual);
+ break;
+ default:
+ break;
+ }
+
+ aStr.Append( *iServerId);
+}
+
+// ----------------------------------------------------------------------------------------
+// CCommand::Length()
+// ----------------------------------------------------------------------------------------
+
+TInt CCommand::Length()
+{
+ //Calculate serialized command length
+ TPckg<TCertInfo> certPck( iCertInfo);
+ TPckg<TAclCommands> cmdPck( iCommand);
+
+ return certPck.Length() + cmdPck.Length();
+}
+
+// ----------------------------------------------------------------------------------------
+// CCommand::SaveStringL()
+// ----------------------------------------------------------------------------------------
+HBufC8 * CCommand::SaveStringL()
+{
+ //Create buffer for string
+ HBufC8 * buf = HBufC8::NewL( Length());
+ TPtr8 ptr = buf->Des();
+
+ //create descriptor packs
+ TPckg<TCertInfo> certPck( iCertInfo);
+ TPckg<TAclCommands> cmdPck( iCommand);
+
+ //add serialized data to buffer
+ ptr.Append( certPck);
+ ptr.Append( cmdPck);
+
+ return buf;
+}
+
+// ----------------------------------------------------------------------------------------
+// CCommand::LoadFromStringL()
+// ----------------------------------------------------------------------------------------
+CCommand * CCommand::LoadFromStringL( TPtrC8& aString)
+{
+ CCommand * command = new (ELeave) CCommand();
+ TPtrC8 ptr( aString);
+
+ //Certificate
+ TPckg<TCertInfo> certPck( command->iCertInfo);
+ certPck.Copy( ptr.Ptr(), certPck.Length());
+ ptr.Set( ptr.Mid( certPck.Length()));
+
+ //Commands
+ TPckg<TAclCommands> cmdPck( command->iCommand);
+ cmdPck.Copy( ptr.Ptr(), cmdPck.Length());
+ ptr.Set( ptr.Mid( cmdPck.Length()));
+
+ return command;
+}
+
+
+
+
+// ----------------------------------------------------------------------------------------
+// CACLNode::CACLNode()
+// ----------------------------------------------------------------------------------------
+CACLNode::CACLNode()
+ : iURI(0)
+{
+}
+
+// ----------------------------------------------------------------------------------------
+// CACLNode::CACLNode()
+// ----------------------------------------------------------------------------------------
+CACLNode::~CACLNode()
+{
+ delete iURI;
+ iCommands.Close();
+}
+
+
+// ----------------------------------------------------------------------------------------
+// CACLNode::CompareElements()
+// ----------------------------------------------------------------------------------------
+
+TInt CACLNode::CompareElements( CACLNode const& aNode1, CACLNode const& aNode2)
+{
+ RDEBUG("CACLNode::CompareElements()");
+ RDEBUG8_2(" -> Node1 URI = %S", &aNode1.iURIPtr );
+ RDEBUG8_2(" -> Node2 URI = %S", &aNode2.iURIPtr );
+ TInt result = (aNode1.iURIPtr).Compare( aNode2.iURIPtr);
+ RDEBUG_2(" -> comparison result = %d", result);
+ return result;
+}
+
+// ----------------------------------------------------------------------------------------
+// CACLNode::FindCorrespondingCommand()
+// ----------------------------------------------------------------------------------------
+
+CCommand* CACLNode::FindCorrespondingCommand( const CCommand* aCommand)
+{
+ CCommand* retVal = 0;
+
+ //find corresponding command from command list
+ for ( TInt i(0); i < iCommands.Count(); i++)
+ {
+ CCommand* command = iCommands[i];
+
+ if ( CompareCommands( *command, *aCommand))
+ {
+ retVal = command;
+ break;
+ }
+ }
+
+ return retVal;
+}
+
+
+// ----------------------------------------------------------------------------------------
+// CACLNode::GetNodeACLStringL()
+// ----------------------------------------------------------------------------------------
+
+HBufC8 * CACLNode::GetNodeACLStringL()
+{
+ RDEBUG("CACLNode::GetNodeACLStringL()");
+ HBufC8 * buf = HBufC8::NewL( iCommands.Count() * 21);
+ TPtr8 ptr = buf->Des();
+
+ for ( TInt i(0); i < iCommands.Count();)
+ {
+ TBuf8<30> command;
+
+ iCommands[i++]->CommandString( command);
+ ptr.Append( command);
+
+ if ( i != iCommands.Count() )
+ {
+ ptr.Append(KNSmlDmAclSeparator);
+ }
+ }
+
+
+ return buf;
+}
+
+
+// ----------------------------------------------------------------------------------------
+// CACLNode::SetURIL()
+// ----------------------------------------------------------------------------------------
+
+void CACLNode::SetURIL( const TDesC8& aURI )
+{
+ delete iURI;
+ iURI = NULL;
+ iURIPtr.Set( KNullDesC8);
+ iURI = aURI.AllocL();
+ iURIPtr.Set( *iURI);
+}
+
+// ----------------------------------------------------------------------------------------
+// CACLNode::ClearACL()
+// ----------------------------------------------------------------------------------------
+
+void CACLNode::ClearACL()
+{
+ //find all command which concern specific command remove them from list
+ for ( TInt i(0); i < iCommands.Count(); i++)
+ {
+#ifdef _DEBUG
+ TBuf8<30> command;
+ iCommands[i]->CommandString( command);
+ RDEBUG8_2("DMUtilServer: Remove command %S", &command);
+#endif //_DEBUG
+
+ delete iCommands[i];
+ iCommands.Remove( i--);
+ }
+}
+
+
+
+// ----------------------------------------------------------------------------------------
+// CACLNode::SetServerIdToACLL()
+// ----------------------------------------------------------------------------------------
+
+
+void CACLNode::SetServerIdToACLL( const TAclCommands& aCommandType, const TDesC8& aServerId)
+{
+ RDEBUG("CACLStorage::SetServerIdToACLL()");
+ //check first that command isn't already exist
+ for ( TInt i(0); i < iCommands.Count(); i++)
+ {
+ CCommand * command = iCommands[i];
+
+ if ( (command->iCommand == aCommandType || aCommandType == EACLAll )
+ && *command->iServerId == aServerId)
+ {
+ return;
+ }
+ }
+
+ //and if command is new, create new CCommand for it
+ CCommand * command = CCommand::NewL( aServerId, aCommandType);
+
+ CleanupStack::PushL( command);
+ iCommands.AppendL( command);
+ CleanupStack::Pop( command);
+
+#ifdef _DEBUG
+ TBuf8<30> commandStr;
+ command->CommandString( commandStr);
+ RDEBUG8_2("DMUtilServer: New command %S", &commandStr);
+#endif //_DEBUG
+
+}
+
+// ----------------------------------------------------------------------------------------
+// CACLNode::Length()
+// ----------------------------------------------------------------------------------------
+
+TInt CACLNode::Length()
+{
+ TInt testvalue;
+ TPckgC<TInt> valueLength( testvalue);
+ TPckgC<TACLDestination> destLength( iDestination);
+
+ TInt size = valueLength.Length() * 2 + destLength.Length() + iURI->Length();
+
+ for (TInt i(0); i < iCommands.Count(); i++)
+ {
+ size += iCommands[i]->Length();
+ }
+ RDEBUG_2("DMUtilServer: CACLNode::Length - End (returned size: %d)", size);
+
+ return size;
+}
+
+// ----------------------------------------------------------------------------------------
+// CACLNode::SaveStringL()
+// ----------------------------------------------------------------------------------------
+
+HBufC8 * CACLNode::SaveStringL()
+{
+ RDEBUG("DMUtilServer: CACLNode::SaveStringL - Start");
+
+ //create buffer for string
+ HBufC8* buf = HBufC8::NewL( Length());
+ TPtr8 ptr = buf->Des();
+
+ //clearflag
+ TPckgC<TInt> flagPck( iClearFlag);
+ ptr.Append( flagPck);
+
+ //destPack
+ TPckgC<TACLDestination> destPck( iDestination);
+ ptr.Append( destPck);
+
+ //uri
+ TInt uriLength( iURI->Length());
+ TPckgC<TInt> uriPck( uriLength);
+ ptr.Append( uriPck);
+ ptr.Append( *iURI);
+
+ //append commands to string
+ for ( TInt i(0); i < iCommands.Count(); i++)
+ {
+ //get command save string
+ HBufC8* buf = iCommands[i]->SaveStringL();
+ ptr.Append( *buf);
+
+ delete buf;
+ }
+
+ RDEBUG("DMUtilServer: CACLNode::SaveStringL - End");
+ return buf;
+}
+
+// ----------------------------------------------------------------------------------------
+// CACLNode::LoadFromStringL()
+// ----------------------------------------------------------------------------------------
+
+CACLNode * CACLNode::LoadFromStringL( TDes8& aString)
+{
+ RDEBUG("DMUtilServer: CACLNode::LoadFromStringL - Start");
+
+ CACLNode * node = new (ELeave) CACLNode();
+ TPtrC8 ptr( aString);
+
+ //Clear flag
+ TPckg<TInt> flagPck( node->iClearFlag);
+ flagPck.Copy( ptr.Ptr(), flagPck.Length());
+ ptr.Set( ptr.Mid( flagPck.Length()));
+
+
+ //destPack
+ TPckg<TACLDestination> destPck( node->iDestination);
+ destPck.Copy( ptr.Ptr(), destPck.Length());
+ ptr.Set( ptr.Mid( destPck.Length()));
+
+ //get uri length
+ TInt uriLength;
+ TPckg<TInt> intPck( uriLength);
+ intPck.Copy( ptr.Ptr(), intPck.Length());
+ ptr.Set( ptr.Mid( intPck.Length()));
+
+ //get URI and save it to node
+ node->iURI = HBufC8::NewL( uriLength);
+ node->iURI->Des().Copy( ptr.Ptr(), uriLength);
+ node->iURIPtr.Set( *(node->iURI));
+ ptr.Set( ptr.Mid( uriLength));
+
+ TInt len( ptr.Length() );
+ while ( len )
+ {
+ //Read buffer
+ CCommand * command = CCommand::LoadFromStringL( ptr);
+
+ //Set Pointer
+ ptr.Set( ptr.Mid( command->Length()));
+ len = ptr.Length();
+ //append readen command to command list
+ CleanupStack::PushL( command);
+ node->iCommands.AppendL( command);
+ CleanupStack::Pop( command);
+ }
+
+ RDEBUG("DMUtilServer: CACLNode::LoadFromStringL - End");
+
+ return node;
+}
+
+
+// ----------------------------------------------------------------------------------------
+// CACLNode::SetCertificateToACLL()
+// ----------------------------------------------------------------------------------------
+
+void CACLNode::SetCertificateToACLL( const TACLDestination& aDestination, const TAclCommands& aCommandType, const TCertInfo& aCertInfo)
+{
+ RDEBUG("DMUtilServer: CACLNode::SetCertificateToACLL - Start");
+
+ //check first that command isn't already exist
+ for ( TInt i(0); i < iCommands.Count(); i++)
+ {
+ CCommand * command = iCommands[i];
+
+ if ( (command->iCommand == aCommandType || aCommandType == EACLAll )
+ && CompareCertInfos( command->iCertInfo, aCertInfo ))
+ {
+ return;
+ }
+ }
+
+ //and if command is new, create new CCommand for it
+ CCommand * command = CCommand::NewL( aCertInfo, aCommandType);
+
+ CleanupStack::PushL( command);
+ iCommands.AppendL( command);
+ CleanupStack::Pop( command);
+
+ iDestination = aDestination;
+
+
+ RDEBUG("DMUtilServer: CACLNode::SetCertificateToACLL - End");
+}
+
+// ----------------------------------------------------------------------------------------
+// CACLNode::CreateACLL()
+// ----------------------------------------------------------------------------------------
+
+CACLNode * CACLNode::CreateACLL( const TDesC8& aACLString)
+{
+ RDEBUG("DMUtilServer: CACLNode::CreateACLL - Start");
+
+
+ //Create ACL node
+ CACLNode * node = new (ELeave) CACLNode();
+
+ TPtrC8 ptr( aACLString);
+ TInt err( KErrNone);
+
+ //decode acl string
+ while ( ptr.Length() && err == KErrNone)
+ {
+ //find equal mark...
+ TInt index = ptr.Locate('=');
+
+ //...acl is corrupted if mark not found
+ if ( index == KErrNotFound)
+ {
+ err = KErrCorrupt;
+ break;
+ }
+
+ //create command ptr, which includes only command string
+ TPtrC8 command( ptr.Left( index + 1));
+ TAclCommands aclCommand;
+
+ //remove encoded part
+ ptr.Set( ptr.Mid( index + 1));
+
+ //resolve command type
+ if ( command.CompareF( KNSmlDmAclAddEqual) == 0)
+ {
+ aclCommand = EACLAdd;
+ }
+ else
+ if ( command.CompareF( KNSmlDmAclGetEqual) == 0)
+ {
+ aclCommand = EACLGet;
+ }
+ else
+ if ( command.CompareF( KNSmlDmAclDeleteEqual) == 0)
+ {
+ aclCommand = EACLDelete;
+ }
+ else
+ if ( command.CompareF( KNSmlDmAclReplaceEqual) == 0)
+ {
+ aclCommand = EACLReplace;
+ }
+ else
+ if ( command.CompareF( KNSmlDmAclExecEqual) == 0)
+ {
+ aclCommand = EACLExec;
+ }
+
+ //find &-mark
+ index = ptr.Locate('&');
+
+ //server ptr contains server id
+ TPtrC8 server(ptr);
+ if ( index != KErrNotFound)
+ {
+ //set server text
+ server.Set( ptr.Left( index));
+
+ //remove encoded part
+ ptr.Set( ptr.Mid( index + 1));
+ }
+ else
+ {
+ ptr.Set( KNullDesC8);
+ }
+
+
+ //create command add it to CNode
+ if ( err == KErrNone)
+ {
+ CCommand * command = CCommand::NewL( server, aclCommand);
+ CleanupStack::PushL( command);
+ node->iCommands.AppendL( command);
+ CleanupStack::Pop( command);
+ }
+ }
+
+ RDEBUG("DMUtilServer: CACLNode::CreateACLL - End");
+ return node;
+}
+
+
+
+// ----------------------------------------------------------------------------------------
+// CACLStorage::CACLStorage()
+// ----------------------------------------------------------------------------------------
+
+CACLStorage::CACLStorage()
+{
+}
+
+// ----------------------------------------------------------------------------------------
+// CACLStorage::~CACLStorage()
+// ----------------------------------------------------------------------------------------
+
+CACLStorage::~CACLStorage()
+{
+ delete iCurrentServerId;
+ iNodes.ResetAndDestroy();
+#ifdef __TARM_SYMBIAN_CONVERGENCY
+ // nothing
+#else
+ //iDbSession.Close();
+#endif
+}
+
+// ----------------------------------------------------------------------------------------
+// CACLStorage::NewL()()
+// ----------------------------------------------------------------------------------------
+
+CACLStorage* CACLStorage::NewL()
+{
+ CACLStorage * self = new (ELeave) CACLStorage();
+
+ CleanupStack::PushL( self);
+ self->ConstructL();
+ CleanupStack::Pop( self);
+
+ return self;
+}
+
+
+// ----------------------------------------------------------------------------------------
+// CACLStorage::ConstructL()()
+// ----------------------------------------------------------------------------------------
+
+void CACLStorage::ConstructL()
+ {
+ RDEBUG("CACLStorage::ConstructL()");
+#ifdef __TARM_SYMBIAN_CONVERGENCY
+ // nothing
+#else
+
+// User::LeaveIfError( iDbSession.Connect() );
+#endif
+ iCertificateReceived = EFalse;
+ LoadACLL();
+ }
+
+
+// ----------------------------------------------------------------------------------------
+// CACLStorage::NewSession()
+// ----------------------------------------------------------------------------------------
+void CACLStorage::NewSessionL( const TCertInfo& aCertInfo, const TDesC8& aServerID)
+{
+ RDEBUG("=== CACLStorage::NewSessionL() ===");
+ delete iCurrentServerId;
+ iCurrentServerId = 0;
+ iCurrentServerId = aServerID.AllocL();
+
+ //set current session values
+ SetCertInfo( aCertInfo );
+
+ //update ACLs
+ RDEBUG("==== Starting to update ACLs ==== ");
+ UpdateACLsL();
+ RDEBUG("==== Starting to update ACLs DONE ! ==== ");
+}
+
+// ----------------------------------------------------------------------------------------
+// CACLStorage::CloseSession()
+// ----------------------------------------------------------------------------------------
+void CACLStorage::CloseSession( )
+{
+ delete iCurrentServerId;
+ iCurrentServerId = 0;
+ iCertificateReceived = EFalse;
+}
+
+// ----------------------------------------------------------------------------------------
+// CACLStorage::CertInfo()
+// ----------------------------------------------------------------------------------------
+TInt CACLStorage::CertInfo( TCertInfo &aCertInfo )
+{
+ if( ! iCertificateReceived )
+ {
+ return KErrNotFound;
+ }
+
+ aCertInfo = iCurrentCertificate;
+ return KErrNone;
+}
+
+// ----------------------------------------------------------------------------------------
+// CACLStorage::SetCertInfo()
+// ----------------------------------------------------------------------------------------
+void CACLStorage::SetCertInfo( const TCertInfo &aCertInfo )
+{
+ TPckg<TCertInfo> certa( aCertInfo );
+ TPckg<TCertInfo> certb( iCurrentCertificate );
+ certb.Copy( certa );
+
+ iCertificateReceived = ETrue;
+}
+
+// ----------------------------------------------------------------------------------------
+// CACLStorage::ServerIDL()
+// ----------------------------------------------------------------------------------------
+HBufC8* CACLStorage::ServerIDL()
+ {
+ if( iCurrentServerId != 0)
+ {
+ return iCurrentServerId->AllocL();
+ }
+ return 0;
+ }
+
+// ----------------------------------------------------------------------------------------
+// CACLStorage::NewSession()
+// ----------------------------------------------------------------------------------------
+
+CACLNode * CACLStorage::FindNodeL( const TDesC8& aURI, TBool aCreateNewIfDoesntExist)
+{
+ RDEBUG8_2("CACLStorage::FindNodeL() (%S)", &aURI);
+ //Create reference element with URI
+ TLinearOrder<CACLNode> linearOrder( &CACLNode::CompareElements);
+ CACLNode referenceNode;
+ referenceNode.iURIPtr.Set( aURI);
+
+ //find element index
+ TInt index = iNodes.FindInOrder( &referenceNode, linearOrder);
+
+ if ( index != KErrNotFound )
+ {
+ return iNodes[ index];
+ }
+
+ if ( aCreateNewIfDoesntExist )
+ {
+ CACLNode * newNode = new (ELeave) CACLNode();
+ CleanupStack::PushL( newNode);
+ newNode->SetURIL( aURI);
+ iNodes.InsertInOrderL( newNode, linearOrder);
+ CleanupStack::Pop( newNode);
+
+ RDEBUG8_2("CACLStorage::FindNodeL() Node not found, created (%S)", &aURI);
+
+ return newNode;
+ }
+
+ return 0;
+}
+
+
+
+
+
+// ----------------------------------------------------------------------------------------
+// CACLStorage::NewSession()
+// ----------------------------------------------------------------------------------------
+
+TInt CACLStorage::RemoveNode( const TDesC8& aURI)
+{
+ RDEBUG8_2("CACLStorage::RemoveNode() (%S)", &aURI);
+ //Create reference element with URI
+ TLinearOrder<CACLNode> linearOrder( &CACLNode::CompareElements);
+ CACLNode referenceNode;
+ referenceNode.iURIPtr.Set( aURI);
+
+ //find element index
+ TInt index = iNodes.FindInOrder( &referenceNode, linearOrder);
+
+ if ( index != KErrNotFound)
+ {
+ RDEBUG8_2("CACLStorage::Removed (%S)", &aURI);
+ delete iNodes[ index];
+ iNodes.Remove( index);
+
+ index = KErrNone;
+ }
+
+ return index;
+}
+
+// ----------------------------------------------------------------------------------------
+// CACLStorage::MngSessionCertificate()
+// ----------------------------------------------------------------------------------------
+
+TCertInfo& CACLStorage::MngSessionCertificate()
+{
+ return iMngSessionCertificate;
+}
+
+// ----------------------------------------------------------------------------------------
+// CACLStorage::RemoveACL()
+// ----------------------------------------------------------------------------------------
+TInt CACLStorage::RemoveACL( const TDesC8& aURI, TBool aRestoreDefaults)
+{
+ RDEBUG8_3("CACLStorage::RemoveACL() (%S)->(%d)", &aURI, aRestoreDefaults);
+ TInt err = KErrNone;
+
+ if( aRestoreDefaults )
+ {
+#ifdef __TARM_SYMBIAN_CONVERGENCY
+TRAPD( trapErr, {
+ // Symbian framework used
+ RDmTree dmTreeSession;
+ dmTreeSession.ConnectL();
+ CleanupClosePushL( dmTreeSession );
+
+ RDmTreeNode node;
+ User::LeaveIfError( dmTreeSession.OpenNodeL( aURI, node, RDmTree::EReadWrite ) );
+ CleanupClosePushL( node );
+
+ // remove the node
+ node.RemoveDmPropertyL( DevMan::EACL );
+ node.Close();
+ dmTreeSession.CommitL();
+
+ CleanupStack::PopAndDestroy( &node );
+ CleanupStack::PopAndDestroy( &dmTreeSession );
+ } );
+ err = trapErr;
+
+#else
+User::LeaveIfError( iDbSession.Connect() );
+ iDbSession.UpdateAclL( aURI, KNullDesC8 );
+ iDbSession.Close();
+#endif
+
+
+ }
+
+
+ if( err == KErrNone )
+ {
+ RemoveNode( aURI );
+ }
+
+ return err;
+}
+
+// ----------------------------------------------------------------------------------------
+// CACLStorage::AddACLForNode()
+// ----------------------------------------------------------------------------------------
+void CACLStorage::AddACLForNodeL( const TDesC8& aURI, const TACLDestination& aDestination, const TAclCommands& aCommandType)
+{
+ //find node from storage
+ CACLNode * node = FindNodeL( aURI, ETrue);
+
+ CleanupStack::PushL( node);
+ node->SetCertificateToACLL( aDestination, aCommandType, iMngSessionCertificate);
+ CleanupStack::Pop( node);
+
+ //incremental operation
+ node->iClearFlag = EFalse;
+}
+
+// ----------------------------------------------------------------------------------------
+// CACLStorage::SetACLForNode()
+// ----------------------------------------------------------------------------------------
+void CACLStorage::SetACLForNodeL( const TDesC8& aURI, const TACLDestination& aDestination, const TAclCommands& aCommandType)
+{
+
+ //find node from storage
+ CACLNode * node = FindNodeL( aURI, ETrue);
+
+ CleanupStack::PushL( node);
+ node->SetCertificateToACLL( aDestination, aCommandType, iMngSessionCertificate);
+ CleanupStack::Pop( node);
+
+ //non-incremental operation
+ node->iClearFlag = ETrue;
+}
+
+
+
+
+// ----------------------------------------------------------------------------------------
+// CACLStorage::UpdateACLs()
+// ----------------------------------------------------------------------------------------
+
+void CACLStorage::UpdateACLsL()
+{
+ RDEBUG_2(" ... starting to update ACL nodes, count: %d", iNodes.Count() );
+ for ( TInt i(0); i < iNodes.Count(); i++)
+ {
+ UpdateACLL( iNodes[i]);
+ }
+}
+
+// ----------------------------------------------------------------------------------------
+// CACLStorage::UpdateACLs()
+// ----------------------------------------------------------------------------------------
+
+void CACLStorage::UpdateACLL( const CACLNode *aACLNode)
+{
+ RDEBUG_2("DMUtilServer: CACLStorage::UpdateACLL - Start (%d)", aACLNode->iDestination);
+
+ if ( aACLNode->iDestination == EForNode )
+ {
+ UpdateACLL( aACLNode, aACLNode->iURIPtr);
+ }
+ else
+ {
+ //Create child info object
+ CChildInfo::RChildNodes childs;
+
+ //childinfo owns "CChildInfo::RChildNodes childs"
+ CChildInfo * childinfo = new (ELeave) CChildInfo( childs);
+ CleanupStack::PushL( childinfo);
+
+ //get childs
+ childinfo->GetChildsL( aACLNode->iURIPtr);
+
+ //update all childs nodes
+ for ( TInt i(0); i < childs.Count(); i++)
+ {
+ UpdateACLL( aACLNode, childs[i]);
+ }
+
+
+ //update parent also if iDestination is EForBoth
+ if ( aACLNode->iDestination == EForBoth)
+ {
+ UpdateACLL( aACLNode, aACLNode->iURIPtr);
+ }
+
+ //destroy child info
+ CleanupStack::PopAndDestroy( childinfo);
+ }
+
+ RDEBUG("DMUtilServer: CACLStorage::UpdateACL - End");
+}
+
+// ----------------------------------------------------------------------------------------
+// CACLStorage::UpdateACL()
+// ----------------------------------------------------------------------------------------
+void CACLStorage::UpdateACLL( const CACLNode *aACLNode, const TDesC8& aURI)
+ {
+ RDEBUG8_2("DMUtilServer: CACLStorage::UpdateACL - Start: %S", &aURI );
+#ifdef __TARM_SYMBIAN_CONVERGENCY
+ RDmTree dmTreeSession;
+ dmTreeSession.ConnectL();
+ CleanupClosePushL( dmTreeSession );
+
+ RDmTreeNode node;
+ User::LeaveIfError( dmTreeSession.OpenNodeL( aURI, node, RDmTree::EReadWrite ) );
+ CleanupClosePushL( node );
+
+ RBuf8 buf;
+ //get old ACL values from dmdbtree
+ node.DmPropertyL( DevMan::EACL, buf );
+
+ RDEBUG8_3("DMUtilServer: Original ACL from DM tree node %S: %S", &aURI, &buf);
+#else
+ //get old ACL values from dmdbhandler
+ CBufFlat* bufBase = CBufFlat::NewL( 1);
+ User::LeaveIfError( iDbSession.Connect() );
+ iDbSession.GetAclL( aURI, *bufBase, EFalse);
+iDbSession.Close();
+
+ TPtrC8 aclPtr = bufBase->Ptr( 0 );
+
+ RDEBUG8_3("DMUtilServer: Original ACL from DM tree node %S: %S", &aURI, &aclPtr);
+#endif
+
+
+
+ //Create CACLNode from acl string
+#ifdef __TARM_SYMBIAN_CONVERGENCY
+ CACLNode * acl = CACLNode::CreateACLL( buf );
+#else
+ CACLNode * acl = CACLNode::CreateACLL( aclPtr );
+#endif
+ CleanupStack::PushL( acl);
+
+ //clear original nodes
+ if ( aACLNode->iClearFlag )
+ {
+ RDEBUG("DMUtilServer: Remove original ACL items");
+ acl->ClearACL();
+ }
+
+ //copy commands to original ACL
+ for ( TInt i(0); i < aACLNode->iCommands.Count(); i++)
+ {
+ CCommand * command = aACLNode->iCommands[i];
+
+ CleanupStack::PushL( command);
+ delete command->iServerId;
+ command->iServerId = 0;
+ command->iServerId = iCurrentServerId->AllocL();
+ CleanupStack::Pop( command);
+
+ //find corresponding command from original acl string
+ CCommand * origCommand = acl->FindCorrespondingCommand( command);
+
+ //if no correspondinding command exist and current session certificate is same
+ //as in command, add command to node
+ if ( !origCommand )
+ {
+ if ( CompareCertInfos( iCurrentCertificate, command->iCertInfo))
+ {
+ RDEBUG("DMUtilServer: Add new ACL item");
+ acl->SetServerIdToACLL( command->iCommand, *iCurrentServerId);
+ }
+ }
+ else
+ {
+ //remove all commands which have same server id than new session (except origCommand)
+ for ( TInt i(0); i < acl->iCommands.Count(); i++)
+ {
+ if ( *iCurrentServerId == *acl->iCommands[i]->iServerId && acl->iCommands[i] != origCommand)
+ {
+ acl->iCommands.Remove(i--);
+ }
+ }
+ }
+ }
+
+ //update ACL to CM tree
+#ifdef __TARM_SYMBIAN_CONVERGENCY
+ HBufC8* aclStr = acl->GetNodeACLStringL();
+ RDEBUG_2("DMUtilServer: New ACL string for node: %S", aclStr);
+ CleanupStack::PushL( aclStr );
+
+ node.SetDmPropertyL( DevMan::EACL, *aclStr );
+
+ node.Close();
+ dmTreeSession.CommitL();
+
+ CleanupStack::PopAndDestroy( aclStr);
+ CleanupStack::PopAndDestroy( acl);
+
+ CleanupStack::PopAndDestroy( &node );
+ CleanupStack::PopAndDestroy( &dmTreeSession );
+#else
+ HBufC8 * aclStr = acl->GetNodeACLStringL();
+ CleanupStack::PushL( aclStr);
+ RDEBUG8_2("DMUtilServer: New ACL string for node: %S", aclStr);
+ User::LeaveIfError( iDbSession.Connect() );
+ iDbSession.UpdateAclL( aURI, *aclStr);
+ iDbSession.Close();
+ CleanupStack::PopAndDestroy( aclStr);
+
+ CleanupStack::PopAndDestroy( acl);
+#endif
+ RDEBUG("DMUtilServer: CACLStorage::UpdateACL - End");
+ }
+
+
+// ----------------------------------------------------------------------------------------
+// CACLStorage::SaveACLL()
+// ----------------------------------------------------------------------------------------
+
+void CACLStorage::SaveACLL()
+{
+ RDEBUG("DMUtilServer: Save ACL configuration!");
+
+ //Open rfs
+ RFs rfs;
+ CleanupClosePushL( rfs);
+ User::LeaveIfError( rfs.Connect());
+
+ //Open rfile
+ RFile file;
+ CleanupClosePushL( file);
+
+ TInt err = file.Open( rfs, KStorageTempFile, EFileWrite);
+
+ if ( err != KErrNone)
+ {
+ if ( err == KErrPathNotFound)
+ {
+ rfs.CreatePrivatePath( EDriveC);
+ }
+
+ err = file.Create( rfs, KStorageTempFile, EFileWrite);
+ }
+
+ User::LeaveIfError( err);
+
+ TInt size = 0;
+
+ //write all nodes
+ for ( TInt i(0); i < iNodes.Count(); i++)
+ {
+ RDEBUG_2(" -> node %d", i );
+ //write node length to file
+ TInt nodeLength( iNodes[i]->Length());
+ TPckgC<TInt> pck( nodeLength);
+ User::LeaveIfError( file.Write( pck));
+ size += pck.Length();
+ size += nodeLength;
+
+ HBufC8 * saveString = iNodes[i]->SaveStringL();
+ CleanupStack::PushL( saveString);
+ User::LeaveIfError( file.Write( *saveString));
+ CleanupStack::PopAndDestroy( saveString);
+ }
+
+ //Set file size
+ file.SetSize( size);
+
+ CleanupStack::PopAndDestroy( &file);
+
+ //Create storage file
+ CFileMan * fileMan = CFileMan::NewL( rfs);
+ CleanupStack::PushL( fileMan);
+
+ err = file.Open( rfs, KStorageFile, EFileRead );
+
+ if ( err == KErrNone )
+ {
+ file.Close();
+ User::LeaveIfError( fileMan->Rename( KStorageFile, KStorageBackupFile, CFileMan::EOverWrite));
+ }
+
+ User::LeaveIfError( fileMan->Rename( KStorageTempFile, KStorageFile, CFileMan::EOverWrite));
+
+ if ( err == KErrNone )
+ {
+ User::LeaveIfError( fileMan->Delete( KStorageBackupFile));
+ }
+
+
+ CleanupStack::PopAndDestroy( fileMan);
+ CleanupStack::PopAndDestroy( &rfs);
+}
+
+// ----------------------------------------------------------------------------------------
+// CACLStorage::LoadACLL()
+// ----------------------------------------------------------------------------------------
+
+void CACLStorage::LoadACLL()
+{
+ RDEBUG("DMUtilServer: Load ACL configuration!");
+
+ //Open rfs
+ RFs rfs;
+ User::LeaveIfError( rfs.Connect());
+ CleanupClosePushL( rfs);
+
+ //Open rfile
+ RFile file;
+ CleanupClosePushL( file);
+
+ TInt err = file.Open( rfs, KStorageBackupFile, EFileRead);
+ file.Close();
+
+ //backup file exist, error in previois save operation, restore backup
+ if ( err == KErrNone)
+ {
+ CFileMan * fileMan = CFileMan::NewL( rfs);
+ CleanupStack::PushL( fileMan);
+
+ User::LeaveIfError( fileMan->Rename( KStorageBackupFile, KStorageFile, CFileMan::EOverWrite));
+
+ CleanupStack::PopAndDestroy( fileMan);
+ }
+
+ //open proper storage file
+ err = file.Open( rfs, KStorageFile, EFileRead);
+
+ if ( err == KErrNone)
+ {
+ TInt size(0);
+ User::LeaveIfError( file.Size( size));
+
+ while ( size > 0)
+ {
+ //read next node size
+ TInt nodeSize(0);
+ TPckg<TInt> pckg(nodeSize);
+ User::LeaveIfError( file.Read( pckg));
+
+ //decrase file remaining index
+ size -= nodeSize;
+ size -= pckg.Length();
+
+ //create buffer for next node string and read string
+ HBufC8 * nodeStr = HBufC8::NewLC( nodeSize);
+ TPtr8 ptr = nodeStr->Des();
+ User::LeaveIfError( file.Read( ptr, nodeSize));
+
+ //create node from string and append it string list
+ CACLNode * node = CACLNode::LoadFromStringL( ptr);
+ CleanupStack::PushL( node);
+ iNodes.AppendL( node);
+
+ CleanupStack::Pop( node);
+ CleanupStack::PopAndDestroy( nodeStr);
+ }
+ }
+
+ CleanupStack::PopAndDestroy( 2, &rfs);
+}
+
+
+
+
+// ----------------------------------------------------------------------------------------
+// CChildInfo::CChildInfo()
+// ----------------------------------------------------------------------------------------
+
+CChildInfo::CChildInfo( RChildNodes& aNodes)
+ : iChilds( aNodes)
+{
+
+}
+
+// ----------------------------------------------------------------------------------------
+// CChildInfo::~CChildInfo()
+// ----------------------------------------------------------------------------------------
+
+CChildInfo::~CChildInfo()
+ {
+ iChilds.Close();
+#ifdef __TARM_SYMBIAN_CONVERGENCY
+ // nothing
+#else
+ delete iBuffer;
+#endif
+ }
+
+// ----------------------------------------------------------------------------------------
+// CChildInfo::GetChildsL()
+// ----------------------------------------------------------------------------------------
+
+
+TInt CChildInfo::GetChildsL( const TDesC8& aURI )
+ {
+ RDEBUG8_2("DMUtilServer: CChildInfo::GetChildsL - Start (%S)", &aURI);
+#ifdef __TARM_SYMBIAN_CONVERGENCY
+ RDmTree dmTreeSession;
+ dmTreeSession.ConnectL();
+ CleanupClosePushL( dmTreeSession );
+
+ CDesC8ArrayFlat* buf = new( ELeave ) CDesC8ArrayFlat( 4 );
+ CleanupStack::PushL( buf );
+
+ dmTreeSession.ChildrenL( aURI, *buf );
+
+ // copy, should be fixed so that this step is not needed
+ for( TInt i = 0; i < buf->Count(); i++ )
+ {
+ iChilds.AppendL( ( *buf)[ i ] );
+ }
+
+ CleanupStack::PopAndDestroy( buf );
+ CleanupStack::PopAndDestroy( &dmTreeSession );
+
+
+ RDEBUG("DMUtilServer: CChildInfo::GetChildsL - End");
+ return KErrNone;
+#else
+ //create dmmodule
+ CNSmlDmModule* dmmodule = CNSmlDmModule::NewL( this);
+ CleanupStack::PushL( dmmodule);
+
+ //fetch objects...
+ dmmodule->FetchObjectL( aURI, KNullDesC8, KResultRef, KStatusRef, ETrue);
+
+ CleanupStack::PopAndDestroy( dmmodule);
+
+ //Check errors
+ TInt error( KErrNone);
+ if ( iErr )
+ {
+ error = KErrGeneral;
+ }
+
+
+ RDEBUG("DMUtilServer: CChildInfo::GetChildsL - End");
+ return error;
+#endif
+ }
+
+
+
+
+
+
+#ifdef __TARM_SYMBIAN_CONVERGENCY
+ // nothing
+#else
+
+
+
+// ----------------------------------------------------------------------------------------
+// CChildInfo::SetResultsL()
+// ----------------------------------------------------------------------------------------
+
+void CChildInfo::SetResultsL( TInt aResultsRef,
+ const CBufBase& aObject,
+ const TDesC8& /*aType*/,
+ const TDesC8& /*aFormat*/,
+ TInt /*aTotalSize*/ )
+{
+ RDEBUG("DMUtilServer: CChildInfo::SetResultsL - Start");
+
+ if ( !aObject.Size())
+ {
+ //no child nodes
+ return;
+ }
+
+ if ( aResultsRef != KResultRef || iErr)
+ {
+ iErr = ETrue;
+ return;
+ }
+
+
+ //create pointer for childlist and read it from package buffer
+ delete iBuffer;
+ iBuffer = 0;
+
+ iBuffer = HBufC8::NewL( aObject.Size());
+
+ TPtr8 bufptr = iBuffer->Des();
+ aObject.Read( 0, bufptr, aObject.Size());
+ TPtrC8 ptr = *iBuffer;
+
+ //separate childrens
+ while ( ptr.Length())
+ {
+ //find separator
+ TInt index = ptr.Locate('/');
+
+ if ( index == KErrNotFound)
+ {
+ iChilds.AppendL( ptr);
+ }
+ else
+ {
+ ptr.Mid( index + 1);
+ iChilds.AppendL( ptr.Right( index));
+ }
+ }
+
+ RDEBUG("DMUtilServer: CChildInfo::SetResultsL - End");
+}
+
+// ----------------------------------------------------------------------------------------
+// CChildInfo::SetStatusL()
+// ----------------------------------------------------------------------------------------
+
+void CChildInfo::SetStatusL( TInt aStatusRef, TInt aStatusCode )
+{
+ iErr = !( aStatusRef == KStatusRef && aStatusCode == 200/*KNSmlDmStatusOK*/);
+}
+
+
+
+#endif
+
+