1 /*

     2 * Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  DM tree etc.

    15 *

    16 */

    17 

    18 #include <utf.h>

    19 #include <smldmadapter.h>

    20 #include <nsmldebug.h>

    21 #include <nsmldmmodule.h>

    22 //For P&S keys

    23 #include <e32property.h>

    24 #include "nsmldminternalpskeys.h"

    25 #include "nsmldmddf.h"

    26 #include "nsmldmtreeconstants.h"

    27 #include "nsmldmhostclient.h"

    28 #include "nsmldmclientandserver.h"

    29 #include "nsmldmuri.h"

    30 #include <featmgr.h>

    31 // FOTA

    32 #include "nsmldmimpluids.h"

    33 // FOTA end

    34 

    35 #ifndef __WINS__

    36 // This lowers the unnecessary compiler warning (armv5) to remark.

    37 // "Warning:  #174-D: expression has no effect..." is caused by 

    38 // DBG_ARGS8 macro in no-debug builds.

    39 #pragma diag_remark 174

    40 #endif

    41 

    42 const TInt KGranularity = 4;

    43 // FOTA

    44 _LIT8 ( KNSmlDMFotaNode, "FUMO" );

    45 _LIT8 ( KNSmlDMAcc, "DMAcc");

    46 _LIT8 ( KNSmlDMRoot, "." );

    47 // FOTA end

    48 

    49 // ===========================================================================

    50 // CNSmlDmDDF

    51 // ===========================================================================

    52 

    53 // ---------------------------------------------------------------------------

    54 // CNSmlDmDDF::CNSmlDmDDF(CNSmlDmModule& aDmModule)

    55 // ----------------------------------------------------------------------------

    56 CNSmlDmDDF::CNSmlDmDDF(CNSmlDmModule& aDmModule) : iDmModule(aDmModule)

    57 	{

    58 	}

    59 

    60 // ----------------------------------------------------------------------------

    61 // CNSmlDmDDF::~CNSmlDmDDF()

    62 // ----------------------------------------------------------------------------

    63 CNSmlDmDDF::~CNSmlDmDDF()

    64 	{

    65 	delete iMgmtTree;

    66 

    67 	iSessionArray.Reset();

    68 	iSessionArray.Close();

    69 	

    70 	iResultRefs.ResetAndDestroy();

    71 	iDeleteStatusRefs.ResetAndDestroy();

    72 	iAddNodeStatusRefs.ResetAndDestroy();

    73 	if(iAddRootNodesList)

    74 		{

    75 		delete iAddRootNodesList;

    76 		}

    77 	//P&S key deletion,even fine if the key is not there

    78 	RProperty::Delete( KPSUidNSmlDMSyncAgent,KNSmlDMCmdAddNodeSuccess);

    79 	FeatureManager::UnInitializeLib();

    80 	}

    81 

    82 // ----------------------------------------------------------------------------

    83 //CNSmlDmDDF* CNSmlDmDDF::NewL(CNSmlDmDbHandler *aDbHandler)

    84 // ----------------------------------------------------------------------------

    85 CNSmlDmDDF* CNSmlDmDDF::NewL(CNSmlDmModule& aModule)

    86 	{

    87 	CNSmlDmDDF* self = new (ELeave) CNSmlDmDDF(aModule);

    88 	CleanupStack::PushL(self);

    89 	self->ConstructL();

    90 	CleanupStack::Pop();

    91 	return self;

    92 	}

    93 

    94 // ----------------------------------------------------------------------------

    95 // void CNSmlDmDDF::GenerateDDFL(CBufBase& aObject)

    96 // Generates generates xml from the ddf

    97 // ----------------------------------------------------------------------------

    98 void CNSmlDmDDF::GenerateDDFL(CBufBase& aObject)

    99 	{

   100 	_DBG_FILE("CNSmlDmDDF::GenerateDDFL() : begin");

   101 	iMgmtTree->GenerateXMLL(aObject);

   102 	_DBG_FILE("CNSmlDmDDF::GenerateDDFL() : end");

   103 	}

   104 

   105 // ----------------------------------------------------------------------------

   106 // void CNSmlDmDDF::SetServerL(const TDesC8& aURI)

   107 // Sets serverid to db

   108 // ----------------------------------------------------------------------------

   109 void CNSmlDmDDF::SetServerL(const TDesC8& aServerId)

   110 	{

   111 	_DBG_FILE("CNSmlDmDDF::SetServerL() : begin");

   112 	iDbSession.SetServerL(aServerId);

   113 	_DBG_FILE("CNSmlDmDDF::SetServerL() : end");

   114 	}

   115 

   116 // ----------------------------------------------------------------------------

   117 // TBool CNSmlDmDDF::IsDDFChangedL(/*CNSmlDmDbHandler *aDbHandler,*/

   118 // 	TDesC& aServer)

   119 // Checks if ddf has been changed. Ask the ddf version from all the adapters

   120 // and calculates checksum from adapter implementaion uids and versions

   121 // ----------------------------------------------------------------------------

   122 TInt CNSmlDmDDF::IsDDFChangedL()

   123 	{

   124 	_DBG_FILE("CNSmlDmDDF::IsDDFChangedL() : begin");

   125 	User::LeaveIfError( iDbSession.Connect() );

   126 	TInt checkSum(0);

   127 	for(TInt i=0;i<4;i++)

   128 		{

   129 		switch(i)

   130 			{

   131 			case 0:

   132 				if(iSessionArray[i].ConnectL(KNSmlDmHostServer1Name,this)

   133 					==KErrNone)

   134 					{

   135 					iOkSessions=iOkSessions|(0x01<<i);

   136 					checkSum=checkSum+iSessionArray[i].DDFStructureL(

   137 						*iMgmtTree);

   138 					iMgmtTree->SetServerId(i+1);

   139 					}

   140 				break;

   141 			case 1:

   142 				if(iSessionArray[i].ConnectL(KNSmlDmHostServer2Name,this)

   143 					==KErrNone)

   144 					{

   145 					iOkSessions=iOkSessions|(0x01<<i);

   146 					checkSum=checkSum+iSessionArray[i].DDFStructureL(

   147 						*iMgmtTree);

   148 					iMgmtTree->SetServerId(i+1);

   149 					}

   150 				break;

   151 			case 2:

   152 				if(iSessionArray[i].ConnectL(KNSmlDmHostServer3Name,this)

   153 					==KErrNone)

   154 					{

   155 					iOkSessions=iOkSessions|(0x01<<i);

   156 					checkSum=checkSum+iSessionArray[i].DDFStructureL(

   157 						*iMgmtTree);

   158 					iMgmtTree->SetServerId(i+1);

   159 					}

   160 				break;

   161 			case 3:

   162 				if(iSessionArray[i].ConnectL(KNSmlDmHostServer4Name,this)

   163 					==KErrNone)

   164 					{

   165 					iOkSessions=iOkSessions|(0x01<<i);

   166 					checkSum=checkSum+iSessionArray[i].DDFStructureL(

   167 						*iMgmtTree);

   168 					iMgmtTree->SetServerId(i+1);

   169 					}

   170 				break;

   171 			default:

   172 				User::Panic ( KNSmlTxtPanicDmModule, KErrArgument );

   173 				break;

   174 			}

   175 		}

   176 	return checkSum;

   177 	}

   178 

   179 

   180 // ----------------------------------------------------------------------------

   181 // void CNSmlDmDDF::AddObjectL(const TDesC& aURI, const TDesC8& aObject,

   182 // 	const TDesC& aType)

   183 // Adds object, if adapter is found by using th uri, calls the adapters add object function.

   184 // Adapters AddNodeObjectL is called if not leaf object

   185 // ----------------------------------------------------------------------------

   186 void CNSmlDmDDF::AddObjectL(const TDesC8& aURI,

   187 	const TDesC8& aObject,

   188 	const TDesC8& aType,

   189 	const TInt aStatusRef,

   190 	TBool aLargeItem)

   191 	{

   192 	_DBG_FILE("CNSmlDmDDF::AddObjectL() : begin");

   193 	TBool adapterCalled = EFalse;

   194 	TInt status = KNSmlDmStatusNotFound;		

   195 	if(iAdapterId==0||iSessionId==0)

   196 		{

   197 		//update not allowed in object group level (levels before adapter

   198 		//level) 

   199 		iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusCommandNotAllowed);

   200 		return;

   201 		}

   202 		

   203 	if(iDbSession.CheckDynamicAclL(aURI,EAclAdd,iMgmtTree))	 //tarm

   204 		{

   205 		//acl rigths ok

   206 		TNSmlDmDDFFormat format = IsLeafL(aURI);

   207 		TPtrC8 parentUri = NSmlDmURI::ParentURI(aURI);

   208 		if(format==ENSmlDmDDFLeaf)

   209 			{

   210 			HBufC8* luid = iDbSession.GetLuidAllocL(iAdapterId,aURI);

   211 			TInt len = luid->Length();

   212 			CleanupStack::PushL(luid);

   213 

   214 			TInt find = KErrNotFound;

   215 			if( !FeatureManager::FeatureSupported( KFeatureIdSyncMlDm112) )//means DM 1.2

   216 			 {

   217 			 if(iAddRootNodesList)

   218 			     {							

   219 			     HBufC8* puri = HBufC8::NewLC(parentUri.Length()+2);

   220 			     puri->Des().Append(parentUri);

   221 			     puri->Des().Append(',');

   222 			     find = iAddRootNodesList->Find(puri->Des());	

   223 			     CleanupStack::PopAndDestroy();

   224 			     }			

   225 			 if( find <= KErrNotFound )

   226 			     {

   227 			     TBool returnstatus = ETrue; 

   228 			     TPtrC8 Uri1 = NSmlDmURI::URISeg(aURI,1);

   229 			     if( iAddRootNodesList && Uri1.Match(KNSmlDMAcc) >= KErrNone )//dm case

   230 			     {

   231 			     TPtrC8 FindUri = NSmlDmURI::URISeg(aURI,2);

   232 			     HBufC8* puri = HBufC8::NewLC(Uri1.Length()+FindUri.Length()+2);

   233 			     puri->Des().Append(aURI.Left(Uri1.Length()+FindUri.Length()+1));

   234 			     puri->Des().Append(',');

   235 			     find = iAddRootNodesList->Find(puri->Des());   

   236 			     CleanupStack::PopAndDestroy();

   237 			     if(find >= 0)

   238 			         {

   239 			         returnstatus = EFalse; 

   240 			         }

   241 			     }

   242 			     if(returnstatus)//not added in this session

   243 			         {			    	 

   244 			         _DBG_FILE("CNSmlDmDDF::AddObjectL()node not added in this session");

   245                      if(len > 0) //Luid exists,Already existed

   246                      {

   247                      iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusAlreadyExists);	 

   248                      }

   249                      else

   250                      {

   251                      iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusNotFound);

   252                      }

   253 			         CleanupStack::PopAndDestroy(); //luid

   254 			         return;

   255 			         }

   256 			     }

   257 				}

   258 			iSessionArray[iSessionId-1].UpdateLeafL(iAdapterId,*luid,

   259 				aStatusRef,aURI,aObject,aType,aLargeItem);

   260 			adapterCalled = ETrue;		

   261 			CleanupStack::PopAndDestroy(); //luid

   262 			}

   263 		else

   264 			{

   265 			RProperty::Set(KPSUidNSmlDMSyncAgent, 

   266 						          KNSmlDMCmdAddNodeSuccess, ENotAdded);

   267 			HBufC8* luid = iDbSession.GetLuidAllocL(iAdapterId,aURI);

   268 			CleanupStack::PushL(luid);			

   269 			CNSmlCallbackElement *newElement 

   270 				= new (ELeave)CNSmlCallbackElement();

   271 			CleanupStack::PushL(newElement);

   272 			newElement->iRef = aStatusRef;

   273 			newElement->iUri = aURI.AllocL();

   274 			iAddNodeStatusRefs.AppendL(newElement);

   275 			CleanupStack::Pop(); //newElement

   276 			iSessionArray[iSessionId-1].AddNodeL(iAdapterId,*luid,aStatusRef,

   277 				aURI);

   278 			//means DM 1.2

   279 			if( !FeatureManager::FeatureSupported( KFeatureIdSyncMlDm112) )

   280 			  {

   281 			  //Check the status of add node, so that update the add buffer

   282 			  TInt NodeAddingSuccess = KErrNotFound;

   283 			  TInt NodeorLeafexists= KErrNotFound;

   284 			  TInt err = RProperty::Get(KPSUidNSmlDMSyncAgent, 

   285 					  KNSmlDMCmdAddNodeSuccess, NodeAddingSuccess);

   286 			  //This key will be set by DM Host Session's setstatus

   287 			  TInt err1 = RProperty::Get( KPSUidNSmlDMSyncAgent, 

   288 					  KNSmlDMCmdAddOnExistingNodeorLeafKey,

   289 					  NodeorLeafexists );				  

   290 			  if( ( err1 == KErrNone && NodeorLeafexists == EAddCmd ) && 

   291 			          (err == KErrNone && (NodeAddingSuccess == EAdded ||

   292 			                  NodeAddingSuccess == ENotAdded) ) )

   293 			      {

   294 			      if(iAddRootNodesList) //already created

   295 			          {																						

   296 			          //Do check if there is any node already added					

   297 			          if( iAddRootNodesList->Match(aURI) <= KErrNotFound ) 

   298 			              {

   299 			              iAddRootNodesList = iAddRootNodesList->ReAllocL

   300 			              (iAddRootNodesList->Length() + aURI.Length()+ 10);

   301 			              iAddRootNodesList->Des().Append(aURI);

   302 			              }					

   303 			          }

   304 			      else //getting created

   305 			          {					

   306 			          iAddRootNodesList = HBufC8::NewL(aURI.Length()+ 10);					

   307 			          iAddRootNodesList->Des().Append(aURI);

   308 			          }			      

   309 			      iAddRootNodesList->Des().Append(',');				

   310 			      }			  			  

   311 			  }

   312 			adapterCalled = ETrue;

   313 		

   314 			CleanupStack::PopAndDestroy(); //luid

   315 			}

   316 		} //end if(iDbSession.CheckAclL())

   317 	else

   318 		{

   319 		//no acl rights

   320 		status = KNSmlDmStatusPermissionDenied;

   321 		}

   322 

   323 	if(!adapterCalled)

   324 		{

   325 		iDmModule.DoSetStatusL(aStatusRef,status);

   326 		}

   327 	_DBG_FILE("CNSmlDmDDF::AddObjectL() : begin");

   328 	}

   329 

   330 // ----------------------------------------------------------------------------

   331 // void CNSmlDmDDF::UpdateObjectL(const TDesC& aURI, const TDesC8& aObject,

   332 //	const TDesC& aType)

   333 // Calls the adapters UpdateObjectL function if the adapter is recognised by

   334 // using URI 

   335 // ----------------------------------------------------------------------------

   336 void CNSmlDmDDF::UpdateObjectL(const TDesC8& aURI,

   337 	const TDesC8& aObject,

   338 	const TDesC8& aType,

   339 	const TInt aStatusRef,

   340 	TBool aLargeItem,

   341 	// FOTA

   342 	TInt aTotSizeOfLarge

   343 	// FOTA end

   344 	)

   345 	{

   346 	_DBG_FILE("CNSmlDmDDF::UpdateObjectL() : begin");

   347 

   348 	TBool adapterCalled = EFalse;

   349 	TInt status = KNSmlDmStatusNotFound;

   350 	

   351 	

   352 	if(iAdapterId==0||iSessionId==0)

   353 		{

   354 		//update not allowed in object group level

   355 		//(levels before adapter level) 

   356 		iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusCommandNotAllowed);

   357 		return;

   358 		}

   359 		

   360 	if(iDbSession.CheckDynamicAclL(aURI,EAclReplace,iMgmtTree)) //tarm

   361 		{

   362 		//acl rigths ok

   363 		TNSmlDmDDFFormat format = IsLeafL(aURI);

   364 		

   365 		if(format==ENSmlDmDDFLeaf)

   366 			{

   367 			HBufC8* luid = iDbSession.GetLuidAllocL(iAdapterId,aURI);

   368 			CleanupStack::PushL(luid);

   369 

   370 			// FOTA

   371 			iSessionArray[iSessionId-1].UpdateLeafL(iAdapterId,*luid,

   372 				aStatusRef,aURI,aObject,aType,aLargeItem,aTotSizeOfLarge);

   373 			// FOTA end

   374 			adapterCalled = ETrue;

   375 		

   376 			CleanupStack::PopAndDestroy(); //luid

   377 			}

   378 		else

   379 			{

   380 			status=KNSmlDmStatusCommandNotAllowed;

   381 			}

   382 			

   383 			

   384 		} //end if(iDbSession.CheckAclL())

   385 	else

   386 		{

   387 		//no acl rights

   388 		status = KNSmlDmStatusPermissionDenied;

   389 		}

   390 

   391 	if(!adapterCalled)

   392 		{

   393 		iDmModule.DoSetStatusL(aStatusRef,status);

   394 		}

   395 

   396 	_DBG_FILE("CNSmlDmDDF::UpdateObjectL() : end");

   397 	}

   398 

   399 // ----------------------------------------------------------------------------

   400 // void CNSmlDmDDF::FetchObjectL(const TDesC& aURI, const TDesC& aType,

   401 //	CBufBase& aObject )

   402 // Calls the adapters FetchObjectL function via IPC if the adapter and 

   403 // correct host server are recognised by using URI.

   404 // Adapters ChildURIListL is called, if not leaf object

   405 // ----------------------------------------------------------------------------

   406 void CNSmlDmDDF::FetchObjectL(const TDesC8& aURI,

   407 	const TDesC8& aType,

   408 	const TInt aResultsRef,

   409 	const TInt aStatusRef,

   410 	TBool aAclPass )

   411 	{

   412 	_DBG_FILE("CNSmlDmDDF::FetchObjectL() : begin");

   413 	TBool adapterCalled = EFalse;

   414 	TInt status = KNSmlDmStatusNotFound;

   415 

   416 	if(aAclPass||iDbSession.CheckDynamicAclL(aURI,EAclGet,iMgmtTree)) //tarm

   417 		{

   418 		//acl rights ok or internal query when aclchecking is passed

   419 		HBufC8* luid = NULL;

   420 

   421 		if(iAdapterId==0||iSessionId==0)

   422 			{

   423 			//this will response to gets before adapter level

   424 			TInt status = KNSmlDmStatusOK;

   425 			CBufBase* object = CBufFlat::NewL(128);

   426 			CleanupStack::PushL(object);

   427 			CNSmlDmNodeList* final = NULL;

   428 			if(aURI.Length()==0||aURI.Compare(KNSmlDmRootUri)==0)

   429 				{

   430 				//fetch for the root level

   431 				CNSmlDmNodeList* nodeListPtr = iMgmtTree->iNodeListPtr;

   432 				//loop through the fisrt level after root

   433 				while(nodeListPtr!=0)

   434 					{

   435 					object->InsertL(object->Size(),

   436 						nodeListPtr->iNode->iNodeName.iContent,

   437 						nodeListPtr->iNode->iNodeName.iLength);

   438 						

   439 					if(nodeListPtr->iNext!=0)

   440 						{

   441 						object->InsertL(object->Size(),KNSmlDmLitSeparator8);

   442 						}

   443 					nodeListPtr = nodeListPtr->iNext;

   444 					}

   445 				}

   446 			else

   447 				{

   448 				iMgmtTree->FindNameFromNodeListL(aURI,final);

   449 

   450 				if(!final)

   451 					{

   452 					//the node was not found from ddf

   453 					status = KNSmlDmStatusNotFound;

   454 					}

   455 				else

   456 					{

   457 					if(final->iNode)

   458 						{

   459 						CNSmlDmNodeList* nodeListPtr =

   460 							final->iNode->iNodeListPtr;

   461 					

   462 						//loop the childs of "final" node

   463 						while(nodeListPtr)

   464 							{

   465 							object->InsertL(object->Size(),

   466 								nodeListPtr->iNode->iNodeName.iContent,

   467 								nodeListPtr->iNode->iNodeName.iLength);

   468 								

   469 							if(nodeListPtr->iNext)

   470 								{

   471 								object->InsertL(object->Size(),

   472 									KNSmlDmLitSeparator8);

   473 								}

   474 							nodeListPtr = nodeListPtr->iNext;

   475 							}

   476 						}

   477 					else

   478 						{

   479 						object->InsertL(0,KNullDesC8);

   480 						}

   481 					}

   482 				}

   483 			iDmModule.DoSetStatusL(aStatusRef,status);

   484 			if(status == KNSmlDmStatusOK)

   485 				{

   486 				CNSmlCallbackElement *newElement =

   487 					new (ELeave)CNSmlCallbackElement();

   488 					

   489 				CleanupStack::PushL(newElement);

   490 				newElement->iRef = aResultsRef;

   491 				newElement->iUri = aURI.AllocL();

   492 				newElement->iNode = ETrue;

   493 				iResultRefs.AppendL(newElement);

   494 				CleanupStack::Pop(); //newElement

   495 				SetResultsL(aResultsRef,*object,aType,object->Size());

   496 				}

   497 			CleanupStack::PopAndDestroy(); //object

   498 			return;

   499 			} //end if(iAdapterId==0||iSessionId==0)

   500 

   501 		luid = iDbSession.GetLuidAllocL(iAdapterId,aURI);

   502 		CleanupStack::PushL(luid);

   503 

   504 		CNSmlCallbackElement *newElement = new (ELeave)CNSmlCallbackElement();

   505 		CleanupStack::PushL(newElement);

   506 		newElement->iRef = aResultsRef;

   507 		newElement->iUri = 0;

   508 

   509 		//mapping info found for the uri

   510 		TNSmlDmDDFFormat format = IsLeafL(aURI);

   511 		if(format==ENSmlDmDDFLeaf)

   512 			{

   513 			newElement->iUri = aURI.AllocL();

   514 			newElement->iNode = EFalse;

   515 			iResultRefs.AppendL(newElement);

   516 			CleanupStack::Pop(); //newElement

   517 			

   518 			iSessionArray[iSessionId-1].FetchLeafObjectL(iAdapterId,

   519 				aURI,*luid,aType,aResultsRef,aStatusRef);

   520 

   521 			adapterCalled = ETrue;

   522 			}

   523 		else if(format==ENSmlDmDDFNode)

   524 			{

   525 			//interior node, ask the childurilist from the adapter

   526 			CArrayFixFlat<TSmlDmMappingInfo> *previousList

   527 				=new (ELeave) CArrayFixFlat <TSmlDmMappingInfo> (KGranularity);

   528 				

   529 			CleanupStack::PushL(previousList);

   530 			iDbSession.GetUriSegListL(iAdapterId,aURI,*previousList);

   531 			newElement->iUri = aURI.AllocL();

   532 			newElement->iNode = ETrue;

   533 			iResultRefs.AppendL(newElement);

   534 			CleanupStack::Pop(2); //previousList,newElement

   535 			CleanupStack::PushL(previousList);

   536 			iSessionArray[iSessionId-1].ChildURIListL(iAdapterId,aURI,*luid,

   537 				*previousList,aResultsRef,aStatusRef);

   538 				

   539 			adapterCalled = ETrue;

   540 			CleanupStack::PopAndDestroy(); //previousList

   541 			} //end else IsLeaf

   542 		CleanupStack::PopAndDestroy(); //luid

   543 		} //end if(iDbSession.CheckAclL())

   544 	else

   545 		{

   546 		status = KNSmlDmStatusPermissionDenied;

   547 		}

   548 

   549 	if(!adapterCalled)

   550 		{

   551 		iDmModule.DoSetStatusL(aStatusRef,status);

   552 		}

   553 

   554 	_DBG_FILE("CNSmlDmDDF::FetchObjectL() : end");

   555 	}

   556 

   557 

   558 // ----------------------------------------------------------------------------

   559 // void CNSmlDmDDF::FetchObjectSizeL(const TDesC8& aURI,

   560 //	const TDesC8& aType,

   561 //	const TInt aResultsRef,

   562 //	const TInt aStatusRef)

   563 // Calls the adapters FetchObjectSizeL function via IPC if the adapter and 

   564 // correct host server are recognised by using URI.

   565 // ----------------------------------------------------------------------------

   566 void CNSmlDmDDF::FetchObjectSizeL(const TDesC8& aURI,

   567 	const TDesC8& aType,

   568 	const TInt aResultsRef,

   569 	const TInt aStatusRef)

   570 	{

   571 	_DBG_FILE("CNSmlDmDDF::FetchObjectSizeL() : begin");

   572 

   573 	if(iAdapterId&&iSessionId)

   574 		{

   575 		HBufC8* luid = iDbSession.GetLuidAllocL(iAdapterId,aURI);

   576 		CleanupStack::PushL(luid);

   577 

   578 		CNSmlCallbackElement *newElement = new (ELeave)CNSmlCallbackElement();

   579 		CleanupStack::PushL(newElement);

   580 		newElement->iRef = aResultsRef;

   581 		newElement->iUri = aURI.AllocL();

   582 		newElement->iNode = EFalse;

   583 		iResultRefs.AppendL(newElement);

   584 		CleanupStack::Pop(); //newElement

   585 		iSessionArray[iSessionId-1].FetchLeafObjectSizeL(iAdapterId,aURI,*luid,aType,aResultsRef,aStatusRef);

   586 		CleanupStack::PopAndDestroy(); //luid

   587 		}

   588 	else

   589 		{

   590 		iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusNotFound);

   591 		}

   592 

   593 

   594 	_DBG_FILE("CNSmlDmDDF::FetchObjectSizeL() : end");

   595 	}

   596 

   597 

   598 // ----------------------------------------------------------------------------

   599 // void CNSmlDmDDF::ExecuteObjectL(const TDesC& aURI, const TDesC8& aObject,

   600 // const TDesC& aType)

   601 // Calls the adapters ExecuteObjectL function if the adapter is recognised

   602 // by using URI 

   603 // ----------------------------------------------------------------------------

   604 void CNSmlDmDDF::ExecuteObjectL(const TDesC8& aURI,

   605 	const TDesC8& aObject,

   606 	const TDesC8& aType,

   607 	const TInt aStatusRef,

   608 	// FOTA

   609 	const TDesC8& aCorrelator,

   610 	// FOTA end	

   611 	TBool aLargeItem)

   612 	{

   613 	_DBG_FILE("CNSmlDmDDF::ExecuteObjectL() : begin");

   614 

   615 	TBool adapterCalled = EFalse;

   616 	TInt status = KNSmlDmStatusNotFound;

   617 	

   618 	if(iAdapterId==0||iSessionId==0)

   619 		{

   620 		//update not allowed in object group level

   621 		//(levels before adapter level) 

   622 		iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusCommandNotAllowed);

   623 		return;

   624 		}

   625 		

   626 	if(iDbSession.CheckDynamicAclL(aURI,EAclExecute,iMgmtTree)) //tarm

   627 		{

   628 		//acl rigths ok

   629 		HBufC8* luid = iDbSession.GetLuidAllocL(iAdapterId,aURI);

   630 		CleanupStack::PushL(luid);

   631 		// FOTA 

   632 		// For the FOTA adapter put the correlator to aObject instead of

   633 		// data.

   634 		if ( iAdapterId == KNSmlDMFotaAdapterImplUid || iAdapterId == KNSmlDMAMAdapterImplUid)

   635 			{

   636 			iSessionArray[iSessionId-1].ExecuteCommandL(iAdapterId,*luid,

   637 				aStatusRef,aURI,aCorrelator,aType,aLargeItem);

   638 			}

   639 		else

   640 			{

   641 			iSessionArray[iSessionId-1].ExecuteCommandL(iAdapterId,*luid,

   642 				aStatusRef,aURI,aObject,aType,aLargeItem);		

   643 			}

   644 		// FOTA end			

   645 		adapterCalled = ETrue;

   646 		

   647 		CleanupStack::PopAndDestroy(); //luid

   648 		} //end if(iDbSession.CheckAclL())

   649 	else

   650 		{

   651 		//no acl rights

   652 		status = KNSmlDmStatusPermissionDenied;

   653 		}

   654 

   655 	if(!adapterCalled)

   656 		{

   657 		iDmModule.DoSetStatusL(aStatusRef,status);

   658 		}

   659 

   660 	_DBG_FILE("CNSmlDmDDF::ExecuteObjectL() : end");

   661 

   662 	}

   663 

   664 // ----------------------------------------------------------------------------

   665 // void CNSmlDmDDF::CopyObjectL(const TDesC& aURI, const TDesC8& aObject,

   666 //	const TDesC& aType)

   667 // Calls the adapters CopyObjectL function if the adapter is recognised

   668 // by using URI 

   669 // ----------------------------------------------------------------------------

   670 void CNSmlDmDDF::CopyObjectL(const TDesC8& aTargetURI,

   671 	const TDesC8& aSourceURI,

   672 	const TDesC8& aType,

   673 	const TInt aStatusRef)

   674 	{

   675 	_DBG_FILE("CNSmlDmDDF::CopyObjectL() : begin");

   676 

   677 	TBool adapterCalled = EFalse;

   678 	TInt status = KNSmlDmStatusNotFound;

   679 	

   680 	

   681 //	if(format==ENode)

   682 	if(iAdapterId==0||iSessionId==0)

   683 		{

   684 		//update not allowed in object group level

   685 		//(levels before adapter level) 

   686 		iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusCommandNotAllowed);

   687 		return;

   688 		}

   689 		

   690 	if(iDbSession.CheckDynamicAclL(aSourceURI,EAclGet,iMgmtTree)&& //tarm

   691 		iDbSession.CheckDynamicAclL(aTargetURI,EAclAdd,iMgmtTree))

   692 		{

   693 		//acl rigths ok

   694 		HBufC8* targetLuid = iDbSession.GetLuidAllocL(iAdapterId,aTargetURI);

   695 		CleanupStack::PushL(targetLuid);

   696 		HBufC8* sourceLuid = iDbSession.GetLuidAllocL(iAdapterId,aSourceURI);

   697 		CleanupStack::PushL(sourceLuid);

   698 

   699 		iSessionArray[iSessionId-1].CopyCommandL(iAdapterId,

   700 			*targetLuid,aTargetURI,*sourceLuid,aSourceURI,aStatusRef,aType);

   701 

   702 		adapterCalled = ETrue;

   703 		

   704 		CleanupStack::PopAndDestroy(2); //targetLuid,sourceLuid

   705 		} //end if(iDbSession.CheckAclL())

   706 	else

   707 		{

   708 		//no acl rights

   709 		status = KNSmlDmStatusPermissionDenied;

   710 		}

   711 

   712 	if(!adapterCalled)

   713 		{

   714 		iDmModule.DoSetStatusL(aStatusRef,status);

   715 		}

   716 

   717 	_DBG_FILE("CNSmlDmDDF::CopyObjectL() : end");

   718 	}

   719 

   720 

   721 

   722 

   723 // ----------------------------------------------------------------------------

   724 // void CNSmlDmDDF::DeleteObjectL(const TDesC& aURI)

   725 // Calls the adapters DeleteObjectL function if the adapter is

   726 // recognised by using URI.

   727 // ----------------------------------------------------------------------------

   728 void CNSmlDmDDF::DeleteObjectL(const TDesC8& aURI,const TInt aStatusRef)

   729 	{

   730 	_DBG_FILE("CNSmlDmDDF::DeleteObjectL(): begin");

   731 	TInt status = KNSmlDmStatusNotFound;

   732 	TBool adapterCalled = EFalse;

   733 

   734 	if(iAdapterId==0||iSessionId==0)

   735 		{

   736 		//delete not allowed in object group level

   737 		//(levels before adapter level) 

   738 		iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusCommandNotAllowed);

   739 		return;

   740 		}

   741 

   742 	if(iDbSession.CheckDynamicAclL(aURI,EAclDelete,iMgmtTree)) //tarm

   743 		{

   744 		//acl rights ok

   745 		HBufC8* luid = iDbSession.GetLuidAllocL(iAdapterId,aURI);

   746 		CleanupStack::PushL(luid);

   747 

   748 		if(luid->Length())

   749 			{

   750 			CNSmlCallbackElement *newElement 

   751 				= new (ELeave)CNSmlCallbackElement();

   752 			CleanupStack::PushL(newElement);

   753 			newElement->iRef = aStatusRef;

   754 			newElement->iUri = aURI.AllocL();

   755 			iDeleteStatusRefs.AppendL(newElement);

   756 			CleanupStack::Pop(); //newElement

   757 			

   758 			iSessionArray[iSessionId-1].DeleteObjectL(iAdapterId,*luid,

   759 				aStatusRef,aURI);

   760 				

   761 			adapterCalled = ETrue;

   762 			}

   763 		else

   764 			{

   765 			iSessionArray[iSessionId-1].DeleteObjectL(iAdapterId,*luid,

   766 				aStatusRef,aURI);

   767 				

   768 			adapterCalled = ETrue;

   769 			}	

   770 		CleanupStack::PopAndDestroy(); //luid

   771 		} //end if(iDbSession.CheckAclL())

   772 	else

   773 		{

   774 		status = KNSmlDmStatusPermissionDenied;

   775 		}

   776 

   777 	if(!adapterCalled)

   778 		{

   779 		iDmModule.DoSetStatusL(aStatusRef,status);

   780 		}

   781 

   782 	_DBG_FILE("CNSmlDmDDF::DeleteObjectL() : end");

   783 	}

   784 

   785 

   786 // ----------------------------------------------------------------------------

   787 // CNSmlDmDDF::CheckURIL(const TDesC& aURI)

   788 // Compares URI to ddf and check that URI is valid

   789 // ----------------------------------------------------------------------------

   790 CNSmlDmDDF::TAccess CNSmlDmDDF::CheckURIL(const TDesC8& aURI,

   791 	TNSmlDmCmdType aCmd)

   792 	{

   793 	_DBG_FILE("CNSmlDmDDF::CheckURIL() : begin");

   794 	TAccess ret(ENotExist);

   795 	TUint8 access(0);

   796 	TUriCheck found = CheckAdapterL(aURI,access);

   797 	if(found!=EUriNotFound)

   798 		{

   799 		//uri OK, now check the access which is set in ddf

   800 		ret = ENotAccess;

   801 		switch(aCmd)

   802 			{

   803 			case EAclAdd:

   804 			if(access&TSmlDmAccessTypes::EAccessType_Add)

   805 				{

   806 				ret = EOk;

   807 				}

   808 			break;

   809 		

   810 			case EAclReplace:

   811 			if(access&TSmlDmAccessTypes::EAccessType_Replace)

   812 				{

   813 				ret = EOk;

   814 				}

   815 			break;

   816 		

   817 			case EAclGet:

   818 			if(access&TSmlDmAccessTypes::EAccessType_Get)

   819 				{

   820 				ret = EOk;

   821 				}

   822 			break;

   823 	

   824 			case EAclDelete:

   825 			if(access&TSmlDmAccessTypes::EAccessType_Delete)

   826 				{

   827 				ret = EOk;

   828 				}

   829 			break;

   830 

   831 			case EAclExecute:

   832 			if(access&TSmlDmAccessTypes::EAccessType_Exec)

   833 				{

   834 				ret = EOk;

   835 				}

   836 			break;

   837 

   838 			case EAclCopy:

   839 			if(access&TSmlDmAccessTypes::EAccessType_Copy)

   840 				{

   841 				ret = EOk;

   842 				}

   843 			break;

   844 			default:

   845 			User::Panic ( KNSmlTxtPanicDmModule, KErrArgument );

   846 			break;

   847 			}

   848 		}

   849 

   850 	_DBG_FILE("CNSmlDmDDF::CheckURIL() : end");

   851 	return ret;

   852 	}

   853 

   854 

   855 

   856 

   857 // ----------------------------------------------------------------------------

   858 // void CNSmlDmDDF::ConstructL()

   859 // Second phase constructor

   860 // ----------------------------------------------------------------------------

   861 void CNSmlDmDDF::ConstructL()

   862 	{

   863 	_DBG_FILE("CNSmlDmDDF::ConstructL() : begin");

   864 	iMgmtTree = CNSmlDmMgmtTree::NewL();

   865 	iResultSessionId=KErrNotFound;

   866 	for(TInt i=0;i<4;i++)

   867 		{

   868 		RNSmlDMDataSession session;

   869 		iSessionArray.AppendL(session);

   870 		}

   871     FeatureManager::InitializeLibL(); 		

   872     RProperty::Define(KPSUidNSmlDMSyncAgent,

   873     		KNSmlDMCmdAddNodeSuccess, RProperty::EInt,

   874 			KReadPolicy, KWritePolicy );

   875 	_DBG_FILE("CNSmlDmDDF::ConstructL() : end");

   876 	}

   877 

   878 

   879 // ----------------------------------------------------------------------------

   880 // CNSmlDmDDF::CheckAclL( const TDesC& aURI,

   881 // CNSmlDmDbHandler::TCmdType aCmdType)

   882 // Does the ACL checking

   883 // ----------------------------------------------------------------------------

   884 TBool CNSmlDmDDF::CheckAclL( const TDesC8& aURI, TNSmlDmCmdType aCmdType)

   885 	{

   886 	TUint8 access(0);

   887 	if(aURI.Length()==0||aURI.Compare(KNSmlDmRootUri)==0

   888 		||CheckAdapterL(aURI,access)!=EUriNotFound)

   889 		{

   890 		return iDbSession.CheckDynamicAclL(aURI,aCmdType,iMgmtTree); //tarm

   891 		}

   892 	return EFalse;

   893 	}

   894 

   895 

   896 // ----------------------------------------------------------------------------

   897 // CNSmlDmDDF::UpdateAclL( const TDesC& aURI,const TDesC8 &aACL)

   898 // Updates ACL to tree db

   899 // ----------------------------------------------------------------------------

   900 void CNSmlDmDDF::UpdateAclL( const TDesC8& aURI,

   901 	const TDesC8 &aACL, const TInt aStatusRef)

   902 	{

   903 	if(aURI.Length()==0||aURI.Compare(KNSmlDmRootUri)==0)

   904 	    {

   905 		iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusForbidden);

   906 	    }

   907 	else

   908 	    {

   909     	TNSmlDmDDFFormat format = IsLeafL(aURI);

   910     	TBool access(0);

   911     	TPtrC8 parentUri = NSmlDmURI::ParentURI(aURI);

   912     	if(format==ENSmlDmDDFLeaf)

   913     		{

   914     		access = CheckAclL(parentUri,EAclReplace);

   915     		}

   916     	else

   917     		{

   918     		access = CheckAclL(parentUri,EAclReplace)

   919     			||CheckAclL(aURI,EAclReplace);

   920     		}

   921 

   922     	if(access)

   923     		{

   924     		TInt ret = iDbSession.UpdateAclL(aURI,aACL);

   925     		if( ret == KErrNone)

   926     			{

   927     			iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusOK);

   928     			}

   929     		else if( ret == KErrAccessDenied)

   930     			{

   931     			iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusForbidden);

   932     			}

   933     		else

   934     			{

   935     			iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusCommandFailed);

   936     			}

   937     		}

   938     	else

   939     		{

   940     		iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusPermissionDenied);

   941     		}

   942 	    }

   943 	}

   944 

   945 // ----------------------------------------------------------------------------

   946 // CNSmlDmDDF::GetAclL( const TDesC& aURI, CBufBase &aACL)

   947 // ----------------------------------------------------------------------------

   948 TInt CNSmlDmDDF::GetAclL( const TDesC8& aURI, CBufBase &aACL)

   949 	{

   950 	TInt ret = KNSmlDmStatusPermissionDenied;

   951 	if(CheckAclL(aURI,EAclGet))

   952 		{

   953 		iDbSession.GetAclL(aURI,aACL,EFalse);

   954 		ret = KNSmlDmStatusOK;

   955 		}

   956 	return ret;

   957 	}

   958 

   959 

   960 // ----------------------------------------------------------------------------

   961 // CNSmlDmDDF::GetLuidAllocL(const TDesC& aURI)

   962 // gets and allocates the mapped luid from tree db

   963 // ----------------------------------------------------------------------------

   964 HBufC8* CNSmlDmDDF::GetLuidAllocL(const TDesC8& aURI)

   965 	{

   966 	HBufC8* luid=0;

   967 	if(CheckURIL(aURI,EAclGet)!=CNSmlDmDDF::ENotExist)

   968 		{

   969 		if(iAdapterId)

   970 			{

   971 			luid = iDbSession.GetLuidAllocL(iAdapterId,aURI);

   972 			}

   973 		}

   974 	if(!luid)

   975 		{

   976 		luid = KNullDesC8().AllocL();

   977 		}

   978 	return luid;

   979 	}

   980 

   981 

   982 // ----------------------------------------------------------------------------

   983 // CNSmlDmDDF::StartAtomicL()

   984 // Start atomic indication

   985 // ----------------------------------------------------------------------------

   986 void CNSmlDmDDF::StartAtomicL()

   987 	{

   988 	for(TInt i=0;i<4;i++)

   989 		{

   990 		if(iOkSessions&(0x01<<i))

   991 			{

   992 			iSessionArray[i].StartAtomicL();

   993 			}

   994 		}

   995 	iDbSession.StartAtomic();

   996 	}

   997 	

   998 // ----------------------------------------------------------------------------

   999 // CNSmlDmDDF::CommitAtomicL()

  1000 // Commit atomic indication

  1001 // ----------------------------------------------------------------------------

  1002 void CNSmlDmDDF::CommitAtomicL()

  1003 	{

  1004 	for(TInt i=0;i<4;i++)

  1005 		{

  1006 		if(iOkSessions&(0x01<<i))

  1007 			{

  1008 			iSessionArray[i].CommitAtomicL();

  1009 			}

  1010 		}

  1011 	iDbSession.CommitAtomic();

  1012 	}

  1013 	

  1014 // ----------------------------------------------------------------------------

  1015 // CNSmlDmDDF::RollbackAtomicL()

  1016 // Rollback atomic indication

  1017 // ----------------------------------------------------------------------------

  1018 void CNSmlDmDDF::RollbackAtomicL()

  1019 	{

  1020 	for(TInt i=0;i<4;i++)

  1021 		{

  1022 		if(iOkSessions&(0x01<<i))

  1023 			{

  1024 			iSessionArray[i].RollbackAtomicL();

  1025 			}

  1026 		}

  1027 	iDbSession.RollbackAtomic();

  1028 	}

  1029 

  1030 // ----------------------------------------------------------------------------

  1031 // CNSmlDmDDF::DisconnectFromOtherServers()

  1032 //	Closes the connections to callback server and host servers.

  1033 //	Separate function is needed, since the disconnecting cannot 

  1034 //	be made after the active scheduler of the thread is stopped.

  1035 // ----------------------------------------------------------------------------

  1036 //

  1037 void CNSmlDmDDF::DisconnectFromOtherServers()

  1038 	{

  1039 	iDbSession.Close();

  1040 	for ( TInt i(0); i<iSessionArray.Count(); i++ )

  1041 		{

  1042 		if(iOkSessions&(0x01<<i))

  1043 			{

  1044 			iSessionArray[i].Close();

  1045 			}

  1046 		}

  1047 	}

  1048 // FOTA

  1049 // ----------------------------------------------------------------------------

  1050 // CNSmlDmDDF::MarkGenAlertsSentL()

  1051 //	When the generic alerts are successfully sent to the remote 

  1052 //	server, the FOTA adapter needs to be informed about this.

  1053 //	This command is chained through the DM engine.

  1054 // ----------------------------------------------------------------------------

  1055 //

  1056 void CNSmlDmDDF::MarkGenAlertsSentL()

  1057 	{

  1058 	CNSmlDmNodeList* final = NULL;

  1059 	iMgmtTree->FindNameFromNodeListL ( KNSmlDMFotaNode, final );

  1060 	if ( final )

  1061 		{

  1062 		TUint32 adapterId(0);

  1063 		TUint8 sessionId(0);

  1064 		final->GetImplUid ( adapterId, sessionId );

  1065 		iSessionArray[sessionId-1].MarkGenAlertsSent();

  1066 		}

  1067 	}

  1068 // FOTA end

  1069 

  1070 

  1071 // ----------------------------------------------------------------------------

  1072 // CNSmlDmDDF::MarkGenAlertsSentL(const TDesC8& aURI)

  1073 //	When the generic alerts are successfully sent to the remote 

  1074 //	server, the FOTA adapter needs to be informed about this.

  1075 //	This command is chained through the DM engine.

  1076 //  For 1.2 Any adapter can send the Generic adapter,

  1077 //  Hence URI of adapter is passed 

  1078 // ----------------------------------------------------------------------------

  1079 //   

  1080  

  1081 void CNSmlDmDDF::MarkGenAlertsSentL(const TDesC8& aURI)

  1082 

  1083     {

  1084     _DBG_FILE("CNSmlDmDDF::MarkGenAlertsSentL (TDesC8& aURI) : begin");

  1085     CNSmlDmNodeList* final = NULL;

  1086     //Get the first root node from the aURI

  1087      HBufC8* nodeURI = HBufC8::NewLC(aURI.Length());

  1088     TInt i= 0;

  1089     TBool dotPresentInURI = EFalse;

  1090     for( i=0; i < aURI.Length(); i++ )

  1091         {

  1092         if((aURI[i] == '.') && (i==0))

  1093         {

  1094         	dotPresentInURI = ETrue;

  1095         	continue;

  1096         }

  1097         

  1098         if((aURI[i] == '/') && (i==1))

  1099         continue;

  1100         if(aURI[i]=='/')

  1101             {

  1102             break;

  1103             }

  1104         }

  1105 

  1106     if(i>0)

  1107         {

  1108         if(dotPresentInURI)

  1109         {

  1110         	 nodeURI->Des().Format(aURI.Mid(2,i-2)); // removing ./

  1111         }

  1112         else

  1113         {

  1114         	 nodeURI->Des().Format(aURI.Left(i));

  1115         }

  1116         }

  1117        iMgmtTree->FindNameFromNodeListL (nodeURI->Des(),final);

  1118        

  1119        if(final)

  1120         {

  1121         _DBG_FILE("CNSmlDmDDF::MarkGenAlertsSentL (TDesC8& aURI) Adapter found  ");  

  1122          

  1123         TUint32 adapterId(0);

  1124 		TUint8 sessionId(0);

  1125 		final->GetImplUid ( adapterId, sessionId );

  1126 		if(sessionId == 0)

  1127 		{

  1128 		  sessionId = 1;

  1129 		}

  1130 		 

  1131 	    iSessionArray[sessionId-1].MarkGenAlertsSent(nodeURI->Des());

  1132         }

  1133        else

  1134         {