diff -r 000000000000 -r b497e44ab2fc syncmlfw/dm/treemodule/src/nsmldmddf.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/syncmlfw/dm/treemodule/src/nsmldmddf.cpp	Thu Dec 17 09:07:52 2009 +0200
@@ -0,0 +1,1821 @@
+/*
+* 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:  DM tree etc.
+*
+*/
+
+#include <utf.h>
+#include <smldmadapter.h>
+#include <nsmldebug.h>
+#include <nsmldmmodule.h>
+//For P&S keys
+#include <e32property.h>
+#include "nsmldminternalpskeys.h"
+#include "nsmldmddf.h"
+#include "nsmldmtreeconstants.h"
+#include "nsmldmhostclient.h"
+#include "nsmldmclientandserver.h"
+#include "nsmldmuri.h"
+#include <featmgr.h>
+// FOTA
+#include "nsmldmimpluids.h"
+// FOTA end
+
+#ifndef __WINS__
+// This lowers the unnecessary compiler warning (armv5) to remark.
+// "Warning:  #174-D: expression has no effect..." is caused by 
+// DBG_ARGS8 macro in no-debug builds.
+#pragma diag_remark 174
+#endif
+
+const TInt KGranularity = 4;
+// FOTA
+_LIT8 ( KNSmlDMFotaNode, "FUMO" );
+_LIT8 ( KNSmlDMAcc, "DMAcc");
+_LIT8 ( KNSmlDMRoot, "." );
+// FOTA end
+
+// ===========================================================================
+// CNSmlDmDDF
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// CNSmlDmDDF::CNSmlDmDDF(CNSmlDmModule& aDmModule)
+// ----------------------------------------------------------------------------
+CNSmlDmDDF::CNSmlDmDDF(CNSmlDmModule& aDmModule) : iDmModule(aDmModule)
+	{
+	}
+
+// ----------------------------------------------------------------------------
+// CNSmlDmDDF::~CNSmlDmDDF()
+// ----------------------------------------------------------------------------
+CNSmlDmDDF::~CNSmlDmDDF()
+	{
+	delete iMgmtTree;
+
+	iSessionArray.Reset();
+	iSessionArray.Close();
+	
+	iResultRefs.ResetAndDestroy();
+	iDeleteStatusRefs.ResetAndDestroy();
+	iAddNodeStatusRefs.ResetAndDestroy();
+	if(iAddRootNodesList)
+		{
+		delete iAddRootNodesList;
+		}
+	//P&S key deletion,even fine if the key is not there
+	RProperty::Delete( KPSUidNSmlDMSyncAgent,KNSmlDMCmdAddNodeSuccess);
+	FeatureManager::UnInitializeLib();
+	}
+
+// ----------------------------------------------------------------------------
+//CNSmlDmDDF* CNSmlDmDDF::NewL(CNSmlDmDbHandler *aDbHandler)
+// ----------------------------------------------------------------------------
+CNSmlDmDDF* CNSmlDmDDF::NewL(CNSmlDmModule& aModule)
+	{
+	CNSmlDmDDF* self = new (ELeave) CNSmlDmDDF(aModule);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop();
+	return self;
+	}
+
+// ----------------------------------------------------------------------------
+// void CNSmlDmDDF::GenerateDDFL(CBufBase& aObject)
+// Generates generates xml from the ddf
+// ----------------------------------------------------------------------------
+void CNSmlDmDDF::GenerateDDFL(CBufBase& aObject)
+	{
+	_DBG_FILE("CNSmlDmDDF::GenerateDDFL() : begin");
+	iMgmtTree->GenerateXMLL(aObject);
+	_DBG_FILE("CNSmlDmDDF::GenerateDDFL() : end");
+	}
+
+// ----------------------------------------------------------------------------
+// void CNSmlDmDDF::SetServerL(const TDesC8& aURI)
+// Sets serverid to db
+// ----------------------------------------------------------------------------
+void CNSmlDmDDF::SetServerL(const TDesC8& aServerId)
+	{
+	_DBG_FILE("CNSmlDmDDF::SetServerL() : begin");
+	iDbSession.SetServerL(aServerId);
+	_DBG_FILE("CNSmlDmDDF::SetServerL() : end");
+	}
+
+// ----------------------------------------------------------------------------
+// TBool CNSmlDmDDF::IsDDFChangedL(/*CNSmlDmDbHandler *aDbHandler,*/
+// 	TDesC& aServer)
+// Checks if ddf has been changed. Ask the ddf version from all the adapters
+// and calculates checksum from adapter implementaion uids and versions
+// ----------------------------------------------------------------------------
+TInt CNSmlDmDDF::IsDDFChangedL()
+	{
+	_DBG_FILE("CNSmlDmDDF::IsDDFChangedL() : begin");
+	User::LeaveIfError( iDbSession.Connect() );
+	TInt checkSum(0);
+	for(TInt i=0;i<4;i++)
+		{
+		switch(i)
+			{
+			case 0:
+				if(iSessionArray[i].ConnectL(KNSmlDmHostServer1Name,this)
+					==KErrNone)
+					{
+					iOkSessions=iOkSessions|(0x01<<i);
+					checkSum=checkSum+iSessionArray[i].DDFStructureL(
+						*iMgmtTree);
+					iMgmtTree->SetServerId(i+1);
+					}
+				break;
+			case 1:
+				if(iSessionArray[i].ConnectL(KNSmlDmHostServer2Name,this)
+					==KErrNone)
+					{
+					iOkSessions=iOkSessions|(0x01<<i);
+					checkSum=checkSum+iSessionArray[i].DDFStructureL(
+						*iMgmtTree);
+					iMgmtTree->SetServerId(i+1);
+					}
+				break;
+			case 2:
+				if(iSessionArray[i].ConnectL(KNSmlDmHostServer3Name,this)
+					==KErrNone)
+					{
+					iOkSessions=iOkSessions|(0x01<<i);
+					checkSum=checkSum+iSessionArray[i].DDFStructureL(
+						*iMgmtTree);
+					iMgmtTree->SetServerId(i+1);
+					}
+				break;
+			case 3:
+				if(iSessionArray[i].ConnectL(KNSmlDmHostServer4Name,this)
+					==KErrNone)
+					{
+					iOkSessions=iOkSessions|(0x01<<i);
+					checkSum=checkSum+iSessionArray[i].DDFStructureL(
+						*iMgmtTree);
+					iMgmtTree->SetServerId(i+1);
+					}
+				break;
+			default:
+				User::Panic ( KNSmlTxtPanicDmModule, KErrArgument );
+				break;
+			}
+		}
+	return checkSum;
+	}
+
+
+// ----------------------------------------------------------------------------
+// void CNSmlDmDDF::AddObjectL(const TDesC& aURI, const TDesC8& aObject,
+// 	const TDesC& aType)
+// Adds object, if adapter is found by using th uri, calls the adapters add object function.
+// Adapters AddNodeObjectL is called if not leaf object
+// ----------------------------------------------------------------------------
+void CNSmlDmDDF::AddObjectL(const TDesC8& aURI,
+	const TDesC8& aObject,
+	const TDesC8& aType,
+	const TInt aStatusRef,
+	TBool aLargeItem)
+	{
+	_DBG_FILE("CNSmlDmDDF::AddObjectL() : begin");
+	TBool adapterCalled = EFalse;
+	TInt status = KNSmlDmStatusNotFound;		
+	if(iAdapterId==0||iSessionId==0)
+		{
+		//update not allowed in object group level (levels before adapter
+		//level) 
+		iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusCommandNotAllowed);
+		return;
+		}
+		
+	if(iDbSession.CheckDynamicAclL(aURI,EAclAdd,iMgmtTree))	 //tarm
+		{
+		//acl rigths ok
+		TNSmlDmDDFFormat format = IsLeafL(aURI);
+		TPtrC8 parentUri = NSmlDmURI::ParentURI(aURI);
+		if(format==ENSmlDmDDFLeaf)
+			{
+			HBufC8* luid = iDbSession.GetLuidAllocL(iAdapterId,aURI);
+			TInt len = luid->Length();
+			CleanupStack::PushL(luid);
+
+			TInt find = KErrNotFound;
+			if( !FeatureManager::FeatureSupported( KFeatureIdSyncMlDm112) )//means DM 1.2
+			 {
+			 if(iAddRootNodesList)
+			     {							
+			     HBufC8* puri = HBufC8::NewLC(parentUri.Length()+2);
+			     puri->Des().Append(parentUri);
+			     puri->Des().Append(',');
+			     find = iAddRootNodesList->Find(puri->Des());	
+			     CleanupStack::PopAndDestroy();
+			     }			
+			 if( find <= KErrNotFound )
+			     {
+			     TBool returnstatus = ETrue; 
+			     TPtrC8 Uri1 = NSmlDmURI::URISeg(aURI,1);
+			     if( iAddRootNodesList && Uri1.Match(KNSmlDMAcc) >= KErrNone )//dm case
+			     {
+			     TPtrC8 FindUri = NSmlDmURI::URISeg(aURI,2);
+			     HBufC8* puri = HBufC8::NewLC(Uri1.Length()+FindUri.Length()+2);
+			     puri->Des().Append(aURI.Left(Uri1.Length()+FindUri.Length()+1));
+			     puri->Des().Append(',');
+			     find = iAddRootNodesList->Find(puri->Des());   
+			     CleanupStack::PopAndDestroy();
+			     if(find >= 0)
+			         {
+			         returnstatus = EFalse; 
+			         }
+			     }
+			     if(returnstatus)//not added in this session
+			         {			    	 
+			         _DBG_FILE("CNSmlDmDDF::AddObjectL()node not added in this session");
+                     if(len > 0) //Luid exists,Already existed
+                     {
+                     iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusAlreadyExists);	 
+                     }
+                     else
+                     {
+                     iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusNotFound);
+                     }
+			         CleanupStack::PopAndDestroy(); //luid
+			         return;
+			         }
+			     }
+				}
+			iSessionArray[iSessionId-1].UpdateLeafL(iAdapterId,*luid,
+				aStatusRef,aURI,aObject,aType,aLargeItem);
+			adapterCalled = ETrue;		
+			CleanupStack::PopAndDestroy(); //luid
+			}
+		else
+			{
+			RProperty::Set(KPSUidNSmlDMSyncAgent, 
+						          KNSmlDMCmdAddNodeSuccess, ENotAdded);
+			HBufC8* luid = iDbSession.GetLuidAllocL(iAdapterId,aURI);
+			CleanupStack::PushL(luid);			
+			CNSmlCallbackElement *newElement 
+				= new (ELeave)CNSmlCallbackElement();
+			CleanupStack::PushL(newElement);
+			newElement->iRef = aStatusRef;
+			newElement->iUri = aURI.AllocL();
+			iAddNodeStatusRefs.AppendL(newElement);
+			CleanupStack::Pop(); //newElement
+			iSessionArray[iSessionId-1].AddNodeL(iAdapterId,*luid,aStatusRef,
+				aURI);
+			//means DM 1.2
+			if( !FeatureManager::FeatureSupported( KFeatureIdSyncMlDm112) )
+			  {
+			  //Check the status of add node, so that update the add buffer
+			  TInt NodeAddingSuccess = KErrNotFound;
+			  TInt NodeorLeafexists= KErrNotFound;
+			  TInt err = RProperty::Get(KPSUidNSmlDMSyncAgent, 
+					  KNSmlDMCmdAddNodeSuccess, NodeAddingSuccess);
+			  //This key will be set by DM Host Session's setstatus
+			  TInt err1 = RProperty::Get( KPSUidNSmlDMSyncAgent, 
+					  KNSmlDMCmdAddOnExistingNodeorLeafKey,
+					  NodeorLeafexists );				  
+			  if( ( err1 == KErrNone && NodeorLeafexists == EAddCmd ) && 
+			          (err == KErrNone && (NodeAddingSuccess == EAdded ||
+			                  NodeAddingSuccess == ENotAdded) ) )
+			      {
+			      if(iAddRootNodesList) //already created
+			          {																						
+			          //Do check if there is any node already added					
+			          if( iAddRootNodesList->Match(aURI) <= KErrNotFound ) 
+			              {
+			              iAddRootNodesList = iAddRootNodesList->ReAllocL
+			              (iAddRootNodesList->Length() + aURI.Length()+ 10);
+			              iAddRootNodesList->Des().Append(aURI);
+			              }					
+			          }
+			      else //getting created
+			          {					
+			          iAddRootNodesList = HBufC8::NewL(aURI.Length()+ 10);					
+			          iAddRootNodesList->Des().Append(aURI);
+			          }			      
+			      iAddRootNodesList->Des().Append(',');				
+			      }			  			  
+			  }
+			adapterCalled = ETrue;
+		
+			CleanupStack::PopAndDestroy(); //luid
+			}
+		} //end if(iDbSession.CheckAclL())
+	else
+		{
+		//no acl rights
+		status = KNSmlDmStatusPermissionDenied;
+		}
+
+	if(!adapterCalled)
+		{
+		iDmModule.DoSetStatusL(aStatusRef,status);
+		}
+	_DBG_FILE("CNSmlDmDDF::AddObjectL() : begin");
+	}
+
+// ----------------------------------------------------------------------------
+// void CNSmlDmDDF::UpdateObjectL(const TDesC& aURI, const TDesC8& aObject,
+//	const TDesC& aType)
+// Calls the adapters UpdateObjectL function if the adapter is recognised by
+// using URI 
+// ----------------------------------------------------------------------------
+void CNSmlDmDDF::UpdateObjectL(const TDesC8& aURI,
+	const TDesC8& aObject,
+	const TDesC8& aType,
+	const TInt aStatusRef,
+	TBool aLargeItem,
+	// FOTA
+	TInt aTotSizeOfLarge
+	// FOTA end
+	)
+	{
+	_DBG_FILE("CNSmlDmDDF::UpdateObjectL() : begin");
+
+	TBool adapterCalled = EFalse;
+	TInt status = KNSmlDmStatusNotFound;
+	
+	
+	if(iAdapterId==0||iSessionId==0)
+		{
+		//update not allowed in object group level
+		//(levels before adapter level) 
+		iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusCommandNotAllowed);
+		return;
+		}
+		
+	if(iDbSession.CheckDynamicAclL(aURI,EAclReplace,iMgmtTree)) //tarm
+		{
+		//acl rigths ok
+		TNSmlDmDDFFormat format = IsLeafL(aURI);
+		
+		if(format==ENSmlDmDDFLeaf)
+			{
+			HBufC8* luid = iDbSession.GetLuidAllocL(iAdapterId,aURI);
+			CleanupStack::PushL(luid);
+
+			// FOTA
+			iSessionArray[iSessionId-1].UpdateLeafL(iAdapterId,*luid,
+				aStatusRef,aURI,aObject,aType,aLargeItem,aTotSizeOfLarge);
+			// FOTA end
+			adapterCalled = ETrue;
+		
+			CleanupStack::PopAndDestroy(); //luid
+			}
+		else
+			{
+			status=KNSmlDmStatusCommandNotAllowed;
+			}
+			
+			
+		} //end if(iDbSession.CheckAclL())
+	else
+		{
+		//no acl rights
+		status = KNSmlDmStatusPermissionDenied;
+		}
+
+	if(!adapterCalled)
+		{
+		iDmModule.DoSetStatusL(aStatusRef,status);
+		}
+
+	_DBG_FILE("CNSmlDmDDF::UpdateObjectL() : end");
+	}
+
+// ----------------------------------------------------------------------------
+// void CNSmlDmDDF::FetchObjectL(const TDesC& aURI, const TDesC& aType,
+//	CBufBase& aObject )
+// Calls the adapters FetchObjectL function via IPC if the adapter and 
+// correct host server are recognised by using URI.
+// Adapters ChildURIListL is called, if not leaf object
+// ----------------------------------------------------------------------------
+void CNSmlDmDDF::FetchObjectL(const TDesC8& aURI,
+	const TDesC8& aType,
+	const TInt aResultsRef,
+	const TInt aStatusRef,
+	TBool aAclPass )
+	{
+	_DBG_FILE("CNSmlDmDDF::FetchObjectL() : begin");
+	TBool adapterCalled = EFalse;
+	TInt status = KNSmlDmStatusNotFound;
+
+	if(aAclPass||iDbSession.CheckDynamicAclL(aURI,EAclGet,iMgmtTree)) //tarm
+		{
+		//acl rights ok or internal query when aclchecking is passed
+		HBufC8* luid = NULL;
+
+		if(iAdapterId==0||iSessionId==0)
+			{
+			//this will response to gets before adapter level
+			TInt status = KNSmlDmStatusOK;
+			CBufBase* object = CBufFlat::NewL(128);
+			CleanupStack::PushL(object);
+			CNSmlDmNodeList* final = NULL;
+			if(aURI.Length()==0||aURI.Compare(KNSmlDmRootUri)==0)
+				{
+				//fetch for the root level
+				CNSmlDmNodeList* nodeListPtr = iMgmtTree->iNodeListPtr;
+				//loop through the fisrt level after root
+				while(nodeListPtr!=0)
+					{
+					object->InsertL(object->Size(),
+						nodeListPtr->iNode->iNodeName.iContent,
+						nodeListPtr->iNode->iNodeName.iLength);
+						
+					if(nodeListPtr->iNext!=0)
+						{
+						object->InsertL(object->Size(),KNSmlDmLitSeparator8);
+						}
+					nodeListPtr = nodeListPtr->iNext;
+					}
+				}
+			else
+				{
+				iMgmtTree->FindNameFromNodeListL(aURI,final);
+
+				if(!final)
+					{
+					//the node was not found from ddf
+					status = KNSmlDmStatusNotFound;
+					}
+				else
+					{
+					if(final->iNode)
+						{
+						CNSmlDmNodeList* nodeListPtr =
+							final->iNode->iNodeListPtr;
+					
+						//loop the childs of "final" node
+						while(nodeListPtr)
+							{
+							object->InsertL(object->Size(),
+								nodeListPtr->iNode->iNodeName.iContent,
+								nodeListPtr->iNode->iNodeName.iLength);
+								
+							if(nodeListPtr->iNext)
+								{
+								object->InsertL(object->Size(),
+									KNSmlDmLitSeparator8);
+								}
+							nodeListPtr = nodeListPtr->iNext;
+							}
+						}
+					else
+						{
+						object->InsertL(0,KNullDesC8);
+						}
+					}
+				}
+			iDmModule.DoSetStatusL(aStatusRef,status);
+			if(status == KNSmlDmStatusOK)
+				{
+				CNSmlCallbackElement *newElement =
+					new (ELeave)CNSmlCallbackElement();
+					
+				CleanupStack::PushL(newElement);
+				newElement->iRef = aResultsRef;
+				newElement->iUri = aURI.AllocL();
+				newElement->iNode = ETrue;
+				iResultRefs.AppendL(newElement);
+				CleanupStack::Pop(); //newElement
+				SetResultsL(aResultsRef,*object,aType,object->Size());
+				}
+			CleanupStack::PopAndDestroy(); //object
+			return;
+			} //end if(iAdapterId==0||iSessionId==0)
+
+		luid = iDbSession.GetLuidAllocL(iAdapterId,aURI);
+		CleanupStack::PushL(luid);
+
+		CNSmlCallbackElement *newElement = new (ELeave)CNSmlCallbackElement();
+		CleanupStack::PushL(newElement);
+		newElement->iRef = aResultsRef;
+		newElement->iUri = 0;
+
+		//mapping info found for the uri
+		TNSmlDmDDFFormat format = IsLeafL(aURI);
+		if(format==ENSmlDmDDFLeaf)
+			{
+			newElement->iUri = aURI.AllocL();
+			newElement->iNode = EFalse;
+			iResultRefs.AppendL(newElement);
+			CleanupStack::Pop(); //newElement
+			
+			iSessionArray[iSessionId-1].FetchLeafObjectL(iAdapterId,
+				aURI,*luid,aType,aResultsRef,aStatusRef);
+
+			adapterCalled = ETrue;
+			}
+		else if(format==ENSmlDmDDFNode)
+			{
+			//interior node, ask the childurilist from the adapter
+			CArrayFixFlat<TSmlDmMappingInfo> *previousList
+				=new (ELeave) CArrayFixFlat <TSmlDmMappingInfo> (KGranularity);
+				
+			CleanupStack::PushL(previousList);
+			iDbSession.GetUriSegListL(iAdapterId,aURI,*previousList);
+			newElement->iUri = aURI.AllocL();
+			newElement->iNode = ETrue;
+			iResultRefs.AppendL(newElement);
+			CleanupStack::Pop(2); //previousList,newElement
+			CleanupStack::PushL(previousList);
+			iSessionArray[iSessionId-1].ChildURIListL(iAdapterId,aURI,*luid,
+				*previousList,aResultsRef,aStatusRef);
+				
+			adapterCalled = ETrue;
+			CleanupStack::PopAndDestroy(); //previousList
+			} //end else IsLeaf
+		CleanupStack::PopAndDestroy(); //luid
+		} //end if(iDbSession.CheckAclL())
+	else
+		{
+		status = KNSmlDmStatusPermissionDenied;
+		}
+
+	if(!adapterCalled)
+		{
+		iDmModule.DoSetStatusL(aStatusRef,status);
+		}
+
+	_DBG_FILE("CNSmlDmDDF::FetchObjectL() : end");
+	}
+
+
+// ----------------------------------------------------------------------------
+// void CNSmlDmDDF::FetchObjectSizeL(const TDesC8& aURI,
+//	const TDesC8& aType,
+//	const TInt aResultsRef,
+//	const TInt aStatusRef)
+// Calls the adapters FetchObjectSizeL function via IPC if the adapter and 
+// correct host server are recognised by using URI.
+// ----------------------------------------------------------------------------
+void CNSmlDmDDF::FetchObjectSizeL(const TDesC8& aURI,
+	const TDesC8& aType,
+	const TInt aResultsRef,
+	const TInt aStatusRef)
+	{
+	_DBG_FILE("CNSmlDmDDF::FetchObjectSizeL() : begin");
+
+	if(iAdapterId&&iSessionId)
+		{
+		HBufC8* luid = iDbSession.GetLuidAllocL(iAdapterId,aURI);
+		CleanupStack::PushL(luid);
+
+		CNSmlCallbackElement *newElement = new (ELeave)CNSmlCallbackElement();
+		CleanupStack::PushL(newElement);
+		newElement->iRef = aResultsRef;
+		newElement->iUri = aURI.AllocL();
+		newElement->iNode = EFalse;
+		iResultRefs.AppendL(newElement);
+		CleanupStack::Pop(); //newElement
+		iSessionArray[iSessionId-1].FetchLeafObjectSizeL(iAdapterId,aURI,*luid,aType,aResultsRef,aStatusRef);
+		CleanupStack::PopAndDestroy(); //luid
+		}
+	else
+		{
+		iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusNotFound);
+		}
+
+
+	_DBG_FILE("CNSmlDmDDF::FetchObjectSizeL() : end");
+	}
+
+
+// ----------------------------------------------------------------------------
+// void CNSmlDmDDF::ExecuteObjectL(const TDesC& aURI, const TDesC8& aObject,
+// const TDesC& aType)
+// Calls the adapters ExecuteObjectL function if the adapter is recognised
+// by using URI 
+// ----------------------------------------------------------------------------
+void CNSmlDmDDF::ExecuteObjectL(const TDesC8& aURI,
+	const TDesC8& aObject,
+	const TDesC8& aType,
+	const TInt aStatusRef,
+	// FOTA
+	const TDesC8& aCorrelator,
+	// FOTA end	
+	TBool aLargeItem)
+	{
+	_DBG_FILE("CNSmlDmDDF::ExecuteObjectL() : begin");
+
+	TBool adapterCalled = EFalse;
+	TInt status = KNSmlDmStatusNotFound;
+	
+	if(iAdapterId==0||iSessionId==0)
+		{
+		//update not allowed in object group level
+		//(levels before adapter level) 
+		iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusCommandNotAllowed);
+		return;
+		}
+		
+	if(iDbSession.CheckDynamicAclL(aURI,EAclExecute,iMgmtTree)) //tarm
+		{
+		//acl rigths ok
+		HBufC8* luid = iDbSession.GetLuidAllocL(iAdapterId,aURI);
+		CleanupStack::PushL(luid);
+		// FOTA 
+		// For the FOTA adapter put the correlator to aObject instead of
+		// data.
+		if ( iAdapterId == KNSmlDMFotaAdapterImplUid || iAdapterId == KNSmlDMAMAdapterImplUid)
+			{
+			iSessionArray[iSessionId-1].ExecuteCommandL(iAdapterId,*luid,
+				aStatusRef,aURI,aCorrelator,aType,aLargeItem);
+			}
+		else
+			{
+			iSessionArray[iSessionId-1].ExecuteCommandL(iAdapterId,*luid,
+				aStatusRef,aURI,aObject,aType,aLargeItem);		
+			}
+		// FOTA end			
+		adapterCalled = ETrue;
+		
+		CleanupStack::PopAndDestroy(); //luid
+		} //end if(iDbSession.CheckAclL())
+	else
+		{
+		//no acl rights
+		status = KNSmlDmStatusPermissionDenied;
+		}
+
+	if(!adapterCalled)
+		{
+		iDmModule.DoSetStatusL(aStatusRef,status);
+		}
+
+	_DBG_FILE("CNSmlDmDDF::ExecuteObjectL() : end");
+
+	}
+
+// ----------------------------------------------------------------------------
+// void CNSmlDmDDF::CopyObjectL(const TDesC& aURI, const TDesC8& aObject,
+//	const TDesC& aType)
+// Calls the adapters CopyObjectL function if the adapter is recognised
+// by using URI 
+// ----------------------------------------------------------------------------
+void CNSmlDmDDF::CopyObjectL(const TDesC8& aTargetURI,
+	const TDesC8& aSourceURI,
+	const TDesC8& aType,
+	const TInt aStatusRef)
+	{
+	_DBG_FILE("CNSmlDmDDF::CopyObjectL() : begin");
+
+	TBool adapterCalled = EFalse;
+	TInt status = KNSmlDmStatusNotFound;
+	
+	
+//	if(format==ENode)
+	if(iAdapterId==0||iSessionId==0)
+		{
+		//update not allowed in object group level
+		//(levels before adapter level) 
+		iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusCommandNotAllowed);
+		return;
+		}
+		
+	if(iDbSession.CheckDynamicAclL(aSourceURI,EAclGet,iMgmtTree)&& //tarm
+		iDbSession.CheckDynamicAclL(aTargetURI,EAclAdd,iMgmtTree))
+		{
+		//acl rigths ok
+		HBufC8* targetLuid = iDbSession.GetLuidAllocL(iAdapterId,aTargetURI);
+		CleanupStack::PushL(targetLuid);
+		HBufC8* sourceLuid = iDbSession.GetLuidAllocL(iAdapterId,aSourceURI);
+		CleanupStack::PushL(sourceLuid);
+
+		iSessionArray[iSessionId-1].CopyCommandL(iAdapterId,
+			*targetLuid,aTargetURI,*sourceLuid,aSourceURI,aStatusRef,aType);
+
+		adapterCalled = ETrue;
+		
+		CleanupStack::PopAndDestroy(2); //targetLuid,sourceLuid
+		} //end if(iDbSession.CheckAclL())
+	else
+		{
+		//no acl rights
+		status = KNSmlDmStatusPermissionDenied;
+		}
+
+	if(!adapterCalled)
+		{
+		iDmModule.DoSetStatusL(aStatusRef,status);
+		}
+
+	_DBG_FILE("CNSmlDmDDF::CopyObjectL() : end");
+	}
+
+
+
+
+// ----------------------------------------------------------------------------
+// void CNSmlDmDDF::DeleteObjectL(const TDesC& aURI)
+// Calls the adapters DeleteObjectL function if the adapter is
+// recognised by using URI.
+// ----------------------------------------------------------------------------
+void CNSmlDmDDF::DeleteObjectL(const TDesC8& aURI,const TInt aStatusRef)
+	{
+	_DBG_FILE("CNSmlDmDDF::DeleteObjectL(): begin");
+	TInt status = KNSmlDmStatusNotFound;
+	TBool adapterCalled = EFalse;
+
+	if(iAdapterId==0||iSessionId==0)
+		{
+		//delete not allowed in object group level
+		//(levels before adapter level) 
+		iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusCommandNotAllowed);
+		return;
+		}
+
+	if(iDbSession.CheckDynamicAclL(aURI,EAclDelete,iMgmtTree)) //tarm
+		{
+		//acl rights ok
+		HBufC8* luid = iDbSession.GetLuidAllocL(iAdapterId,aURI);
+		CleanupStack::PushL(luid);
+
+		if(luid->Length())
+			{
+			CNSmlCallbackElement *newElement 
+				= new (ELeave)CNSmlCallbackElement();
+			CleanupStack::PushL(newElement);
+			newElement->iRef = aStatusRef;
+			newElement->iUri = aURI.AllocL();
+			iDeleteStatusRefs.AppendL(newElement);
+			CleanupStack::Pop(); //newElement
+			
+			iSessionArray[iSessionId-1].DeleteObjectL(iAdapterId,*luid,
+				aStatusRef,aURI);
+				
+			adapterCalled = ETrue;
+			}
+		else
+			{
+			iSessionArray[iSessionId-1].DeleteObjectL(iAdapterId,*luid,
+				aStatusRef,aURI);
+				
+			adapterCalled = ETrue;
+			}	
+		CleanupStack::PopAndDestroy(); //luid
+		} //end if(iDbSession.CheckAclL())
+	else
+		{
+		status = KNSmlDmStatusPermissionDenied;
+		}
+
+	if(!adapterCalled)
+		{
+		iDmModule.DoSetStatusL(aStatusRef,status);
+		}
+
+	_DBG_FILE("CNSmlDmDDF::DeleteObjectL() : end");
+	}
+
+
+// ----------------------------------------------------------------------------
+// CNSmlDmDDF::CheckURIL(const TDesC& aURI)
+// Compares URI to ddf and check that URI is valid
+// ----------------------------------------------------------------------------
+CNSmlDmDDF::TAccess CNSmlDmDDF::CheckURIL(const TDesC8& aURI,
+	TNSmlDmCmdType aCmd)
+	{
+	_DBG_FILE("CNSmlDmDDF::CheckURIL() : begin");
+	TAccess ret(ENotExist);
+	TUint8 access(0);
+	TUriCheck found = CheckAdapterL(aURI,access);
+	if(found!=EUriNotFound)
+		{
+		//uri OK, now check the access which is set in ddf
+		ret = ENotAccess;
+		switch(aCmd)
+			{
+			case EAclAdd:
+			if(access&TSmlDmAccessTypes::EAccessType_Add)
+				{
+				ret = EOk;
+				}
+			break;
+		
+			case EAclReplace:
+			if(access&TSmlDmAccessTypes::EAccessType_Replace)
+				{
+				ret = EOk;
+				}
+			break;
+		
+			case EAclGet:
+			if(access&TSmlDmAccessTypes::EAccessType_Get)
+				{
+				ret = EOk;
+				}
+			break;
+	
+			case EAclDelete:
+			if(access&TSmlDmAccessTypes::EAccessType_Delete)
+				{
+				ret = EOk;
+				}
+			break;
+
+			case EAclExecute:
+			if(access&TSmlDmAccessTypes::EAccessType_Exec)
+				{
+				ret = EOk;
+				}
+			break;
+
+			case EAclCopy:
+			if(access&TSmlDmAccessTypes::EAccessType_Copy)
+				{
+				ret = EOk;
+				}
+			break;
+			default:
+			User::Panic ( KNSmlTxtPanicDmModule, KErrArgument );
+			break;
+			}
+		}
+
+	_DBG_FILE("CNSmlDmDDF::CheckURIL() : end");
+	return ret;
+	}
+
+
+
+
+// ----------------------------------------------------------------------------
+// void CNSmlDmDDF::ConstructL()
+// Second phase constructor
+// ----------------------------------------------------------------------------
+void CNSmlDmDDF::ConstructL()
+	{
+	_DBG_FILE("CNSmlDmDDF::ConstructL() : begin");
+	iMgmtTree = CNSmlDmMgmtTree::NewL();
+	iResultSessionId=KErrNotFound;
+	for(TInt i=0;i<4;i++)
+		{
+		RNSmlDMDataSession session;
+		iSessionArray.AppendL(session);
+		}
+    FeatureManager::InitializeLibL(); 		
+    RProperty::Define(KPSUidNSmlDMSyncAgent,
+    		KNSmlDMCmdAddNodeSuccess, RProperty::EInt,
+			KReadPolicy, KWritePolicy );
+	_DBG_FILE("CNSmlDmDDF::ConstructL() : end");
+	}
+
+
+// ----------------------------------------------------------------------------
+// CNSmlDmDDF::CheckAclL( const TDesC& aURI,
+// CNSmlDmDbHandler::TCmdType aCmdType)
+// Does the ACL checking
+// ----------------------------------------------------------------------------
+TBool CNSmlDmDDF::CheckAclL( const TDesC8& aURI, TNSmlDmCmdType aCmdType)
+	{
+	TUint8 access(0);
+	if(aURI.Length()==0||aURI.Compare(KNSmlDmRootUri)==0
+		||CheckAdapterL(aURI,access)!=EUriNotFound)
+		{
+		return iDbSession.CheckDynamicAclL(aURI,aCmdType,iMgmtTree); //tarm
+		}
+	return EFalse;
+	}
+
+
+// ----------------------------------------------------------------------------
+// CNSmlDmDDF::UpdateAclL( const TDesC& aURI,const TDesC8 &aACL)
+// Updates ACL to tree db
+// ----------------------------------------------------------------------------
+void CNSmlDmDDF::UpdateAclL( const TDesC8& aURI,
+	const TDesC8 &aACL, const TInt aStatusRef)
+	{
+	if(aURI.Length()==0||aURI.Compare(KNSmlDmRootUri)==0)
+	    {
+		iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusForbidden);
+	    }
+	else
+	    {
+    	TNSmlDmDDFFormat format = IsLeafL(aURI);
+    	TBool access(0);
+    	TPtrC8 parentUri = NSmlDmURI::ParentURI(aURI);
+    	if(format==ENSmlDmDDFLeaf)
+    		{
+    		access = CheckAclL(parentUri,EAclReplace);
+    		}
+    	else
+    		{
+    		access = CheckAclL(parentUri,EAclReplace)
+    			||CheckAclL(aURI,EAclReplace);
+    		}
+
+    	if(access)
+    		{
+    		TInt ret = iDbSession.UpdateAclL(aURI,aACL);
+    		if( ret == KErrNone)
+    			{
+    			iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusOK);
+    			}
+    		else if( ret == KErrAccessDenied)
+    			{
+    			iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusForbidden);
+    			}
+    		else
+    			{
+    			iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusCommandFailed);
+    			}
+    		}
+    	else
+    		{
+    		iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusPermissionDenied);
+    		}
+	    }
+	}
+
+// ----------------------------------------------------------------------------
+// CNSmlDmDDF::GetAclL( const TDesC& aURI, CBufBase &aACL)
+// ----------------------------------------------------------------------------
+TInt CNSmlDmDDF::GetAclL( const TDesC8& aURI, CBufBase &aACL)
+	{
+	TInt ret = KNSmlDmStatusPermissionDenied;
+	if(CheckAclL(aURI,EAclGet))
+		{
+		iDbSession.GetAclL(aURI,aACL,EFalse);
+		ret = KNSmlDmStatusOK;
+		}
+	return ret;
+	}
+
+
+// ----------------------------------------------------------------------------
+// CNSmlDmDDF::GetLuidAllocL(const TDesC& aURI)
+// gets and allocates the mapped luid from tree db
+// ----------------------------------------------------------------------------
+HBufC8* CNSmlDmDDF::GetLuidAllocL(const TDesC8& aURI)
+	{
+	HBufC8* luid=0;
+	if(CheckURIL(aURI,EAclGet)!=CNSmlDmDDF::ENotExist)
+		{
+		if(iAdapterId)
+			{
+			luid = iDbSession.GetLuidAllocL(iAdapterId,aURI);
+			}
+		}
+	if(!luid)
+		{
+		luid = KNullDesC8().AllocL();
+		}
+	return luid;
+	}
+
+
+// ----------------------------------------------------------------------------
+// CNSmlDmDDF::StartAtomicL()
+// Start atomic indication
+// ----------------------------------------------------------------------------
+void CNSmlDmDDF::StartAtomicL()
+	{
+	for(TInt i=0;i<4;i++)
+		{
+		if(iOkSessions&(0x01<<i))
+			{
+			iSessionArray[i].StartAtomicL();
+			}
+		}
+	iDbSession.StartAtomic();
+	}
+	
+// ----------------------------------------------------------------------------
+// CNSmlDmDDF::CommitAtomicL()
+// Commit atomic indication
+// ----------------------------------------------------------------------------
+void CNSmlDmDDF::CommitAtomicL()
+	{
+	for(TInt i=0;i<4;i++)
+		{
+		if(iOkSessions&(0x01<<i))
+			{
+			iSessionArray[i].CommitAtomicL();
+			}
+		}
+	iDbSession.CommitAtomic();
+	}
+	
+// ----------------------------------------------------------------------------
+// CNSmlDmDDF::RollbackAtomicL()
+// Rollback atomic indication
+// ----------------------------------------------------------------------------
+void CNSmlDmDDF::RollbackAtomicL()
+	{
+	for(TInt i=0;i<4;i++)
+		{
+		if(iOkSessions&(0x01<<i))
+			{
+			iSessionArray[i].RollbackAtomicL();
+			}
+		}
+	iDbSession.RollbackAtomic();
+	}
+
+// ----------------------------------------------------------------------------
+// CNSmlDmDDF::DisconnectFromOtherServers()
+//	Closes the connections to callback server and host servers.
+//	Separate function is needed, since the disconnecting cannot 
+//	be made after the active scheduler of the thread is stopped.
+// ----------------------------------------------------------------------------
+//
+void CNSmlDmDDF::DisconnectFromOtherServers()
+	{
+	iDbSession.Close();
+	for ( TInt i(0); i<iSessionArray.Count(); i++ )
+		{
+		if(iOkSessions&(0x01<<i))
+			{
+			iSessionArray[i].Close();
+			}
+		}
+	}
+// FOTA
+// ----------------------------------------------------------------------------
+// CNSmlDmDDF::MarkGenAlertsSentL()
+//	When the generic alerts are successfully sent to the remote 
+//	server, the FOTA adapter needs to be informed about this.
+//	This command is chained through the DM engine.
+// ----------------------------------------------------------------------------
+//
+void CNSmlDmDDF::MarkGenAlertsSentL()
+	{
+	CNSmlDmNodeList* final = NULL;
+	iMgmtTree->FindNameFromNodeListL ( KNSmlDMFotaNode, final );
+	if ( final )
+		{
+		TUint32 adapterId(0);
+		TUint8 sessionId(0);
+		final->GetImplUid ( adapterId, sessionId );
+		iSessionArray[sessionId-1].MarkGenAlertsSent();
+		}
+	}
+// FOTA end
+
+
+// ----------------------------------------------------------------------------
+// CNSmlDmDDF::MarkGenAlertsSentL(const TDesC8& aURI)
+//	When the generic alerts are successfully sent to the remote 
+//	server, the FOTA adapter needs to be informed about this.
+//	This command is chained through the DM engine.
+//  For 1.2 Any adapter can send the Generic adapter,
+//  Hence URI of adapter is passed 
+// ----------------------------------------------------------------------------
+//   
+ 
+void CNSmlDmDDF::MarkGenAlertsSentL(const TDesC8& aURI)
+
+    {
+    _DBG_FILE("CNSmlDmDDF::MarkGenAlertsSentL (TDesC8& aURI) : begin");
+    CNSmlDmNodeList* final = NULL;
+    //Get the first root node from the aURI
+     HBufC8* nodeURI = HBufC8::NewLC(aURI.Length());
+    TInt i= 0;
+    TBool dotPresentInURI = EFalse;
+    for( i=0; i < aURI.Length(); i++ )
+        {
+        if((aURI[i] == '.') && (i==0))
+        {
+        	dotPresentInURI = ETrue;
+        	continue;
+        }
+        
+        if((aURI[i] == '/') && (i==1))
+        continue;
+        if(aURI[i]=='/')
+            {
+            break;
+            }
+        }
+
+    if(i>0)
+        {
+        if(dotPresentInURI)
+        {
+        	 nodeURI->Des().Format(aURI.Mid(2,i-2)); // removing ./
+        }
+        else
+        {
+        	 nodeURI->Des().Format(aURI.Left(i));
+        }
+        }
+       iMgmtTree->FindNameFromNodeListL (nodeURI->Des(),final);
+       
+       if(final)
+        {
+        _DBG_FILE("CNSmlDmDDF::MarkGenAlertsSentL (TDesC8& aURI) Adapter found  ");  
+         
+        TUint32 adapterId(0);
+		TUint8 sessionId(0);
+		final->GetImplUid ( adapterId, sessionId );
+		if(sessionId == 0)
+		{
+		  sessionId = 1;
+		}
+		 
+	    iSessionArray[sessionId-1].MarkGenAlertsSent(nodeURI->Des());
+        }
+       else
+        {
+         _DBG_FILE("CNSmlDmDDF::MarkGenAlertsSentL (TDesC8& aURI) Adapter NOT found  ");  
+        }
+        CleanupStack::PopAndDestroy(); //nodeURI
+        _DBG_FILE("CNSmlDmDDF::MarkGenAlertsSentL (TDesC8& aURI) : END");
+    }
+// ----------------------------------------------------------------------------
+// CNSmlDmDDF::CheckAdapterL(const TDesC& aURI)
+// Finds the correct adapter from correct host server by using DDF.
+// EUriNotFound returned if uri not according to DDF
+// EBeforeAdapter returned if URI ok, but points to node bfore
+// adapterlevel
+// EPassAdapter returned if command should pass to adapeter
+// In pass adapter case, iAdapterId is set to correct adapters uid and
+// iSessionId is set to point to session to correct host server.
+// ----------------------------------------------------------------------------
+CNSmlDmDDF::TUriCheck CNSmlDmDDF::CheckAdapterL(const TDesC8& aURI,
+	TUint8& aAccess)
+	{
+	_DBG_FILE("CNSmlDmDDF::CheckAdapterL() : begin");
+
+	aAccess = 0;
+
+	//check if root level
+	if(aURI.Length()==0||aURI.Compare(KNSmlDmRootUri)==0)
+		{
+		iAdapterId = 0;
+		iSessionId = 0;
+		aAccess |= TSmlDmAccessTypes::EAccessType_Get;
+		aAccess |= TSmlDmAccessTypes::EAccessType_Replace;
+		return EBeforeAdapter;
+		}
+
+	TUriCheck found = EUriNotFound;
+
+
+	CNSmlDmNodeList* final=0;
+	iMgmtTree->FindNameFromNodeListL(aURI,final);
+
+	if(!final)
+		{
+		iAdapterId = 0;
+		iSessionId = 0;
+		return EUriNotFound;
+		}
+	else
+		{
+		final->GetImplUid(iAdapterId,iSessionId);
+		aAccess |= final->iNode->iDFProperties.iAccessTypes;
+		if(iAdapterId==0||iSessionId==0)
+			{
+			//before adapter level, do not pass adapter
+			found = EBeforeAdapter;
+			iAdapterId=0;
+			iSessionId=0;
+			}
+		else
+			{
+			//adapter level, adapter is loaded and EPassAdapter returned
+			found = EPassAdapter;
+			}
+		}
+
+	_DBG_FILE("CNSmlDmDDF::CheckAdapterL() : end");
+	return found;
+	}
+
+
+// ----------------------------------------------------------------------------
+// TFormat CNSmlDmDDF::IsLeafL(const TDesC& aURI)
+// Function checks if the object pointed by aURI is leaf object of
+// the adapter returns ELeaf, ENode or ENotFound
+// ----------------------------------------------------------------------------
+TNSmlDmDDFFormat CNSmlDmDDF::IsLeafL(const TDesC8& aURI)
+	{
+	_DBG_FILE("CNSmlDmDDF::IsLeafL() : begin");
+
+	_DBG_FILE("CNSmlDmDDF::IsLeafL : before FindNameFromNodelist()");
+	CNSmlDmNodeList* final;
+	return iMgmtTree->FindNameFromNodeListL(aURI,final);
+	}
+
+
+// ----------------------------------------------------------------------------
+// CNSmlDmDDF::GetFormatAllocL()
+// Get format from ddf
+// ----------------------------------------------------------------------------
+HBufC8* CNSmlDmDDF::GetFormatAllocL(const TDesC8& aURI)
+	{
+	_DBG_FILE("CNSmlDmDDF::GetFormatAllocL() : begin");
+
+	CNSmlDmNodeList* final=0;
+	iMgmtTree->FindNameFromNodeListL(aURI,final);
+
+	HBufC8* format = 0;
+	if(!final)
+		{
+		format = HBufC8::NewL(KNSmlDmFormatNode().Length());
+		format->Des().Format(KNSmlDmFormatNode);
+		return format;
+		}
+	else
+		{
+		switch(final->iNode->iDFProperties.iDFFormat)
+			{
+			case MSmlDmDDFObject::EChr:
+				format = KNSmlDmFormatChr().AllocL();
+				break;
+
+			case MSmlDmDDFObject::EB64:
+				format = KNSmlDmFormatB64().AllocL();
+				break;
+
+			case MSmlDmDDFObject::EBool:
+				format = KNSmlDmFormatBool().AllocL();
+				break;
+
+			case MSmlDmDDFObject::EInt:
+				format = KNSmlDmFormatInt().AllocL();
+				break;
+
+			case MSmlDmDDFObject::ENode:
+				format = KNSmlDmFormatNode().AllocL();
+				break;
+
+			case MSmlDmDDFObject::ENull:
+				format = KNSmlDmFormatNull().AllocL();
+				break;
+
+			case MSmlDmDDFObject::EXml:
+				format = KNSmlDmFormatXml().AllocL();
+				break;
+
+			case MSmlDmDDFObject::EBin:
+				format = KNSmlDmFormatBin().AllocL();
+				break;
+            
+    		case MSmlDmDDFObject::EDate:
+    			{
+    			if(!FeatureManager::FeatureSupported( KFeatureIdSyncMlDm112  ))
+    			format = KNSmlDDFFormatDate().AllocL();
+    			else
+				format = KNSmlDmFormatChr().AllocL();
+    		    break;
+    			}
+    		case MSmlDmDDFObject::ETime:
+    			{
+    			if(!FeatureManager::FeatureSupported( KFeatureIdSyncMlDm112  ))
+    		    format = KNSmlDDFFormatTime().AllocL();
+    			else
+    			format = KNSmlDmFormatChr().AllocL();
+    		    break;
+    			}
+    		case MSmlDmDDFObject::EFloat:
+    			{
+    			if(!FeatureManager::FeatureSupported( KFeatureIdSyncMlDm112  ))
+    		    format = KNSmlDDFFormatFloat().AllocL();
+    			else
+    			format = KNSmlDmFormatChr().AllocL();
+    			break;
+    			}
+	
+			default:
+				format = KNSmlDmFormatChr().AllocL();
+				break;
+			}
+		}
+	return format;
+	}
+
+
+// ----------------------------------------------------------------------------
+// CNSmlDmDDF::GetMimeTypeL()
+// Get mimetype from ddf
+// ----------------------------------------------------------------------------
+TInt CNSmlDmDDF::GetMimeTypeL(const TDesC8& aURI,CBufBase& aObject)
+	{
+	_DBG_FILE("CNSmlDmDDF::GetMimeTypeL() : begin");
+
+	CNSmlDmNodeList* final=0;
+	iMgmtTree->FindNameFromNodeListL(aURI,final);
+
+	TInt ret(KErrNotFound);
+	if(final)
+		{
+		ret = KErrNone;
+		if(final->iNode->iDFProperties.iDFType)
+			{
+			aObject.InsertL(0,final->iNode->iDFProperties.iDFType->iContent,
+				final->iNode->iDFProperties.iDFType->iLength);
+			}
+		else
+			{
+			aObject.InsertL(0,KNullDesC8);
+			}
+		}
+	return ret;
+	}
+
+
+// ----------------------------------------------------------------------------
+// CNSmlDmDDF::GetCaseSenseL()
+// Get mimetype from ddf
+// ----------------------------------------------------------------------------
+TInt CNSmlDmDDF::GetCaseSenseL(const TDesC8& aURI,CBufBase& aObject)
+	{
+	_DBG_FILE("CNSmlDmDDF::GetCaseSenseL() : begin");
+
+	CNSmlDmNodeList* final=0;
+	TInt ret(KErrNotFound);
+	   
+    if(aURI.Compare(KNSmlDMRoot)==0)
+    {
+    	ret = KErrNone;
+    	aObject.InsertL(0,KNSmlDDFCaseSense,
+				KNSmlDDFCaseSense.iTypeLength);
+    }
+    else
+    {
+    iMgmtTree->FindNameFromNodeListL(aURI,final);	
+    }
+	if(final)
+		{
+		ret = KErrNone;
+		if(final->iNode->iDFProperties.iCaseSense)
+			{
+			aObject.InsertL(0,KNSmlDDFCaseSense,
+				KNSmlDDFCaseSense.iTypeLength);
+			}
+		else
+			{
+			aObject.InsertL(0,KNSmlDDFCaseSense,
+				KNSmlDDFCaseInSense.iTypeLength);
+				
+		//	aObject.InsertL(0,KNullDesC8);
+			}
+		}
+	return ret;
+	}
+
+
+// ----------------------------------------------------------------------------
+// CNSmlDmDDF::GetNameL()
+// Function which gets the name from ddf by using URI
+// ----------------------------------------------------------------------------
+TInt CNSmlDmDDF::GetNameL(const TDesC8& aURI,CBufBase& aObject)
+	{
+	_DBG_FILE("CNSmlDmDDF::GetMimeTypeL() : begin");
+
+	CNSmlDmNodeList* final=NULL;
+	iMgmtTree->FindNameFromNodeListL(aURI,final);
+
+
+	if(!final)
+		{
+		return KErrNotFound;
+		}
+	else
+		{
+		aObject.InsertL(0,final->iNode->iNodeName.iContent,
+			final->iNode->iNodeName.iLength);
+		}
+	return KErrNone;
+	}
+
+
+
+// ----------------------------------------------------------------------------
+// void CNSmlDmDDF::RemoveEndAndBeginSlashes(CBufBase &aObject)
+// Removes "/" marks from the end and begin of the aObject 
+// ----------------------------------------------------------------------------
+void CNSmlDmDDF::RemoveEndAndBeginSlashes(CBufBase &aObject) const
+	{
+	if(aObject.Size()!=0)
+		{
+		if(aObject.Ptr(0)[0]==KNSmlDMUriSeparator)
+			{
+			aObject.Delete(0,1);
+			}
+		if(aObject.Ptr(aObject.Size()-1)[0]==KNSmlDMUriSeparator)
+			{
+			aObject.Delete(aObject.Size()-1,1);
+			aObject.Compress();
+			}
+		}
+	}
+
+// ----------------------------------------------------------------------------
+// void CNSmlDmDDF::MoreDataL(CBufBase*& adata)
+// Gets more data in case of largeobject
+// ----------------------------------------------------------------------------
+void CNSmlDmDDF::MoreDataL(CBufBase*& aData)
+	{
+	if(iResultSessionId>=0)
+		{
+		iSessionArray[iResultSessionId].MoreDataL(aData);
+		}
+	}
+
+
+// ----------------------------------------------------------------------------
+// void CNSmlDmDDF::EndMessageL( )
+// Message ends
+// ----------------------------------------------------------------------------
+void CNSmlDmDDF::EndMessageL( )
+	{
+	_DBG_FILE("CNSmlDmDDF::EndMessageL() : begin");
+	TInt i;
+	if(iResultSessionId==KErrNotFound)
+		{
+    	_DBG_FILE("CNSmlDmDDF::EndMessageL() :iResultSessionId==KErrNotFound ");
+		for(i=0;i<iSessionArray.Count();i++)
+			{
+			if(iOkSessions&(0x01<<i))
+				{
+            	_DBG_FILE("CNSmlDmDDF::EndMessageL():before CompleteOuts...");
+				iSessionArray[i].CompleteOutstandingCmdsL();
+				}
+			}
+		}
+
+	iResultRefs.ResetAndDestroy();
+	iDeleteStatusRefs.ResetAndDestroy();
+	iAddNodeStatusRefs.ResetAndDestroy();
+	_DBG_FILE("CNSmlDmDDF::EndMessageL() : end");
+	}
+
+
+
+// ----------------------------------------------------------------------------
+// void CNSmlDmDDF::SetMappingL(const TDesC& aURI, const TDesC& aLUID )
+// Callback function which is called by adapter for setting the mapping info
+// ----------------------------------------------------------------------------
+void CNSmlDmDDF::SetMappingL(const TDesC8& aURI, const TDesC8& aLUID )
+	{
+	iDbSession.AddMappingInfoL(iAdapterId,aURI,aLUID);
+	}
+
+
+
+// ----------------------------------------------------------------------------
+// void CNSmlDmDDF::SetStatusL( TInt aStatusRef, 
+//	CNSmlDmAdapter::TError aErrorCode )
+// Callback function which is called by adapter for returning correct
+//	statuscode
+// ----------------------------------------------------------------------------
+void CNSmlDmDDF::SetStatusL( TInt aStatusRef,
+	MSmlDmAdapter::TError aErrorCode )
+	{
+
+	TInt status = KNSmlDmStatusCommandFailed;
+	//map the adapter return code to statuscode
+	switch(aErrorCode)
+		{
+		case MSmlDmAdapter::EOk:
+		status=KNSmlDmStatusOK;
+		break;
+
+		case MSmlDmAdapter::ENotFound:
+		status=KNSmlDmStatusNotFound;
+		break;
+							
+		case MSmlDmAdapter::EInvalidObject:
+		break;
+							
+		case MSmlDmAdapter::EAlreadyExists:
+		status=KNSmlDmStatusAlreadyExists;
+		break;
+							
+		case MSmlDmAdapter::ETooLargeObject:
+		status=KNSmlDmStatusRequestEntityTooLarge;
+		break;
+		
+		case MSmlDmAdapter::EDiskFull:
+		status = KNSmlDmStatusDeviceFull;
+		break;
+
+		case MSmlDmAdapter::EError:
+		status = KNSmlDmStatusCommandFailed;
+		break;
+
+		case MSmlDmAdapter::ERollbackFailed:
+		status = KNSmlDmStatusAtomicRollBackFailed;
+		break;
+
+		case MSmlDmAdapter::EObjectInUse:
+		break;
+
+		case MSmlDmAdapter::ENoMemory:
+		status = KNSmlDmStatusDeviceFull;
+		break;
+
+		case MSmlDmAdapter::ECommitOK:
+		status = KNSmlDmStatusOK;
+		break;
+
+		case MSmlDmAdapter::ERollbackOK:
+		status = KNSmlDmStatusAtomicRollBackOK;
+		break;
+
+		case MSmlDmAdapter::ECommitFailed:
+		status=KNSmlDmStatusOK;
+		break;
+        
+		case MSmlDmAdapter::ENotAllowed:
+		status = KNSmlDmStatusCommandNotAllowed;
+		break;
+
+		case MSmlDmAdapter::EAcceptedForProcessing:
+		status =	KNSmlDmStatusAcceptedForProcessing;
+		break;
+		
+		case MSmlDmAdapter::EExecSuccess:
+		status =	KNSmlDmStatusSuccess;
+		break;
+		
+case MSmlDmAdapter::EExecClientError:
+status =	KNSmlDmStatusClientError;
+		break;
+case MSmlDmAdapter::		EExecUserCancelled:
+status =	KNSmlDmStatusUserCancelled;
+		break;
+case MSmlDmAdapter::		EExecDownloadFailed:
+status =	KNSmlDmStatusDownloadFailed;
+		break;
+case MSmlDmAdapter::		EExecAltDwnldAuthFail:
+status =	KNSmlDmStatusAltDwnldAuthFail;
+		break;
+case MSmlDmAdapter::		EExecDownFailOOM:
+status =	KNSmlDmStatusDownFailOOM;
+		break;
+case MSmlDmAdapter::		EExecInstallFailed:
+status =	KNSmlDmStatusInstallFailed;
+		break;
+case MSmlDmAdapter::		EExecInstallOOM:
+status =	KNSmlDmStatusInstallOOM;
+		break;
+case MSmlDmAdapter::		EExecPkgValidationFail:
+status =	KNSmlDmStatusPkgValidationFail;
+		break;
+case MSmlDmAdapter::		EExecRemoveFailed:
+status =	KNSmlDmStatusRemoveFailed;
+		break;
+case MSmlDmAdapter::		EExecActivateFailed:
+status =	KNSmlDmStatusActivateFailed;
+		break;
+case MSmlDmAdapter::		EExecDeactivateFailed:
+status =	KNSmlDmStatusDeactivateFailed;
+		break;
+case MSmlDmAdapter::		EExecNotImplemented:
+status =	KNSmlDmStatusNotImplemented;
+		break;
+case MSmlDmAdapter::		EExecUndefError:
+status =	KNSmlDmStatusUndefError;
+		break;
+case MSmlDmAdapter::		EExecOperationReject:
+status =	KNSmlDmStatusOperationReject;
+		break;
+case MSmlDmAdapter::		EExecAltDwnldSrvError:
+status =	KNSmlDmStatusAltDwnldSrvError;
+		break;
+case MSmlDmAdapter::		EExecAltDwnldSrvUnavailable:
+status =	KNSmlDmStatusAltDwnldSrvUnavailable;
+		break;
+		
+		default:
+		status = KNSmlDmStatusCommandFailed;
+		break;
+		}
+	DeleteandAddStatusRefsL(aStatusRef, aErrorCode);
+
+	iDmModule.DoSetStatusL(aStatusRef,status);
+	}
+
+
+// ----------------------------------------------------------------------------
+// void CNSmlDmDDF::SetResultsL( TInt aResultsRef, CBufBase& aObject,
+//	const TDesC& aType )
+// Callback function which is called by adapter for returning correct
+// statuscode
+// ----------------------------------------------------------------------------
+void CNSmlDmDDF::SetResultsL( TInt aResultsRef,
+	CBufBase& aObject,
+	const TDesC8& aType,
+	TInt aTotalSize,
+	TInt8 aSessionId )
+	{
+	_DBG_FILE("CNSmlDmDDF::SetResultsL() : begin");
+	if(aObject.Size()<aTotalSize)
+		{
+		DBG_ARGS8(_S8("CNSmlDmDDF::SetResultsL,Size= %d, TotalSize= %d"),
+		    aObject.Size(),aTotalSize  );
+		iResultSessionId=aSessionId;
+		}
+	else
+		{
+		DBG_ARGS8(
+		    _S8("CNSmlDmDDF::SetResultsL not large,Size= %d,TotalSize= %d"),
+		    aObject.Size(),aTotalSize  );
+		iResultSessionId=KErrNotFound;
+		}
+	TInt index = -1;
+	for(TInt i=0;i<iResultRefs.Count();i++)
+		{
+		if(iResultRefs[i]->iRef == aResultsRef)
+			{
+			if(iResultRefs[i]->iNode)
+				{
+				RemoveEndAndBeginSlashes(aObject);
+				
+				iDbSession.UpdateMappingInfoL(iAdapterId,
+					*iResultRefs[i]->iUri,aObject);
+					
+#ifdef NOT_DEFINED //tarm start (removed)
+				CNSmlDmNodeList* final=NULL;
+            	iMgmtTree->FindNameFromNodeListL(*iResultRefs[i]->iUri,final);
+
+            	if(final&&final->iNode)
+            	    {
+            	    final = final->iNode->iNodeListPtr;
+            	    if(final&&final->iNode->iNodeName.iLength==0)
+            	        {
+                		iDbSession.DefaultACLsToChildrenL(*iResultRefs[i]->iUri,aObject);
+            	        }
+            	    }
+#endif //tarm end
+				}
+			index = i;
+			break;
+			}
+		}
+
+	if(index>=0)
+		{
+		HBufC8* format = GetFormatAllocL(*iResultRefs[index]->iUri);
+		CleanupStack::PushL(format);
+		delete iResultRefs[index];
+		iResultRefs.Remove(index);
+		iDmModule.DoSetResultsL(aResultsRef,aObject,aType,
+			format->Des(),aTotalSize);
+		CleanupStack::PopAndDestroy(); //format
+		}
+	}
+
+
+
+// ===========================================================================
+// CNSmlDmLinkCallback
+// ===========================================================================
+
+// ----------------------------------------------------------------------------
+// CNSmlDmLinkCallback::CNSmlDmLinkCallback()
+// ----------------------------------------------------------------------------
+CNSmlDmLinkCallback::CNSmlDmLinkCallback()
+	{
+	}
+
+// ----------------------------------------------------------------------------
+// CNSmlDmLinkCallback::~CNSmlDmLinkCallback()
+// ----------------------------------------------------------------------------
+CNSmlDmLinkCallback::~CNSmlDmLinkCallback()
+	{
+	delete iResults;
+	}
+
+// ----------------------------------------------------------------------------
+// CNSmlDmLinkCallback::NewL()
+// ----------------------------------------------------------------------------
+CNSmlDmLinkCallback* CNSmlDmLinkCallback::NewL()
+	{
+	CNSmlDmLinkCallback* self = new (ELeave) CNSmlDmLinkCallback();
+	return self;
+	}
+
+// ----------------------------------------------------------------------------
+// CNSmlDmLinkCallback::SetResultsL()
+// ----------------------------------------------------------------------------
+void CNSmlDmLinkCallback::SetResultsL( TInt /*aResultsRef*/,
+	const CBufBase& aObject,
+	const TDesC8& /*aType*/,
+	const TDesC8& /*aFormat*/,
+	TInt /*aTotalSize*/)
+	{
+	if(!iResults)
+		{
+		iResults = CBufFlat::NewL(16);
+		}
+	else
+		{
+		iResults->Reset();
+		}
+	iResults->InsertL(0,CONST_CAST(CBufBase&,aObject).Ptr(0),aObject.Size());
+	}
+
+// ----------------------------------------------------------------------------
+// CNSmlDmLinkCallback::SetStatusL()
+// ----------------------------------------------------------------------------
+void CNSmlDmLinkCallback::SetStatusL( TInt /*aStatusRef*/, TInt aStatusCode )
+	{
+	iStatus = aStatusCode;
+	}
+
+// ----------------------------------------------------------------------------
+// CNSmlDmLinkCallback::GetResultsL()
+// ----------------------------------------------------------------------------
+void CNSmlDmLinkCallback::GetResultsL(CBufBase*& aData,
+	CSmlDmAdapter::TError& aStatus )
+	{
+	if(iStatus==KNSmlDmStatusOK)
+		{
+		aStatus = CSmlDmAdapter::EOk;
+		}
+	else if(iStatus==KNSmlDmStatusNotFound)
+		{
+		aStatus = CSmlDmAdapter::ENotFound;
+		}
+	else
+		{
+		aStatus = CSmlDmAdapter::EError;
+		}
+	aData = iResults;
+	}
+
+
+// ----------------------------------------------------------------------------
+// CNSmlDmLinkCallback::GetStatusL()
+// ----------------------------------------------------------------------------
+TInt CNSmlDmLinkCallback::GetStatusL()
+	{
+	return iStatus;
+	}
+
+// ===========================================================================
+// CNSmlCallbackElement
+// ===========================================================================
+CNSmlCallbackElement::~CNSmlCallbackElement()
+	{
+	delete iUri;
+	}
+
+
+// ===========================================================================
+// CNSmlDmDDF::DeleteandAddStatusRefsL
+// ===========================================================================
+void CNSmlDmDDF::DeleteandAddStatusRefsL( TInt aStatusRef,
+		MSmlDmAdapter::TError aErrorCode )
+	{
+	TInt i=0;
+	for(i=0;i<iDeleteStatusRefs.Count();i++)
+		{
+		if(aStatusRef==iDeleteStatusRefs[i]->iRef)
+			{
+			if(aErrorCode==CSmlDmAdapter::EOk||
+					aErrorCode==CSmlDmAdapter::ENotFound)
+				{
+				//remove mapping info from db
+				iDbSession.RemoveMappingInfoL(iAdapterId,
+						*iDeleteStatusRefs[i]->iUri);
+
+				iDbSession.DeleteAclL(*iDeleteStatusRefs[i]->iUri);
+				}
+			delete iDeleteStatusRefs[i];	
+			iDeleteStatusRefs.Remove(i);
+			break;
+			}
+		}
+
+	for(i=0;i<iAddNodeStatusRefs.Count();i++)
+		{
+		if(aStatusRef==iAddNodeStatusRefs[i]->iRef)
+			{
+			if(aErrorCode==CSmlDmAdapter::EOk)
+				{
+				//check replace rights of parent
+				if(!iDbSession.CheckAclL(NSmlDmURI::ParentURI(
+						*iAddNodeStatusRefs[i]->iUri),EAclReplace))
+					{
+					iDbSession.DefaultACLsToServerL(
+							*iAddNodeStatusRefs[i]->iUri);
+					}
+				}
+			delete iAddNodeStatusRefs[i];
+			iAddNodeStatusRefs.Remove(i);
+			break;
+			}
+		}
+	}
+