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 

    19 #include <s32mem.h>

    20 #include <smldmadapter.h>

    21 #include <data_caging_path_literals.hrh>

    22 

    23 #include <nsmlconstants.h>

    24 #include "nsmldmhostclient.h"

    25 #include "nsmldmcmdarghandler.h"

    26 #include "nsmldmtreedtd.h"

    27 #include "nsmldmddf.h"

    28 // FOTA

    29 #include "nsmldmimpluids.h"

    30 // FOTA end

    31 

    32 const TInt KNSmlMinChunk = 4096;

    33 

    34 //********************************

    35 //RNSmlDMDataSession

    36 //********************************

    37 

    38 // ------------------------------------------------------------------------------------------------

    39 //void RNSmlDMDataSession::RNSmlDMDataSession()

    40 // ------------------------------------------------------------------------------------------------

    41 RNSmlDMDataSession::RNSmlDMDataSession() :

    42     iCallback( NULL ),

    43 	iMapUris( NULL ),

    44 	iMapLuids( NULL ),

    45 	iServerId( 0 ),

    46 	iLargeObjectUri( NULL )

    47 	{

    48 	}

    49 

    50 // ------------------------------------------------------------------------------------------------

    51 //void RNSmlDMDataSession::~RNSmlDMDataSession()

    52 // ------------------------------------------------------------------------------------------------

    53 RNSmlDMDataSession::~RNSmlDMDataSession()

    54 	{

    55 	if(iMapUris!=0)

    56 		{

    57 		iMapUris->ResetAndDestroy();

    58 		delete iMapUris;

    59 		}

    60 	if(iMapLuids!=0)

    61 		{

    62 		iMapLuids->ResetAndDestroy();

    63 		delete iMapLuids;

    64 		}

    65 	delete iLargeObjectUri;

    66 	}

    67 

    68 // ------------------------------------------------------------------------------------------------

    69 //void RNSmlDMDataSession::Connect()

    70 // Connect to the  server - default number of message slots is four

    71 // ------------------------------------------------------------------------------------------------

    72 TInt RNSmlDMDataSession::ConnectL(const TDesC& aServerName,

    73 	CNSmlDmDDF* aCallback)

    74 	{

    75 	iCallback = aCallback;

    76 	

    77 	TInt result( KErrNone );

    78 	TVersion ver ( KNSmlDmHostServerVerMajor, KNSmlDmHostServerVerMinor,

    79 		KNSmlDmHostServerVerBuild );

    80 

    81 	result = CreateSession( aServerName, ver );

    82 	if(result!=KErrNone)

    83 		{

    84 		if(aServerName.Compare(KNSmlDmHostServer1Name)==0)

    85 			{

    86 			result = LaunchServerL( KNSmlDmHostServer1Exe );

    87 			iServerId = 1;

    88 			}

    89 		else if(aServerName.Compare(KNSmlDmHostServer2Name)==0)

    90 			{

    91 			result = LaunchServerL( KNSmlDmHostServer2Exe );

    92 			iServerId = 2;

    93 			}

    94 		else if(aServerName.Compare(KNSmlDmHostServer3Name)==0)

    95 			{

    96 			result = LaunchServerL( KNSmlDmHostServer3Exe );

    97 			iServerId = 3;

    98 			}

    99 		else if(aServerName.Compare(KNSmlDmHostServer4Name)==0)

   100 			{

   101 			result = LaunchServerL( KNSmlDmHostServer4Exe );

   102 			iServerId = 4;

   103 			}

   104 		if ( result == KErrNone )

   105 			{

   106 			result = CreateSession( aServerName, ver );

   107 			}

   108 		}

   109 	

   110 	return result; 

   111 	}

   112 	

   113 

   114 // ------------------------------------------------------------------------------------------------

   115 // void RNSmlDMDataSession::Version()

   116 // Return the version number

   117 // ------------------------------------------------------------------------------------------------

   118 TVersion RNSmlDMDataSession::Version(void) const

   119 	{

   120 	TVersion ver ( KNSmlDmHostServerVerMajor, KNSmlDmHostServerVerMinor,

   121 		KNSmlDmHostServerVerBuild );

   122 

   123 	return ver;

   124 	}

   125 

   126 

   127 // ------------------------------------------------------------------------------------------------

   128 // void RNSmlDMDataSession::Close()

   129 // Close the session; makes call to server which deletes the object

   130 // container and object index for this session

   131 // ------------------------------------------------------------------------------------------------

   132 void RNSmlDMDataSession::Close()

   133 	{

   134 	iChunk.Close();

   135 	SendReceive(ENSmlDMCloseSession,TIpcArgs());

   136 	RHandleBase::Close();

   137 	if(iMapUris)

   138 		{

   139 		iMapUris->ResetAndDestroy();

   140 		delete iMapUris;

   141 		iMapUris = NULL;

   142 		}

   143 	if(iMapLuids)

   144 		{

   145 		iMapLuids->ResetAndDestroy();

   146 		delete iMapLuids;

   147 		iMapLuids = NULL;

   148 		}

   149 	delete iLargeObjectUri;

   150 	iLargeObjectUri = NULL;

   151 	}

   152 

   153 

   154 // ------------------------------------------------------------------------------------------------

   155 //void RNSmlDMDataSession::LaunchServer( const TDesC& aServerExeName )

   156 // ------------------------------------------------------------------------------------------------

   157 TInt RNSmlDMDataSession::LaunchServerL( const TDesC& aServerExeName )

   158 	{

   159 	TInt result( KErrNone );

   160 	TParse parser;

   161 	parser.Set ( aServerExeName, &KDC_PROGRAMS_DIR, NULL );

   162 

   163 	RProcess server;

   164 	result = server.Create( parser.FullName(), KNullDesC );

   165 

   166 	// Process creation failed.

   167 	User::LeaveIfError( result );

   168 	

   169 	TRequestStatus status;

   170 	server.Rendezvous( status );

   171 

   172 	if ( status != KRequestPending )

   173 		{

   174 		server.Kill( 0 );	// abort startup

   175 		server.Close();

   176 		return KErrGeneral;	// status can be KErrNone: don't return status.Int()

   177 		}

   178 	else

   179 		{

   180 		server.Resume();	// logon OK - start the server

   181 		}

   182 		

   183 	User::WaitForRequest( status );

   184 	

   185 	result = status.Int();

   186 	

   187 	if ( status == KErrNone )

   188 		{

   189 		server.Close();

   190 		}

   191 

   192 	return result;

   193 	}

   194 

   195 

   196 // ------------------------------------------------------------------------------------------------

   197 //TInt RNSmlDMDataSession::DDFStructureL(MSmlDmDDFObject& aDDF)

   198 // ------------------------------------------------------------------------------------------------

   199 TInt RNSmlDMDataSession::DDFStructureL(CNSmlDmMgmtTree& aRoot)

   200 	{

   201 	iChunk.Close();

   202 	User::LeaveIfError(iChunk.CreateGlobal( KNullDesC,

   203 		KNSmlDmHostChunkMinSize, KNSmlDmHostChunkMaxSize ));

   204 	SendChunkHandle();

   205 	

   206 	RArray<TUint32> loadedAdapters;

   207 	aRoot.FindLoadedAdaptersL(loadedAdapters);

   208 

   209 	TUint8 count = loadedAdapters.Count();

   210 	

   211 	//1 byte for count and 4 bytes/implUid

   212 	HBufC8* adaptersBuffer = HBufC8::NewLC(1+4*count);

   213 	

   214 	TPtr8 adapterBufPtr = adaptersBuffer->Des();

   215 	RDesWriteStream writeStream(adapterBufPtr);

   216 	CleanupClosePushL(writeStream);

   217 	writeStream.WriteUint8L(count);

   218 	for(TUint8 i=0;i<count;i++)

   219 		{

   220 		TUint32 uid = loadedAdapters[i];

   221 		writeStream.WriteUint32L(uid);

   222 		}

   223 	loadedAdapters.Reset();

   224 	loadedAdapters.Close();

   225 	

   226 	TPckgBuf<TInt> checkSum;

   227 	TPckgBuf<TNSmlDmHostCallbackType> callbackCalled;

   228 	

   229 	TIpcArgs args(&adapterBufPtr,0,&checkSum,&callbackCalled);

   230 	CleanupStack::PopAndDestroy(); //writeStream

   231 	

   232 	TInt errCode = SendReceive( ENSmlDMGetDDF, args );

   233 	

   234 	CleanupStack::PopAndDestroy(); //adaptersBuf

   235 	

   236 	if(errCode!=KErrNone)

   237 		{

   238 		return 0;

   239 		}

   240 

   241 	RMemReadStream readStream( iChunk.Base(), iChunk.Size() );

   242 	CleanupClosePushL( readStream );

   243 	

   244 	aRoot.ParseWBXMLL(readStream);	

   245 	CleanupStack::PopAndDestroy(); // readStream

   246 	

   247 	return checkSum();	

   248 	}

   249 

   250 

   251 // ------------------------------------------------------------------------------------------------

   252 // RNSmlDMDataSession::HandleCallbacks(TNSmlDmHostCallbackType aCallbackType)

   253 // handles callbacks

   254 // ------------------------------------------------------------------------------------------------

   255 void RNSmlDMDataSession::HandleCallbacksL(

   256 	TNSmlDmHostCallbackType aCallbackType)

   257 	{

   258 	TNSmlDmHostCallbackType callbackType=aCallbackType;

   259 	TPckgBuf<TNSmlDmHostCallbackType> callbackCalled;

   260 	

   261 	while(callbackType!=ENSmlDmCallbackNone)

   262 		{

   263 		if(callbackType==ENSmlDmCallbackMappings)

   264 			{

   265            	_DBG_FILE("CNSmlDmDDF::HandleCallbacksL():mappings");

   266 			TIpcArgs args(0,0,0,&callbackCalled);

   267 			SendReceive( ENSmlDMGetMappings,args);

   268 

   269 			callbackType = callbackCalled();

   270 			RMemReadStream readStream( iChunk.Base(), iChunk.Size() );

   271 			CleanupClosePushL( readStream );

   272 			

   273 			if(iMapUris==0)

   274 				{

   275 				iMapUris = new (ELeave) CArrayPtrSeg <HBufC8> (4);

   276 				}

   277 			if(iMapLuids==0)

   278 				{

   279 				iMapLuids = new (ELeave) CArrayPtrSeg <HBufC8> (4);

   280 				}

   281 

   282 			

   283 			NSmlDmCmdArgHandler::ParseMappingsL(readStream,*iMapUris,

   284 				*iMapLuids);

   285 				

   286 			for(TInt i=0;i<iMapUris->Count();i++)

   287 				{

   288 				if(iMapUris->At(i)->Length()&&iMapLuids->At(i)->Length())

   289 					{

   290 					iCallback->SetMappingL(*iMapUris->At(i),*iMapLuids->At(i));

   291 					}

   292 				}

   293 				

   294 			iMapUris->ResetAndDestroy();

   295 			iMapLuids->ResetAndDestroy();

   296 							

   297 			CleanupStack::PopAndDestroy(); // readStream

   298 			}

   299 		else if(callbackType==ENSmlDmCallbackStatuses)

   300 			{

   301            	_DBG_FILE("CNSmlDmDDF::HandleCallbacksL():statuses");

   302 			TIpcArgs args(0,0,0,&callbackCalled);

   303 			SendReceive( ENSmlDMGetStatuses,args);

   304 

   305 			callbackType = callbackCalled();

   306 			RMemReadStream readStream( iChunk.Base(), iChunk.Size() );

   307 			CleanupClosePushL( readStream );

   308 			

   309 			RArray<TNSmlDmStatusElement> statusArray;

   310 			CleanupClosePushL(statusArray);

   311 			NSmlDmCmdArgHandler::ParseStatusesL(readStream,statusArray);

   312 

   313 			for(TInt i=0;i<statusArray.Count();i++)

   314 				{

   315 				iCallback->SetStatusL(statusArray[i].iStatusRef,

   316 					statusArray[i].iStatus);

   317 				}

   318 			CleanupStack::PopAndDestroy(2); // readStream, statusArray

   319 			}

   320 		else if(callbackType==ENSmlDmCallbackResults)

   321 			{

   322            	_DBG_FILE("CNSmlDmDDF::HandleCallbacksL():results");

   323 			TPckgBuf<TInt> dataLength;

   324 			TIpcArgs args(0,0,&dataLength,&callbackCalled);

   325 			SendReceive( ENSmlDMGetResults,args);

   326 

   327 			callbackType = callbackCalled();

   328 			RMemReadStream readStream( iChunk.Base(), iChunk.Size() );

   329 			CleanupClosePushL( readStream );

   330 			

   331 			RPointerArray<CNSmlDmResultElement> resultArray;

   332 			CleanupStack::PushL ( PtrArrCleanupItemRArr ( CNSmlDmResultElement, &resultArray ) );

   333 

   334 			NSmlDmCmdArgHandler::ParseResultsL(readStream,resultArray);

   335 			

   336 			if(callbackType==ENSmlDmCallbackChunkFull)

   337 			    {

   338                	_DBG_FILE("CNSmlDmDDF::HandleCallbacksL():results chunk full");

   339 			    for(TInt i=0;i<resultArray.Count();i++)

   340 				    {

   341 				    iCallback->SetResultsL(resultArray[i]->iResultRef,

   342 					    *resultArray[i]->iResult,*resultArray[i]->iMimeType,

   343 					    dataLength(),iServerId-1);

   344     				}

   345 			    }

   346 			else

   347 			    {

   348     			for(TInt i=0;i<resultArray.Count();i++)

   349     				{

   350     				iCallback->SetResultsL(resultArray[i]->iResultRef,

   351     					*resultArray[i]->iResult,*resultArray[i]->iMimeType,

   352     					resultArray[i]->iResult->Size(),iServerId-1);

   353     				}

   354 				}

   355 			CleanupStack::PopAndDestroy(2); // readStream,resultArray

   356 			}

   357 		else if(callbackType==ENSmlDmCallbackChunkFull)

   358 			{

   359 			callbackType=ENSmlDmCallbackNone;

   360 			}

   361 		else

   362 			{

   363 			callbackType=ENSmlDmCallbackNone;

   364 			}

   365 		} // end while

   366 	}

   367 

   368 

   369 // ------------------------------------------------------------------------------------------------

   370 // RNSmlDMDataSession::SendChunkHandle

   371 // Sends Chunk handle to SyncML DM Host Servers.

   372 // ------------------------------------------------------------------------------------------------

   373 TInt RNSmlDMDataSession::SendChunkHandle()

   374 	{

   375 	TIpcArgs args;

   376  	args.Set(0, iChunk);

   377  	args.Set(1, iServerId);

   378  	const TInt error = SendReceive( ENSmlDMChunkHandle, args );

   379  	return error;

   380 	}

   381 

   382 

   383 // ------------------------------------------------------------------------------------------------

   384 // RNSmlDMDataSession::UpdateLeafL

   385 // Sends update leaf IPC call to SyncML DM Host Servers.

   386 // ------------------------------------------------------------------------------------------------

   387 void RNSmlDMDataSession::UpdateLeafL(TUint32 aAdapterId,

   388 	const TDesC8& aLuid,

   389 	const TInt32 aStatusRef,

   390 	const TDesC8& aURI,

   391 	const TDesC8& aObject,

   392 	const TDesC8& aType,

   393 	const TBool aLargeItem,

   394 	// FOTA

   395 	const TInt aTotSizeOfLarge

   396 	// FOTA end

   397 	)

   398 	{

   399 	TPckgBuf<TNSmlDmHostCallbackType> callbackCalled(ENSmlDmCallbackNone);

   400 	TInt dataLen = aObject.Length()

   401 		+aURI.Length()+aType.Length()+aLuid.Length()+16;

   402 		//16=4*4bytes, TInt = 4 bytes, each datasize must be stored to stream 

   403 	if(dataLen<KNSmlMinChunk)

   404 		{

   405 		iChunk.Adjust(KNSmlMinChunk);

   406 		}

   407 	else

   408 		{

   409 		iChunk.Adjust(dataLen);

   410 		}

   411 	RMemWriteStream writeStream( iChunk.Base(), iChunk.Size() );

   412 	CleanupClosePushL( writeStream );

   413 	

   414 	NSmlDmCmdArgHandler::PacketDataL(writeStream,aLuid,aObject,aURI,aType);

   415 	CleanupStack::PopAndDestroy(); // writeStream

   416 	TInt ret(KErrNone);

   417 		

   418 	if(aLargeItem)

   419 		{

   420 		if(iLargeObjectUri)

   421 			{

   422 			if(iLargeObjectUri->Compare(aURI)==0)

   423 				{

   424 				TIpcArgs args(aAdapterId,aStatusRef,EFalse,&callbackCalled);

   425 				ret = SendReceive( ENSmlDMUpdateLeafLarge,args);

   426 				}

   427 			else

   428 				{

   429 				ret = KErrGeneral;

   430 				}

   431 			}

   432 		else

   433 			{

   434 			iLargeObjectUri=aURI.AllocL();

   435 			// FOTA

   436 			if ( aTotSizeOfLarge && aAdapterId == KNSmlDMFotaAdapterImplUid )

   437 				{

   438 				// For the FOTA adapter the third parameter is overloaded.

   439 				// It contains the overall size of the large object.

   440 				// The size information is sent only with the first chunk.

   441 				TIpcArgs args(aAdapterId,aStatusRef,aTotSizeOfLarge,&callbackCalled);

   442 				ret = SendReceive( ENSmlDMUpdateLeafLarge,args);

   443 				}

   444 			else

   445 				{

   446 				TIpcArgs args(aAdapterId,aStatusRef,EFalse,&callbackCalled);			

   447 				ret = SendReceive( ENSmlDMUpdateLeafLarge,args);

   448 				}

   449 			// FOTA end

   450 			}

   451 		}

   452 	else

   453 		{

   454 		if(iLargeObjectUri)

   455 			{

   456 			delete iLargeObjectUri;

   457 			iLargeObjectUri=NULL;

   458 			TIpcArgs args(aAdapterId,aStatusRef,ETrue,&callbackCalled);

   459 			ret = SendReceive( ENSmlDMUpdateLeafLarge,args);

   460 			}

   461 		else

   462 			{

   463 			TIpcArgs args(aAdapterId,aStatusRef,0,&callbackCalled);

   464 			ret = SendReceive( ENSmlDMUpdateLeaf,args);

   465 			}

   466 		}	

   467 

   468 	TNSmlDmHostCallbackType callbackType = callbackCalled();

   469 	if(callbackType!=ENSmlDmCallbackNone)

   470 		{

   471 		HandleCallbacksL(callbackType);

   472 		}

   473 	// FOTA

   474 	if ( aAdapterId == KNSmlDMFotaAdapterImplUid && ret == KErrTooBig )

   475 		{

   476 		iCallback->SetStatusL(aStatusRef,MSmlDmAdapter::ETooLargeObject);

   477 		delete iLargeObjectUri;

   478 		iLargeObjectUri=NULL;		

   479 		}

   480 	// FOTA end

   481 	else if(ret!=KErrNone)

   482 		{

   483 		iCallback->SetStatusL(aStatusRef,MSmlDmAdapter::EError);

   484 		delete iLargeObjectUri;

   485 		iLargeObjectUri=NULL;

   486 		}

   487 	}

   488 

   489 // ------------------------------------------------------------------------------------------------

   490 // RNSmlDMDataSession::AddNodeL

   491 // Sends add node IPC call to SyncML DM Host Servers.

   492 // ------------------------------------------------------------------------------------------------

   493 void RNSmlDMDataSession::AddNodeL(const TUint32 aAdapterId,

   494 	const TDesC8& aLuid,

   495 	const TInt32 aStatusRef,

   496 	const TDesC8& aURI)

   497 	{

   498 	TPckgBuf<TNSmlDmHostCallbackType> callbackCalled;

   499 	iChunk.Adjust(KNSmlMinChunk);

   500 		

   501 	TIpcArgs args(aAdapterId,aStatusRef,0,&callbackCalled);

   502 	RMemWriteStream writeStream( iChunk.Base(), iChunk.Size() );

   503 	CleanupClosePushL( writeStream );

   504 	

   505 	NSmlDmCmdArgHandler::PacketDataL(writeStream,aLuid,KNullDesC8,

   506 		aURI,KNullDesC8);

   507 	CleanupStack::PopAndDestroy(); // writeStream

   508 			

   509 	SendReceive( ENSmlDMAddNode,args);

   510 

   511 	TNSmlDmHostCallbackType callbackType = callbackCalled();

   512 	if(callbackType!=ENSmlDmCallbackNone)

   513 		{

   514 		HandleCallbacksL(callbackType);

   515 		}

   516 	}

   517 

   518 // ------------------------------------------------------------------------------------------------

   519 // RNSmlDMDataSession::ExecuteCommandL

   520 // Sends execute IPC call to SyncML DM Host Servers.

   521 // ------------------------------------------------------------------------------------------------

   522 void RNSmlDMDataSession::ExecuteCommandL(const TUint32 aAdapterId,

   523 	const TDesC8& aLuid,

   524 	const TInt32 aStatusRef,

   525 	const TDesC8& aURI,

   526 	const TDesC8& aObject,

   527 	const TDesC8& aType,

   528 	const TBool aLargeItem)

   529 	{

   530 	TPckgBuf<TNSmlDmHostCallbackType> callbackCalled(ENSmlDmCallbackNone);

   531 

   532 	TInt dataLen = aObject.Length()

   533 		+aURI.Length()+aType.Length()+aLuid.Length()+16;

   534 		//16=4*4bytes, TInt = 4 bytes, each datasize must be stored to stream 

   535 		

   536 	if(dataLen<KNSmlMinChunk)

   537 		{

   538 		iChunk.Adjust(KNSmlMinChunk);

   539 		}

   540 	else

   541 		{

   542 		iChunk.Adjust(dataLen);

   543 		}

   544 		

   545 	RMemWriteStream writeStream( iChunk.Base(), iChunk.Size() );

   546 	CleanupClosePushL( writeStream );

   547 	

   548 	NSmlDmCmdArgHandler::PacketDataL(writeStream,aLuid,aObject,aURI,aType);

   549 	CleanupStack::PopAndDestroy(); // writeStream

   550 	TInt ret = KErrNone;

   551 			

   552 	if(aLargeItem)

   553 		{

   554 		if(iLargeObjectUri)

   555 			{

   556 			if(iLargeObjectUri->Compare(aURI)==0)

   557 				{

   558 				TIpcArgs args(aAdapterId,aStatusRef,EFalse,&callbackCalled);

   559 				ret = SendReceive( ENSmlDMExecuteLarge,args);

   560 				}

   561 			else

   562 				{

   563 				ret = KErrGeneral;

   564 				}

   565 			}

   566 		else

   567 			{

   568 			iLargeObjectUri=aURI.AllocL();

   569 			TIpcArgs args(aAdapterId,aStatusRef,EFalse,&callbackCalled);

   570 			ret = SendReceive( ENSmlDMExecuteLarge,args);

   571 			}

   572 		}

   573 	else

   574 		{

   575 		if(iLargeObjectUri)

   576 			{

   577 			delete iLargeObjectUri;

   578 			iLargeObjectUri=NULL;

   579 			TIpcArgs args(aAdapterId,aStatusRef,ETrue,&callbackCalled);

   580 			ret = SendReceive( ENSmlDMExecuteLarge,args);

   581 			}

   582 		else

   583 			{

   584 			TIpcArgs args(aAdapterId,aStatusRef,0,&callbackCalled);

   585 			ret = SendReceive( ENSmlDMExecute,args);

   586 			}

   587 		}	

   588 

   589 	TNSmlDmHostCallbackType callbackType = callbackCalled();

   590 	if(callbackType!=ENSmlDmCallbackNone)

   591 		{

   592 		HandleCallbacksL(callbackType);

   593 		}

   594 	if(ret!=KErrNone)

   595 		{

   596 		iCallback->SetStatusL(aStatusRef,MSmlDmAdapter::EError);

   597 		}

   598 	}

   599 

   600 

   601 // ------------------------------------------------------------------------------------------------

   602 // RNSmlDMDataSession::CopyCommandL

   603 // Sends copy IPC call to SyncML DM Host Servers.

   604 // ------------------------------------------------------------------------------------------------

   605 void RNSmlDMDataSession::CopyCommandL(const TUint32 aAdapterId,

   606 	const TDesC8& aTargetLuid,

   607 	const TDesC8& aTargetURI,

   608 	const TDesC8& aSourceLuid,

   609 	const TDesC8& aSourceURI,

   610 	const TInt32 aStatusRef,

   611 	const TDesC8& aType)

   612 	{

   613 	TPckgBuf<TNSmlDmHostCallbackType> callbackCalled;

   614 	iChunk.Adjust(KNSmlMinChunk);

   615 		

   616 	TIpcArgs args(aAdapterId,aStatusRef,0,&callbackCalled);

   617 	RMemWriteStream writeStream( iChunk.Base(), iChunk.Size() );

   618 	CleanupClosePushL( writeStream );

   619 	

   620 	NSmlDmCmdArgHandler::PacketCopyArgumentsL(writeStream,

   621 		aTargetLuid,aTargetURI,aSourceLuid,aSourceURI,aType);

   622 		

   623 	CleanupStack::PopAndDestroy(); // writeStream

   624 			

   625 	TInt ret = SendReceive( ENSmlDMCopy,args);

   626 

   627 	TNSmlDmHostCallbackType callbackType = callbackCalled();

   628 	if(callbackType!=ENSmlDmCallbackNone)

   629 		{

   630 		HandleCallbacksL(callbackType);

   631 		}

   632 	if(ret!=KErrNone)

   633 		{

   634 		iCallback->SetStatusL(aStatusRef,MSmlDmAdapter::EError);

   635 		}

   636 	}

   637 

   638 

   639 // ------------------------------------------------------------------------------------------------

   640 // RNSmlDMDataSession::DeleteObjectL

   641 // Sends delete IPC call to SyncML DM Host Servers.

   642 // ------------------------------------------------------------------------------------------------

   643 void RNSmlDMDataSession::DeleteObjectL(const TUint32 aAdapterId,

   644 	const TDesC8& aLuid,

   645 	const TInt32 aStatusRef,

   646 	const TDesC8& aURI)

   647 	{

   648 	TPckgBuf<TNSmlDmHostCallbackType> callbackCalled;

   649 	iChunk.Adjust(KNSmlMinChunk);

   650 		

   651 	TIpcArgs args(aAdapterId,aStatusRef,0,&callbackCalled);

   652 	RMemWriteStream writeStream( iChunk.Base(), iChunk.Size() );

   653 	CleanupClosePushL( writeStream );

   654 	

   655 	NSmlDmCmdArgHandler::PacketDataL(writeStream,

   656 		aLuid,KNullDesC8,aURI,KNullDesC8);

   657 		

   658 	CleanupStack::PopAndDestroy(); // writeStream

   659 			

   660 	TInt ret = SendReceive( ENSmlDMDelete,args);

   661 

   662 	TNSmlDmHostCallbackType callbackType = callbackCalled();

   663 	if(callbackType!=ENSmlDmCallbackNone)

   664 		{

   665 		HandleCallbacksL(callbackType);

   666 		}

   667 	if(ret!=KErrNone)

   668 		{

   669 		iCallback->SetStatusL(aStatusRef,MSmlDmAdapter::EError);

   670 		}

   671 

   672 	}

   673 

   674 // ------------------------------------------------------------------------------------------------

   675 // RNSmlDMDataSession::FetchLeafObjectL

   676 // Sends fetch IPC call to SyncML DM Host Servers.

   677 // ------------------------------------------------------------------------------------------------

   678 void RNSmlDMDataSession::FetchLeafObjectL(const TUint32 aAdapterId,

   679 	const TDesC8& aURI,

   680 	const TDesC8& aLuid,

   681 	const TDesC8& aType,

   682 	const TInt aResultsRef,

   683 	const TInt aStatusRef )

   684 	{

   685 	TPckgBuf<TNSmlDmHostCallbackType> callbackCalled;

   686 	TIpcArgs args(aAdapterId,aStatusRef,aResultsRef,&callbackCalled);

   687 	iChunk.Adjust(KNSmlMinChunk);

   688 	RMemWriteStream writeStream( iChunk.Base(), iChunk.Size() );

   689 	CleanupClosePushL( writeStream );

   690 	CArrayFixFlat<TSmlDmMappingInfo>* mapArray =

   691 		new (ELeave) CArrayFixFlat<TSmlDmMappingInfo>(1);

   692 		

   693 	CleanupStack::PushL(mapArray);

   694 	NSmlDmCmdArgHandler::PacketFetchArgumentsL(writeStream,aLuid,

   695 		aURI,aType,*mapArray);

   696 		

   697 	CleanupStack::PopAndDestroy(2); // writeStream,mapArray

   698 			

   699 	TInt ret = SendReceive( ENSmlDMFetchLeaf,args);

   700 

   701 	TNSmlDmHostCallbackType callbackType = callbackCalled();

   702 	if(callbackType!=ENSmlDmCallbackNone)

   703 		{

   704 		HandleCallbacksL(callbackType);

   705 		}

   706 	if(ret!=KErrNone)

   707 		{

   708 		iCallback->SetStatusL(aStatusRef,MSmlDmAdapter::EError);

   709 		}

   710 

   711 	}

   712 

   713 // ------------------------------------------------------------------------------------------------

   714 // RNSmlDMDataSession::FetchLeafObjectSizeL

   715 // Sends fetch size IPC call to SyncML DM Host Servers.

   716 // ------------------------------------------------------------------------------------------------

   717 void RNSmlDMDataSession::FetchLeafObjectSizeL(const TUint32 aAdapterId,

   718 	const TDesC8& aURI,

   719 	const TDesC8& aLuid,

   720 	const TDesC8& aType,

   721 	const TInt aResultsRef,

   722 	const TInt aStatusRef )

   723 	{

   724 	TPckgBuf<TNSmlDmHostCallbackType> callbackCalled;

   725 	TIpcArgs args(aAdapterId,aStatusRef,aResultsRef,&callbackCalled);

   726 	iChunk.Adjust(KNSmlMinChunk);

   727 	RMemWriteStream writeStream( iChunk.Base(), iChunk.Size() );

   728 	CleanupClosePushL( writeStream );

   729 	CArrayFixFlat<TSmlDmMappingInfo>* mapArray =

   730 		new (ELeave) CArrayFixFlat<TSmlDmMappingInfo>(1);

   731 	CleanupStack::PushL(mapArray);

   732 	

   733 	NSmlDmCmdArgHandler::PacketFetchArgumentsL(writeStream,aLuid,aURI,

   734 		aType,*mapArray);

   735 		

   736 	CleanupStack::PopAndDestroy(2); // writeStream,mapArray

   737 			

   738 	TInt ret = SendReceive( ENSmlDMFetchLeafSize,args);

   739 

   740 	TNSmlDmHostCallbackType callbackType = callbackCalled();

   741 	if(callbackType!=ENSmlDmCallbackNone)

   742 		{

   743 		HandleCallbacksL(callbackType);

   744 		}

   745 	if(ret!=KErrNone)

   746 		{

   747 		iCallback->SetStatusL(aStatusRef,MSmlDmAdapter::EError);

   748 		}

   749 	}

   750 

   751 

   752 

   753 // ------------------------------------------------------------------------------------------------

   754 // RNSmlDMDataSession::ChildURIListL

   755 // Sends child urilist IPC call to SyncML DM Host Servers.

   756 // ------------------------------------------------------------------------------------------------

   757 void RNSmlDMDataSession::ChildURIListL(const TUint32 aAdapterId,

   758 	const TDesC8& aURI,

   759 	const TDesC8& aLuid,

   760 	const CArrayFixFlat<TSmlDmMappingInfo>& aPreviousURISegmentList,

   761 	const TInt aResultsRef,const TInt aStatusRef )

   762 	{

   763 	TPckgBuf<TNSmlDmHostCallbackType> callbackCalled;

   764 	TIpcArgs args(aAdapterId,aStatusRef,aResultsRef,&callbackCalled);

   765 	iChunk.Adjust(KNSmlMinChunk);

   766 	RMemWriteStream writeStream( iChunk.Base(), iChunk.Size() );

   767 	CleanupClosePushL( writeStream );

   768 	

   769 	NSmlDmCmdArgHandler::PacketFetchArgumentsL(writeStream,aLuid,

   770 		aURI,KNullDesC8,aPreviousURISegmentList);

   771 		

   772 	CleanupStack::PopAndDestroy(); // writeStream

   773 			

   774 	TInt ret = SendReceive( ENSmlDMChildUriList,args);

   775 

   776 	TNSmlDmHostCallbackType callbackType = callbackCalled();

   777 	if(callbackType!=ENSmlDmCallbackNone)

   778 		{

   779 		HandleCallbacksL(callbackType);

   780 		}

   781 	if(ret!=KErrNone)

   782 		{

   783 		iCallback->SetStatusL(aStatusRef,MSmlDmAdapter::EError);

   784 		}

   785 	}

   786 

   787 

   788 // ------------------------------------------------------------------------------------------------

   789 // RNSmlDMDataSession::CompleteOutstandingCmdsL

   790 // Sends CompleteOutstandingCmds IPC call to SyncML DM Host Servers.

   791 // ------------------------------------------------------------------------------------------------

   792 void RNSmlDMDataSession::CompleteOutstandingCmdsL()

   793 	{

   794    	_DBG_FILE("CNSmlDmDDF::CompleteOutstandingCmdsL():begin");

   795 	TPckgBuf<TNSmlDmHostCallbackType> callbackCalled;

   796 	TIpcArgs args(0,0,0,&callbackCalled);

   797 	SendReceive( ENSmlDMCompleteCommands,args);

   798 	TNSmlDmHostCallbackType callbackType = callbackCalled();

   799 	if(callbackType!=ENSmlDmCallbackNone)

   800 		{

   801 		HandleCallbacksL(callbackType);

   802 		}

   803    	_DBG_FILE("CNSmlDmDDF::CompleteOutstandingCmdsL():end");

   804 	}

   805 

   806 // ------------------------------------------------------------------------------------------------

   807 // RNSmlDMDataSession::MoreDataL

   808 // Sends get more data IPC call to SyncML DM Host Servers.

   809 // ------------------------------------------------------------------------------------------------

   810 void RNSmlDMDataSession::MoreDataL(CBufBase*& aData)

   811 	{

   812 	TPckgBuf<TNSmlDmHostCallbackType> callbackCalled;

   813 	TIpcArgs args(0,0,0,&callbackCalled);

   814 	SendReceive( ENSmlDMGetMore,args);

   815 	RMemReadStream readStream( iChunk.Base(), iChunk.Size() );

   816 	CleanupClosePushL( readStream );

   817 			

   818 	RPointerArray<CNSmlDmResultElement> resultArray;

   819 	CleanupStack::PushL ( PtrArrCleanupItemRArr ( CNSmlDmResultElement, &resultArray ) );

   820 

   821 	NSmlDmCmdArgHandler::ParseResultsL(readStream,resultArray);

   822 	

   823 

   824 	RBufWriteStream writeStream(*aData,aData->Size());

   825 	CleanupClosePushL(writeStream);

   826 	

   827 	if(resultArray.Count()>0)

   828 		{

   829 		writeStream.WriteL(resultArray[0]->iResult->Ptr(0),

   830 			resultArray[0]->iResult->Size());

   831 		}

   832 	CleanupStack::PopAndDestroy(3); //writeStream, readStream, resultArray

   833 	}

   834 

   835 

   836 

   837 // ------------------------------------------------------------------------------------------------

   838 // RNSmlDMDataSession::StartAtomicL

   839 // Sends start atomic IPC call to SyncML DM Host Servers.

   840 // ------------------------------------------------------------------------------------------------

   841 void RNSmlDMDataSession::StartAtomicL()

   842 	{

   843 	TPckgBuf<TNSmlDmHostCallbackType> callbackCalled;

   844 	TIpcArgs args(0,0,0,&callbackCalled);

   845 	SendReceive( ENSmlDMStartAtomic,args);

   846 	TNSmlDmHostCallbackType callbackType = callbackCalled();

   847 	if(callbackType!=ENSmlDmCallbackNone)

   848 		{

   849 		HandleCallbacksL(callbackType);

   850 		}

   851 

   852 	}

   853 

   854 // ------------------------------------------------------------------------------------------------

   855 // RNSmlDMDataSession::CommitAtomicL

   856 // Sends commit atomic IPC call to SyncML DM Host Servers.

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

   858 void RNSmlDMDataSession::CommitAtomicL()

   859 	{

   860 	TPckgBuf<TNSmlDmHostCallbackType> callbackCalled;

   861 	TIpcArgs args(0,0,0,&callbackCalled);

   862 	SendReceive( ENSmlDMCommitAtomic,args);

   863 	TNSmlDmHostCallbackType callbackType = callbackCalled();

   864 	if(callbackType!=ENSmlDmCallbackNone)

   865 		{

   866 		HandleCallbacksL(callbackType);

   867 		}

   868 	}

   869 

   870 // ------------------------------------------------------------------------------------------------

   871 // RNSmlDMDataSession::RollbackAtomic

   872 // Sends rollback atomic IPC call to SyncML DM Host Servers.

   873 // ------------------------------------------------------------------------------------------------

   874 void RNSmlDMDataSession::RollbackAtomicL()

   875 	{

   876 	TPckgBuf<TNSmlDmHostCallbackType> callbackCalled;

   877 	TIpcArgs args(0,0,0,&callbackCalled);

   878 	SendReceive( ENSmlDMRollbackAtomic,args);

   879 	TNSmlDmHostCallbackType callbackType = callbackCalled();

   880 	if(callbackType!=ENSmlDmCallbackNone)

   881 		{

   882 		HandleCallbacksL(callbackType);

   883 		}

   884 	}

   885 

   886 // FOTA

   887 // ------------------------------------------------------------------------------------------------

   888 // RNSmlDMDataSession::MarkGenAlertsSent()

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

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

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

   892 //  In this function a request is issued as an IPC call.

   893 // ------------------------------------------------------------------------------------------------

   894 void RNSmlDMDataSession::MarkGenAlertsSent()

   895 	{

   896 	SendReceive ( ENSmlDMGenericAlertsSent,TIpcArgs ( TIpcArgs::ENothing ) );

   897 	}

   898 

   899 

   900 void RNSmlDMDataSession::MarkGenAlertsSent(const TDesC8 &aURI)

   901 	{

   902 	

   903 	_DBG_FILE(" RNSmlDMDataSession::MarkGenAlertsSent calling with the URI ");

   904 	SendReceive ( ENSmlDMGenericAlertsSent,TIpcArgs ( &aURI ) );

   905 	}

   906 // FOTA end