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:  A common session class for all the specialized 

    15 *				 DM Host Servers.

    16 *

    17 */

    18 

    19 

    20 // ------------------------------------------------------------------------------------------------

    21 // Includes

    22 // ------------------------------------------------------------------------------------------------

    23 //

    24 #include <s32mem.h>

    25 #include <s32strm.h>

    26 #include <implementationinformation.h>

    27 #include <ecom.h>

    28 #include <nsmlconstants.h>

    29 #include <nsmldebug.h>

    30 #include <smldmadapter.h>

    31 

    32 // FOTA

    33 #include <nsmldmconst.h>

    34 // FOTA end

    35 #include <nsmldmuri.h>

    36 #include <e32property.h>

    37 #include "nsmldminternalpskeys.h"

    38 #include "nsmldmclientandserver.h"

    39 #include "nsmldmhostserver.h"

    40 #include "nsmldmhostsession.h"

    41 #include "nsmldmcmdarghandler.h"

    42 #include "nsmldmimpluids.h"

    43 #include <featmgr.h>

    44 

    45 #ifndef __WINS__

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

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

    48 // DBG_ARGS8 macro in no-debug builds.

    49 #pragma diag_remark 174

    50 #endif

    51 

    52 

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

    54 // Constants

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

    56 //

    57 // Granularity of the lists; mapping info and prevUriSegList

    58 const TInt KNSmlDmGranularity = 8;

    59 

    60 // This means the dm adapter doesn't support streaming

    61 const TInt KNSmlDmNotSupported = -1;

    62 

    63 // During the fetch link serving the callbacks are handled differently

    64 const TInt KNSmlDmNoRef = -1; 

    65 

    66 // A safety margin (in bytes) which is left unreserved in the chunk

    67 const TInt KNSmlDmChunkMarginal = 128;

    68 

    69 // A cross-reference to the interner adapter is recognized using these strings

    70 _LIT8 ( KNSmlDmApAdapterURI1, "AP" );

    71 _LIT8 ( KNSmlDmApAdapterURI2, "./AP" );

    72 

    73 // Identifies the server which owns the internet DM plug-in adapter

    74 const TInt KNSmlDmApAdapterServerId = 1;

    75 

    76 // Tells to the session class that it is acting as a fetch link server

    77 const TInt KNSmlDmFetchLinkServerId = 99;

    78 

    79 // The constant part of the result item size in bytes: 	

    80 //  iResultRef => 2 bytes

    81 //  iResult->Size => 4 bytes

    82 //  iMimeType->Length => 2 bytes

    83 const TInt KNSmlDmConstItemSize = 8;

    84 

    85 // FOTA

    86 const TInt KNSmlDmLastPackage = 1;

    87 // FOTA end

    88 

    89 

    90 // ------------------------------------------------------------------------------------------------

    91 // CNSmlDMHostSession::CNSmlDMHostSession

    92 //	C++ constructor.

    93 //	@param aServer. The server instance, owner of session.

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

    95 //

    96 CNSmlDMHostSession::CNSmlDMHostSession ( CNSmlDMHostServer& aServer ) : 

    97     iServer(aServer)

    98 	{

    99 	_DBG_FILE("CNSmlDMHostSession::CNSmlDMHostSession(): begin");

   100 	iServer.IncSessionCount();

   101 	_DBG_FILE("CNSmlDMHostSession::CNSmlDMHostSession(): end");

   102 	}

   103 

   104 // ------------------------------------------------------------------------------------------------

   105 // CNSmlDMHostSession::~CNSmlDMHostSession

   106 //  C++ destructor.

   107 // ------------------------------------------------------------------------------------------------

   108 //

   109 CNSmlDMHostSession::~CNSmlDMHostSession()

   110 	{	

   111 	_DBG_FILE("CNSmlDMHostSession::~CNSmlDMHostSession(): begin");

   112 	if ( iCbSessConnected )

   113 		{

   114 		iCbSession.Close();		

   115 		}

   116 	iServer.DecSessionCount();

   117 	delete iMgmtTree;

   118 	if ( iOwnId != KNSmlDmFetchLinkServerId )

   119 		{

   120 		iChunk.Close(); 		

   121 		}

   122 	

   123 	for ( TInt i=0; i<iResultList.Count(); i++ )

   124 		{

   125 		delete iResultList[i];

   126 		}

   127 	iResultList.Close();

   128 	iStatusCodeList.Close();

   129 	iCallbackList.Close();

   130 	

   131 	if ( iLargeWriteStream.streamPtr )

   132 		{

   133 		iLargeWriteStream.streamPtr->Close();		

   134 		}

   135 	if ( iResultReadStream )

   136 		{

   137 		iResultReadStream->Close();		

   138 		}

   139 	

   140 	// delete all loaded adapters

   141 	for ( TInt i=0; i<iAdapters.Count(); i++ )

   142 		{

   143 		delete iAdapters[i].adapterPtr;

   144 		}

   145 	iAdapters.Close();

   146 	REComSession::FinalClose();	

   147 	if ( iMapUris )

   148 		{

   149 		iMapUris->ResetAndDestroy();

   150 		delete iMapUris;	

   151 		}

   152 	if ( iMapLuids )

   153 		{

   154 		iMapLuids->ResetAndDestroy();

   155 		delete iMapLuids;

   156 		}

   157 	delete iSemaphoreName;

   158 	delete iResultOtherAdapter;

   159 	delete iLargeObject;

   160 	DeletePrevParams();

   161 	FeatureManager::UnInitializeLib();

   162 	_DBG_FILE("CNSmlDMHostSession::~CNSmlDMHostSession(): end");

   163 	}

   164 

   165 // ------------------------------------------------------------------------------------------------

   166 // CNSmlDMHostSession::NewL

   167 //	Creates a new session object.

   168 //	@param aServer. Reference to server is needed in order to increase and decrease session counts.

   169 //	@return CNSmlDMHostSession*. New instance of this class.

   170 // ------------------------------------------------------------------------------------------------

   171 //

   172 CNSmlDMHostSession* CNSmlDMHostSession::NewL ( CNSmlDMHostServer& aServer )

   173 	{

   174 	_DBG_FILE("CNSmlDMHostSession::NewL(): begin");

   175 	CNSmlDMHostSession* self= new (ELeave) CNSmlDMHostSession ( aServer );

   176 	CleanupStack::PushL(self);

   177 	self->ConstructL();

   178 	CleanupStack::Pop(); // self

   179 	_DBG_FILE("CNSmlDMHostSession::NewL(): end");

   180 	return self;

   181 	}

   182 

   183 // ------------------------------------------------------------------------------------------------

   184 // CNSmlDMHostSession::ConstructL

   185 //	Symbian 2nd phase constructor

   186 // ------------------------------------------------------------------------------------------------

   187 //

   188 void CNSmlDMHostSession::ConstructL()

   189 	{

   190 	_DBG_FILE("CNSmlDMHostSession::ConstructL(): begin");

   191 	iMgmtTree = CNSmlDmMgmtTree::NewL();

   192 	iCommitStatus.iStreamingOngoing = EFalse;

   193 	iCommitStatus.iStreamCommitted = EFalse;

   194 	FeatureManager::InitializeLibL();

   195 	_DBG_FILE("CNSmlDMHostSession::ConstructL(): end");

   196 	}

   197 

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

   199 // CNSmlDMHostSession::ServiceL

   200 //	Handles the servicing of client requests.

   201 //	Entry point for arriving messages.

   202 //	@param aMessage. An object which encapsulates a client request.

   203 // ------------------------------------------------------------------------------------------------

   204 //

   205 void CNSmlDMHostSession::ServiceL ( const RMessage2& aMessage )

   206 	{

   207 	_DBG_FILE("CNSmlDMHostSession::ServiceL(): begin");

   208 	if(!aMessage.HasCapability(ECapabilityDiskAdmin))

   209 	    {

   210 	    _DBG_FILE("CNSmlDMHostSession::ServiceL(): capability fail");

   211 	    aMessage.Complete( KErrPermissionDenied );

   212 	    return;

   213 	    }

   214 	TRAPD ( err, DispatchMessageL ( aMessage ) );

   215 	aMessage.Complete( err );

   216 	_DBG_FILE("CNSmlDMHostSession::ServiceL(): end");

   217 	}

   218 

   219 // ------------------------------------------------------------------------------------------------

   220 // CNSmlDMHostSession::DispatchMessageL

   221 //	Extracts the operation code from the message. 

   222 //	Based on that calls the right private function.

   223 //	@param aMessage. An object which encapsulates a client request.

   224 // ------------------------------------------------------------------------------------------------

   225 //

   226 void CNSmlDMHostSession::DispatchMessageL ( const RMessage2& aMessage )

   227 	{

   228 	_DBG_FILE("CNSmlDMHostSession::DispatchMessageL(): begin");

   229 	switch( aMessage.Function() )

   230         {

   231 		case ENSmlDMCloseSession:

   232         	CloseSessionL();

   233         	break;

   234 		case ENSmlDMGetDDF:

   235         	GetDDFStructureL ( aMessage );

   236         	break;

   237         case ENSmlDMUpdateLeaf:

   238         	UpdateLeafOrExecuteL ( aMessage, ENSmlDMUpdateLeaf );

   239         	break;

   240         case ENSmlDMExecute:

   241         	UpdateLeafOrExecuteL ( aMessage, ENSmlDMExecute );

   242         	break;

   243         case ENSmlDMUpdateLeafLarge:

   244         	UpdateLeafOrExecuteLargeL ( aMessage, ENSmlDMUpdateLeafLarge );

   245         	break;

   246         case ENSmlDMExecuteLarge:

   247         	UpdateLeafOrExecuteLargeL ( aMessage, ENSmlDMExecuteLarge );

   248         	break;        	

   249         case ENSmlDMAddNode:

   250         	AddCopyOrDeleteL ( aMessage, ENSmlDMAddNode );

   251         	break;

   252         case ENSmlDMCopy:

   253         	AddCopyOrDeleteL ( aMessage, ENSmlDMCopy );

   254         	break;

   255         case ENSmlDMDelete:

   256         	AddCopyOrDeleteL ( aMessage, ENSmlDMDelete );

   257         	break;        

   258         case ENSmlDMStartAtomic:

   259         	StartAtomicL ( aMessage );

   260         	break;

   261         case ENSmlDMCommitAtomic:

   262         	CommitAtomicL ( aMessage );

   263         	break;

   264         case ENSmlDMRollbackAtomic:

   265         	RollbackAtomicL ( aMessage );

   266         	break;

   267         case ENSmlDMCompleteCommands:

   268         	CompleteCommandsL ( aMessage );

   269         	break;

   270         case ENSmlDMFetchLeaf:

   271         	FetchLeafChildUrisOrSizeL ( aMessage, ENSmlDMFetchLeaf );

   272         	break;

   273         case ENSmlDMFetchLink:

   274         	FetchLinkL ( aMessage );

   275         	break;

   276         case ENSmlDMFetchLeafSize:

   277         	FetchLeafChildUrisOrSizeL ( aMessage, ENSmlDMFetchLeafSize );

   278         	break;

   279         case ENSmlDMChildUriList:

   280         	FetchLeafChildUrisOrSizeL ( aMessage, ENSmlDMChildUriList );

   281         	break;

   282     	case ENSmlDMChunkHandle:

   283         	SetChunkHandleL ( aMessage ); 

   284         	break;

   285     	case ENSmlDMGetMappings:

   286         	GetMappingsL ( aMessage ); 

   287         	break;

   288     	case ENSmlDMGetStatuses:

   289         	GetStatusesL ( aMessage ); 

   290         	break;

   291     	case ENSmlDMGetResults:

   292         	GetResultsL ( aMessage ); 

   293         	break;

   294     	case ENSmlDMGetMore:

   295         	GetResultsL ( aMessage ); 

   296         	break;

   297         // FOTA

   298     	case ENSmlDMGenericAlertsSent:

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

   300     	{

   301     	_DBG_FILE(" CNSmlDMHostSession::DispatchMessageL(): calling new MarkGenAlertsSentL(message)");

   302         	MarkGenAlertsSentL(aMessage); 	

   303     	}

   304     	else

   305     	{

   306     	_DBG_FILE(" CNSmlDMHostSession::DispatchMessageL(): calling old  MarkGenAlertsSentL ");

   307         MarkGenAlertsSentL();	

   308     	}

   309         	break;

   310         // FOTA end

   311 		default:

   312 			PanicClient ( aMessage, KErrNotSupported );

   313         }

   314 	_DBG_FILE("CNSmlDMHostSession::DispatchMessageL(): end");

   315 	}

   316 

   317 

   318 // ------------------------------------------------------------------------------------------------

   319 // CNSmlDMHostSession::PanicClient

   320 //	Panics the client

   321 //	@param aMessage. Message from client to panic.

   322 //	@param aReason. Reason code.

   323 // ------------------------------------------------------------------------------------------------

   324 //

   325 void CNSmlDMHostSession::PanicClient ( const RMessage2& aMessage, TInt aReason ) const

   326 	{

   327 	_DBG_FILE("CNSmlDMHostSession::PanicClient(): begin");

   328 	aMessage.Panic ( _L( "CNSmlDMHostSession" ), aReason );

   329 	_DBG_FILE("CNSmlDMHostSession::PanicClient(): end");

   330 	}

   331 	

   332 // ------------------------------------------------------------------------------------------------

   333 // CNSmlDMHostSession::CloseSessionL

   334 //	Empty function.

   335 //	Kept here for possible future needs. 

   336 //	Freeing of resources is done in the destructor.

   337 // ------------------------------------------------------------------------------------------------

   338 //

   339 void CNSmlDMHostSession::CloseSessionL() const

   340 	{

   341 	_DBG_FILE("CNSmlDMHostSession::CloseSessionL(): begin");

   342 	_DBG_FILE("CNSmlDMHostSession::CloseSessionL(): end");

   343 	}

   344 

   345 void CNSmlDMHostSession::MarkGenAlertsSentL(const RMessage2& aMessage)

   346 	{

   347 

   348 	_DBG_FILE("CNSmlDMHostSession::MarkGenAlertsSentL(RMessage2): begin");

   349 	

   350 	HBufC8* tempPtr = HBufC8::NewLC(aMessage.GetDesLength(0));

   351 	_DBG_FILE("CNSmlDMHostSession::MarkGenAlertsSentL(RMessage2): crating hBufC for length of URI ");

   352 	TPtr8 uRI = tempPtr->Des();

   353    _DBG_FILE("CNSmlDMHostSession::MarkGenAlertsSentL(RMessage2): TPrt got from HBufC ");

   354 	aMessage.ReadL(0, uRI, 0);

   355 	TUint32 adId(0);

   356 	TNSmlDmDDFFormat nodeType;

   357 	_DBG_FILE("CNSmlDMHostSession::MarkGenAlertsSentL(RMessage2): Before calling adapterIdFromUriL  ");

   358 	TBool adapterFound = AdapterIdFromUriL ( uRI, adId, nodeType );

   359 	

   360 	_LIT8(KSCOMONODE, "SCOMO");

   361 	

   362 	// For AM Adapter check for Node "SCOMO" if present in Uri then use Adapter Implementation UID

   363 	

   364 	if(uRI.Compare(KSCOMONODE) == KErrNone)

   365 	{

   366 		adId = KNSmlDMAMAdapterImplUid;

   367 		adapterFound = ETrue;

   368 	}

   369 	

   370 	

   371 	_DBG_FILE("CNSmlDMHostSession::MarkGenAlertsSentL(RMessage2): After calling adapterIdFromUriL ");

   372 	

   373 	if ( adapterFound )

   374 		{

   375 	_DBG_FILE("CNSmlDMHostSession::MarkGenAlertsSentL(RMessage2): adapter is found ! ");	  

   376 	

   377         CSmlDmAdapter* adapter = NULL;

   378         adapterFound = EFalse;

   379 	    for ( TInt i(0); i<iAdapters.Count(); i++ )

   380 		{

   381 		

   382 		if ( iAdapters[i].adapterId == adId )

   383 			{

   384 			adapterFound = ETrue;

   385 			if ( !iAdapters[i].adapterPtr )

   386 				{

   387 				adapter = LoadNewAdapterL ( i, adId );

   388 				if ( !adapter )

   389 					{

   390 					User::Leave ( KErrArgument );

   391 					}

   392 				}

   393 			// Call overloaded function of the  adapter to request

   394 			// the  adapter to mark Generic Alerts sent.

   395 		

   396 			TInt resetGenAlerts ( KNSmlDMResetGenAlerts );

   397 			iAdapters[i].adapterPtr->StreamingSupport ( resetGenAlerts );

   398 		

   399 			}

   400 		}

   401 	}

   402 	CleanupStack::PopAndDestroy(); //tempPtr

   403 	if ( !adapterFound )

   404 	    {

   405 	    _DBG_FILE("CNSmlDMHostSession::MarkGenAlertsSentL(RMessage2): adapter NOT :-( found ! ");	  

   406 		User::Leave ( KErrNotFound );	    

   407 	    }

   408 	_DBG_FILE("CNSmlDMHostSession::MarkGenAlertsSentL(): end");

   409 	}

   410 

   411 // FOTA

   412 // ------------------------------------------------------------------------------------------------

   413 // CNSmlDMHostSession::MarkGenAlertsSentL

   414 //	This function is called only for the FOTA adapter.

   415 //	Makes a request for the FOTA adapter to mark generic alerts sent.

   416 //	In other words, the written generic alerts are issued without

   417 //	errors to the remote server.

   418 // ------------------------------------------------------------------------------------------------

   419 //

   420 void CNSmlDMHostSession::MarkGenAlertsSentL()

   421 	{

   422 	_DBG_FILE("CNSmlDMHostSession::MarkGenAlertsSentL(): begin");

   423 	CSmlDmAdapter* adapter = NULL;

   424 	TBool adapterFound ( EFalse );

   425 	for ( TInt i(0); i<iAdapters.Count(); i++ )

   426 		{

   427 		if ( iAdapters[i].adapterId == KNSmlDMFotaAdapterImplUid )

   428 			{

   429 			adapterFound = ETrue;

   430 			if ( !iAdapters[i].adapterPtr )

   431 				{

   432 				adapter = LoadNewAdapterL ( i, KNSmlDMFotaAdapterImplUid );

   433 				if ( !adapter )

   434 					{

   435 					User::Leave ( KErrArgument );

   436 					}

   437 				}

   438 			// Call overloaded function of the FOTA adapter to request

   439 			// the FOTA adapter to mark Generic Alerts sent.

   440 			TInt resetGenAlerts ( KNSmlDMResetGenAlerts );

   441 			iAdapters[i].adapterPtr->StreamingSupport ( resetGenAlerts );

   442 			}

   443 		else if ( iAdapters[i].adapterId == KNSmlDMAMAdapterImplUid )

   444 			{

   445 			adapterFound = ETrue;

   446 			if ( !iAdapters[i].adapterPtr )

   447 				{

   448 				adapter = LoadNewAdapterL ( i, KNSmlDMAMAdapterImplUid );

   449 				if ( !adapter )

   450 					{

   451 					User::Leave ( KErrArgument );

   452 					}

   453 				}

   454 			// Call overloaded function of the AM adapter to request

   455 			// the AM adapter to mark Generic Alerts sent.

   456 			TInt resetGenAlerts ( KNSmlDMResetGenAlerts );

   457 			iAdapters[i].adapterPtr->StreamingSupport ( resetGenAlerts );

   458 			}

   459 		

   460 			

   461 		}

   462 	if ( !adapterFound )

   463 	    {

   464 		User::Leave ( KErrNotFound );	    

   465 	    }

   466 	_DBG_FILE("CNSmlDMHostSession::MarkGenAlertsSentL(): end");

   467 	}

   468 // FOTA end

   469 

   470 // ------------------------------------------------------------------------------------------------

   471 // CNSmlDMHostSession::GetDDFStructureL

   472 //	Gets DDF structure from the dm adapters.

   473 //	aMessage parameter contains a list of adapters which are already loaded.

   474 //	Writes the combined DDF structure to the chunk in the WBXML format.

   475 //	Returns also a checksum of the DDF structure to the client. 

   476 //	@param aMessage. A list of already loaded adapters, and place for checksum.

   477 // ------------------------------------------------------------------------------------------------

   478 //

   479 void CNSmlDMHostSession::GetDDFStructureL ( const RMessage2& aMessage )

   480 	{

   481 	_DBG_FILE("CNSmlDMHostSession::GetDDFStructureL(): begin");

   482 	RImplInfoPtrArray allDmAdapters;

   483 	CleanupStack::PushL ( PtrArrCleanupItemRArr ( CImplementationInformation, &allDmAdapters ) );

   484 

   485 	RArray<TUint32> dontLoadThese;

   486 	CleanupClosePushL ( dontLoadThese );

   487 	ReadUidsL ( aMessage, dontLoadThese );

   488 		

   489 	TUid ifUid = { KSmlDMInterfaceUid };

   490 	REComSession::ListImplementationsL ( ifUid, allDmAdapters );

   491 	RemoveAlreadyLoadedL ( allDmAdapters, dontLoadThese );

   492 	CleanupStack::PopAndDestroy();  // dontLoadThese

   493 

   494 	RPointerArray<HBufC8> versions;

   495 	CleanupStack::PushL ( PtrArrCleanupItemRArr ( HBufC8, &versions ) );

   496 	RArray<TInt32> uids;

   497 	CleanupClosePushL ( uids );

   498 	

   499 	CSmlDmAdapter* adapter = NULL;

   500 	for ( TInt i=0; i<allDmAdapters.Count(); i++ )

   501 		{

   502 		TRAPD ( err, ( adapter = CSmlDmAdapter::NewL ( allDmAdapters[i]->ImplementationUid(), *this ) ) );

   503 		if ( err == KErrNone && adapter )

   504 			{

   505 			CleanupStack::PushL(adapter);

   506 			AskInfoFromAdapterL ( adapter, versions, uids, allDmAdapters[i]->ImplementationUid().iUid );		

   507 			CleanupStack::PopAndDestroy(); //adapter

   508 			}

   509 		} 

   510 	TUint16 crc = CalcCheckSumL ( versions, uids );

   511 	CleanupStack::PopAndDestroy(3); // uids, versions, allDmAdapters

   512 	WriteTreeToChunkL();

   513 	aMessage.WriteL ( 2, TPckgBuf<TInt> (crc) );

   514 	TPckgBuf<TInt> cb = ( iCallbackList.Count() ) ? iCallbackList[0].callBack : ENSmlDmCallbackNone;

   515 	aMessage.WriteL ( 3, cb );	

   516 	_DBG_FILE("CNSmlDMHostSession::GetDDFStructureL(): end");

   517 	}

   518 

   519 

   520 // ------------------------------------------------------------------------------------------------

   521 // CNSmlDMHostSession::ReadUidsL

   522 //	Auxiliary function called by GetDDFStructureL.

   523 //	Reads the UIDs of the loaded adapters from the message, 

   524 //	and stores those to internal list. 

   525 //	@param aMessage. An object which encapsulates a client request.

   526 //	@param aUids. A reference parameter, a place for extracted list of UIDs.

   527 // ------------------------------------------------------------------------------------------------

   528 //

   529 void CNSmlDMHostSession::ReadUidsL ( const RMessage2& aMessage, RArray<TUint32>& aUids ) const

   530 	{

   531 	_DBG_FILE("CNSmlDMHostSession::ReadUidsL(): begin");

   532 	HBufC8* buffer = HBufC8::NewLC ( aMessage.GetDesLengthL(0) );

   533     TPtr8 bufPtr = buffer->Des();

   534     aMessage.ReadL ( 0, bufPtr, 0 );

   535     

   536     RDesReadStream readStream;

   537 	readStream.Open ( *buffer );

   538 	CleanupClosePushL ( readStream );

   539 	TUint8 nOfuids = readStream.ReadUint8L();

   540     	

   541 	for ( TInt i=0; i<nOfuids; i++ )

   542 		{

   543 		TUint32 uidTemp = readStream.ReadUint32L();

   544 		aUids.Append ( uidTemp );		

   545 		}

   546 	

   547 	CleanupStack::PopAndDestroy(2); // readStream, buffer

   548 	_DBG_FILE("CNSmlDMHostSession::ReadUidsL(): end");

   549 	}

   550 

   551 // ------------------------------------------------------------------------------------------------

   552 // CNSmlDMHostSession::RemoveAlreadyLoadedL

   553 //	Auxiliary function called by GetDDFStructureL.

   554 //	Gets a list of all the potential dm adapters.

   555 //	Removes from it those which are alreay loaded.  

   556 //	@param aAllAds. A reference parameter, after this function call 

   557 //	                contains the acceptable adapters.

   558 //	@param aUids. A list of adapters which are already loaded.

   559 // ------------------------------------------------------------------------------------------------

   560 //

   561 void CNSmlDMHostSession::RemoveAlreadyLoadedL ( RImplInfoPtrArray& aAllAds, RArray<TUint32>& aUids ) const

   562 	{

   563 	_DBG_FILE("CNSmlDMHostSession::RemoveAlreadyLoadedL(): begin");

   564 	for ( TInt i=0; i<aAllAds.Count(); i++ )

   565 		{

   566 		for ( TInt u=0; u<aUids.Count(); u++ )

   567 			{

   568 			if ( aUids[u] == (TUint32)aAllAds[i]->ImplementationUid().iUid )

   569 				{

   570 				delete aAllAds[i];

   571 				aAllAds[i] = NULL;

   572 				aAllAds.Remove(i);

   573 				i--;

   574 				break;								

   575 				}

   576 			}

   577 		}

   578 	_DBG_FILE("CNSmlDMHostSession::RemoveAlreadyLoadedL(): end");

   579 	}

   580 

   581 // ------------------------------------------------------------------------------------------------

   582 // CNSmlDMHostSession::AskInfoFromAdapterL

   583 //	Auxiliary function called by GetDDFStructureL.

   584 //	Asks initial information from the loaded dm adapter.

   585 //	E.g. whether the adapter supports streaming or not.

   586 //	@param aAdapter. A pointer to the just loaded dm plug-in adapter. 

   587 //	@param aVersions. A list of DDF versions collected from the adapters. 

   588 //	@param aUids. A list of adapter UIDs. Note that aVersions and aUids

   589 //	              are always ordered to ascending order in order to prevent

   590 //	              a checksum to change value if ECom framework gives a list

   591 //	    	      of potential plug-in adapters in different order.

   592 //	@param aAdapterId. Identifier of the dm plug-in adapter.

   593 // ------------------------------------------------------------------------------------------------

   594 //

   595 void CNSmlDMHostSession::AskInfoFromAdapterL ( CSmlDmAdapter* aAdapter, RPointerArray<HBufC8>& aVersions, 

   596 												RArray<TInt32>& aUids, TInt32 aAdapterId )

   597 	{

   598 	_DBG_FILE("CNSmlDMHostSession::AskInfoFromAdapterL(): begin");

   599 	TNSmlDmAdapter newElement;

   600 	newElement.adapterPtr = NULL;

   601 	newElement.adapterId = aAdapterId;

   602 	newElement.startAtomicCalled = EFalse;

   603 	newElement.commandsCalled = EFalse;

   604 	TInt limit ( KNSmlDmNotSupported );

   605 	newElement.streamingLimit = ( aAdapter->StreamingSupport ( limit ) ) ? limit : KNSmlDmNotSupported;	

   606 	iAdapters.Append ( newElement );

   607 

   608 	CBufBase* version = CBufFlat::NewL(16);

   609 	CleanupStack::PushL ( version );

   610 	aAdapter->DDFVersionL ( *version );

   611 	HBufC8* versionHBufC = HBufC8::NewLC ( version->Size() );

   612 	*versionHBufC = version->Ptr(0);

   613 	TInt j=0;

   614 	// Sort uids and versions to ascending order in arrays

   615 	while ( j<aUids.Count() &&  aAdapterId < aUids[j] )  

   616 		{

   617 		j++;

   618 		}

   619 	aUids.InsertL ( aAdapterId, j );

   620 	aVersions.InsertL ( versionHBufC, j );

   621 	CleanupStack::Pop(); //versionHBufC

   622 	CleanupStack::PopAndDestroy(); //version

   623 		

   624 	aAdapter->DDFStructureL ( *iMgmtTree );

   625 	iMgmtTree->SetAdapterUid ( aAdapterId );

   626 

   627 	_DBG_FILE("CNSmlDMHostSession::AskInfoFromAdapterL(): end");

   628 	}

   629 

   630 // ------------------------------------------------------------------------------------------------

   631 // CNSmlDMHostSession::WriteTreeToChunkL

   632 //	Auxiliary function called by GetDDFStructureL.

   633 //	Writes a combined DDF stucture to the chunk using DM Utils services.

   634 // ------------------------------------------------------------------------------------------------

   635 //

   636 void CNSmlDMHostSession::WriteTreeToChunkL()

   637 	{

   638 	_DBG_FILE("CNSmlDMHostSession::WriteTreeToChunkL(): begin");

   639 	CBufBase* buffer = CBufFlat::NewL ( 64 );

   640 	CleanupStack::PushL ( buffer );

   641 

   642 	RBufWriteStream writeStream ( *buffer );

   643 	CleanupClosePushL ( writeStream );

   644 	iMgmtTree->GenerateWBXMLL ( writeStream );

   645 	CleanupStack::PopAndDestroy();  // writeStream

   646 

   647 	RBufReadStream readStream ( *buffer );

   648 	CleanupClosePushL ( readStream );

   649 	iChunk.Adjust ( buffer->Size() );

   650 

   651 	RMemWriteStream chunkStream ( iChunk.Base(), iChunk.Size() );

   652 	CleanupClosePushL ( chunkStream );

   653 	chunkStream.WriteL ( readStream );

   654 	CleanupStack::PopAndDestroy(3);  // chunkStream, readStream, buffer

   655 	_DBG_FILE("CNSmlDMHostSession::WriteTreeToChunkL(): end");

   656 	}

   657 

   658 

   659 // ------------------------------------------------------------------------------------------------

   660 // CNSmlDMHostSession::CalcCheckSumL

   661 //	Auxiliary function called by GetDDFStructureL.

   662 //	Calculates a CCITT CRC checksum from the collected DDF versions and adapter UIDs 

   663 //	@param aVersions. A collected list from adapters containing versions of the DDF structure. 

   664 //	@param aUids. A list of adapter UIDs. 

   665 //	@return TUint16. Calculated checksum value.

   666 // ------------------------------------------------------------------------------------------------

   667 //

   668 TUint16 CNSmlDMHostSession::CalcCheckSumL ( RPointerArray<HBufC8>& aVersions, RArray<TInt32>& aUids ) const

   669 	{

   670 	_DBG_FILE("CNSmlDMHostSession::CalcCheckSumL(): begin");

   671 	TUint16 crc(0);	

   672 	CBufBase* checkData = CBufFlat::NewL(32);

   673 	CleanupStack::PushL(checkData);

   674 	for ( TInt i(0); i<aUids.Count(); i++ )

   675 		{

   676 		checkData->InsertL ( checkData->Size(), aVersions[i]->Des() );

   677 		checkData->InsertL ( checkData->Size(), &aUids[i], sizeof ( aUids[i] ) );

   678 		}

   679 	Mem::Crc ( crc, checkData->Ptr(0).Ptr(), checkData->Size() );

   680 	CleanupStack::PopAndDestroy(); //checkData

   681 	_DBG_FILE("CNSmlDMHostSession::CalcCheckSumL(): end");

   682 	return crc;

   683 	}

   684 

   685 // ------------------------------------------------------------------------------------------------

   686 // CNSmlDMHostSession::UpdateLeafOrExecuteL

   687 //	Common function for handling UpdateLeafObject and Execute DM commands.

   688 //	Reads parameters from the chunk.

   689 //	Loads the requested adapter if this is a first command to it in this session.

   690 //	Checks the need to inform adapter at atomic command situation.

   691 //	Decides whether or not use streaming for passing data to dm plug-in adapter.

   692 //	Informs the client (DM Tree Module) if there are unread statuses, results or mappings.

   693 //	@param aMessage. An object which encapsulates a client request. 

   694 //	@param aCommand. Needed to choose between Update and Execute commands. 

   695 // ------------------------------------------------------------------------------------------------

   696 //

   697 void CNSmlDMHostSession::UpdateLeafOrExecuteL ( const RMessage2& aMessage, TNSmlDmHostOperationCodes aCommand )

   698 	{

   699 	_DBG_FILE("CNSmlDMHostSession::UpdateLeafOrExecuteL(): begin");

   700 	ReadCmdParamsL ( aMessage );

   701 	CSmlDmAdapter* adapter = NULL;

   702 	for ( TInt i=0; i<iAdapters.Count(); i++ )

   703 		{

   704 		if ( iAdapters[i].adapterId == iAdapterId )

   705 			{

   706 			if ( !iAdapters[i].adapterPtr )

   707 				{

   708 				adapter = LoadNewAdapterL ( i, iAdapterId );

   709 				if ( !adapter )

   710 					{

   711 					User::Leave ( KErrArgument );					

   712 					}

   713 				}

   714 			if ( iStartAtomic && !iAdapters[i].startAtomicCalled )

   715 				{

   716 				iAdapters[i].startAtomicCalled = ETrue;

   717 				iAdapters[i].adapterPtr->StartAtomicL();

   718 				}				

   719 			if ( iAdapters[i].streamingLimit == KNSmlDmNotSupported || iData->Size() < iAdapters[i].streamingLimit )

   720 				{

   721 				CallAdapterCommandL ( aCommand, i );

   722 				}

   723 			else 

   724 				{

   725 				RWriteStream* writeStream = NULL;

   726 				// FOTA

   727 				if ( iAdapterId == KNSmlDMFotaAdapterImplUid && aCommand == ENSmlDMUpdateLeaf )

   728 					{

   729 					// Call overloaded function of the FOTA adapter to tell the 

   730 					// total size of incoming large object.

   731 					TInt sizeOfData ( iData->Size() );

   732 					iAdapters[i].adapterPtr->StreamingSupport ( sizeOfData );

   733 					if ( sizeOfData == KErrNoMemory )

   734 						{

   735 						User::Leave ( KErrTooBig );						

   736 						}

   737 					}

   738 				// FOTA end

   739 				CallAdapterCommandL ( aCommand, i, writeStream );

   740 				if ( !writeStream )

   741 					{

   742 					User::Leave ( KErrGeneral );						

   743 					}

   744 				writeStream->WriteL ( *iData );

   745 				writeStream->Close();

   746 				iAdapters[i].adapterPtr->StreamCommittedL();

   747 				}

   748 			TPckgBuf<TInt> cb = ( iCallbackList.Count() ) ? iCallbackList[0].callBack : ENSmlDmCallbackNone;

   749 			aMessage.WriteL ( 3, cb );				

   750 			return;

   751 			}

   752 		}

   753 	User::Leave ( KErrArgument );

   754 	_DBG_FILE("CNSmlDMHostSession::UpdateLeafOrExecuteL(): end");

   755 	}

   756 

   757 // ------------------------------------------------------------------------------------------------

   758 // CNSmlDMHostSession::UpdateLeafOrExecuteLargeL

   759 //	Common function for handling UpdateLeafObject and Execute DM commands for large objects.

   760 //	Reads parameters from the chunk.

   761 //	Loads the requested adapter if this is a first command to it in this session.

   762 //	Checks the need to inform adapter at atomic command situation.

   763 //	Decides whether or not use streaming for passing data to dm plug-in adapter.

   764 //	In case this is last package of the large object, closes and commits stream,

   765 //	provided streaming was used for passing a data.

   766 //	Informs the client (DM Tree Module) if there are unread statuses, results or mappings.

   767 //	@param aMessage. An object which encapsulates a client request. 

   768 //	@param aCommand. Needed to choose between Update and Execute commands. 

   769 // ------------------------------------------------------------------------------------------------

   770 //

   771 void CNSmlDMHostSession::UpdateLeafOrExecuteLargeL ( const RMessage2& aMessage, TNSmlDmHostOperationCodes aCommand )

   772 	{

   773 	_DBG_FILE("CNSmlDMHostSession::UpdateLeafOrExecuteLargeL(): begin");

   774 	ReadCmdParamsL ( aMessage );

   775 	CSmlDmAdapter* adapter = NULL;

   776 	for ( TInt i=0; i<iAdapters.Count(); i++ )

   777 		{

   778 		if ( iAdapters[i].adapterId == iAdapterId )

   779 			{

   780 			if ( !iAdapters[i].adapterPtr )

   781 				{

   782 				adapter = LoadNewAdapterL ( i, iAdapterId );

   783 				if ( !adapter )

   784 					{

   785 					User::Leave ( KErrArgument );								

   786 					}

   787 				}

   788 			if ( iStartAtomic && !iAdapters[i].startAtomicCalled )

   789 				{

   790 				iAdapters[i].startAtomicCalled = ETrue;

   791 				iAdapters[i].adapterPtr->StartAtomicL();

   792 				}				

   793 			if ( iAdapters[i].streamingLimit != KNSmlDmNotSupported )

   794 				{

   795 				CheckIfCorrectAdapterL();

   796 				if ( !iLargeWriteStream.streamPtr )

   797 					{

   798 					// FOTA

   799 					if ( iAdapterId == KNSmlDMFotaAdapterImplUid && aCommand == ENSmlDMUpdateLeafLarge )

   800 						{

   801 						// Call overloaded function of the FOTA adapter to tell the 

   802 						// total size of incoming large object.

   803 						// Note that in this context the third parameter holds the size

   804 						// information. Otherwise it contains the 'last package' information.

   805 						TInt totSizeOfLarge ( aMessage.Int2() );

   806 						iAdapters[i].adapterPtr->StreamingSupport ( totSizeOfLarge );

   807 						if ( totSizeOfLarge == KErrNoMemory )

   808 							{

   809 							User::Leave ( KErrTooBig );						

   810 							}

   811 						}					

   812 					// FOTA end

   813 					iLargeWriteStream.adapterId = iAdapterId;

   814 					CallAdapterCommandL ( aCommand, i, iLargeWriteStream.streamPtr );

   815 					if ( !iLargeWriteStream.streamPtr )

   816 						{

   817 						User::Leave ( KErrGeneral );						

   818 						}

   819 					iCommitStatus.iStreamingOngoing=ETrue;

   820 					iCommitStatus.iOldStatusRef = iStatusRef;

   821 					}

   822 				iLargeWriteStream.streamPtr->WriteL ( *iData );

   823 				iCommitStatus.iNewStatusRef = iStatusRef;

   824 				// FOTA

   825 				if ( aMessage.Int2() == KNSmlDmLastPackage )  //  Last package (TBool)

   826 				// FOTA end

   827 					{

   828 					iLargeWriteStream.streamPtr->Close();

   829 					iLargeWriteStream.streamPtr = NULL;									

   830 					iCommitStatus.iStreamCommitted = ETrue;

   831 					iAdapters[i].adapterPtr->StreamCommittedL();

   832 				    iCommitStatus.iStreamCommitted=EFalse;

   833         		    iCommitStatus.iStreamingOngoing=EFalse;

   834 					}

   835 				TPckgBuf<TInt> cb = ( iCallbackList.Count() ) ? iCallbackList[0].callBack : ENSmlDmCallbackNone;

   836 				aMessage.WriteL ( 3, cb );

   837 				}

   838 			else 

   839 				{

   840 				UpdateOrExecuteLargeNoStreamL ( aMessage, i, aCommand );

   841 				}

   842 			return;

   843 			}

   844 		}

   845 	User::Leave ( KErrArgument );

   846 	_DBG_FILE("CNSmlDMHostSession::UpdateLeafOrExecuteLargeL(): end");

   847 	}

   848 

   849 // ------------------------------------------------------------------------------------------------

   850 // CNSmlDMHostSession::UpdateOrExecuteLargeNoStreamL

   851 //	Auxiliary function of UpdateLeafOrExecuteLargeL.

   852 //	Provided the dm plug-in adapter doesn't support streaming, this function

   853 //	takes care of appending large object piece by piece.

   854 //	When the last package arrives, calls the adapter and gives the built-up 

   855 //	large object as a parameter.

   856 //	@param aMessage. An object which encapsulates a client request. 

   857 //	@param aAdIndex. Identifies the assigned adapter. 

   858 //	@param aCommand. Needed to choose between Update and Execute commands. 

   859 // ------------------------------------------------------------------------------------------------

   860 //

   861 void CNSmlDMHostSession::UpdateOrExecuteLargeNoStreamL ( const RMessage2& aMessage, TInt aAdIndex, TNSmlDmHostOperationCodes aCommand )

   862 	{

   863 	_DBG_FILE("CNSmlDMHostSession::UpdateOrExecuteLargeNoStreamL(): begin");

   864 

   865 	if ( !iLargeObject )

   866 		{

   867 		iLargeObject = HBufC8::NewL(0);

   868 		}

   869 	iLargeObject = iLargeObject->ReAllocL ( iLargeObject->Length() + iData->Length() );

   870 	TPtr8 tmpPtr = iLargeObject->Des();	

   871 	tmpPtr.Append ( *iData );

   872 	

   873 	if ( aMessage.Int2() )  //  Last package (TBool)

   874 		{					

   875 		CallAdapterCommandL ( aCommand, aAdIndex, ETrue );

   876 		delete iLargeObject;

   877 		iLargeObject = NULL;

   878 		}		

   879 	_DBG_FILE("CNSmlDMHostSession::UpdateOrExecuteLargeNoStreamL(): end");

   880 	}

   881 

   882 // ------------------------------------------------------------------------------------------------

   883 // CNSmlDMHostSession::AddCopyOrDeleteL

   884 //	Common function for handling Add Interior Node, Copy Node, or Delete Object DM commands.

   885 //	Reads parameters from the chunk.

   886 //	Loads the requested adapter if this is a first command to it in this session.

   887 //	Checks the need to inform adapter at atomic command situation.

   888 //	Informs the client (DM Tree Module) if there are unread statuses, results or mappings.

   889 //	@param aMessage. An object which encapsulates a client request. 

   890 //	@param aCommand. Needed to choose between Add, Copy, and Delete commands. 

   891 // ------------------------------------------------------------------------------------------------

   892 //

   893 void CNSmlDMHostSession::AddCopyOrDeleteL ( const RMessage2& aMessage, TNSmlDmHostOperationCodes aCommand )

   894 	{

   895 	_DBG_FILE("CNSmlDMHostSession::AddCopyOrDeleteL(): begin");

   896 	

   897 	if ( aCommand == ENSmlDMCopy )

   898 		{

   899 		ReadCopyCmdParamsL ( aMessage );			

   900 		}

   901 	else

   902 		{

   903 		ReadCmdParamsL ( aMessage );		

   904 		}

   905 	CSmlDmAdapter* adapter = NULL;

   906 	for ( TInt i=0; i<iAdapters.Count(); i++ )

   907 		{

   908 		if ( iAdapters[i].adapterId == iAdapterId )

   909 			{

   910 			if ( !iAdapters[i].adapterPtr )

   911 				{

   912 				adapter = LoadNewAdapterL ( i, iAdapterId );

   913 				if ( !adapter )

   914 					{

   915 					User::Leave ( KErrArgument );					

   916 					}

   917 				}

   918 			if ( iStartAtomic && !iAdapters[i].startAtomicCalled )

   919 				{

   920 				iAdapters[i].startAtomicCalled = ETrue;

   921 				iAdapters[i].adapterPtr->StartAtomicL();

   922 				}				

   923 			CallAdapterCommandL ( aCommand, i );

   924 			TPckgBuf<TInt> cb = ( iCallbackList.Count() ) ? iCallbackList[0].callBack : ENSmlDmCallbackNone;

   925 			aMessage.WriteL ( 3, cb );		

   926 			return;

   927 			}

   928 		}

   929 	User::Leave ( KErrArgument );

   930 	_DBG_FILE("CNSmlDMHostSession::AddCopyOrDeleteL(): end");

   931 	}

   932 

   933 // ------------------------------------------------------------------------------------------------

   934 // CNSmlDMHostSession::FetchLeafChildUrisOrSizeL

   935 //	Common function for handling Fetch Leaf Object, Get Child URI List, or Fetch Leaf Object Size 

   936 //	DM commands.

   937 //	Reads parameters from the chunk.

   938 //	Loads the requested adapter if this is a first command to it in this session.

   939 //	Checks the need to inform adapter at atomic command situation.

   940 //	Informs the client (DM Tree Module) if there are unread statuses, results or mappings.

   941 //	@param aMessage. An object which encapsulates a client request. 

   942 //	@param aCommand. Needed to choose between Fetch, Get Child URI List, and Fetch Size commands. 

   943 // ------------------------------------------------------------------------------------------------

   944 //

   945 void CNSmlDMHostSession::FetchLeafChildUrisOrSizeL ( const RMessage2& aMessage,  TNSmlDmHostOperationCodes aCommand )

   946 	{

   947 	_DBG_FILE("CNSmlDMHostSession::FetchLeafChildUrisOrSizeL(): begin");

   948 	RPointerArray<HBufC8> prevLuids;

   949 	CleanupStack::PushL ( PtrArrCleanupItemRArr ( HBufC8, &prevLuids ) );

   950 	ReadCmdFetchParamsL ( aMessage, prevLuids );

   951 	CSmlDmAdapter* adapter = NULL;

   952 	for ( TInt i=0; i<iAdapters.Count(); i++ )

   953 		{

   954 		if ( iAdapters[i].adapterId == iAdapterId )

   955 			{

   956 			if ( !iAdapters[i].adapterPtr )

   957 				{

   958 				adapter = LoadNewAdapterL ( i, iAdapterId );

   959 				if ( !adapter )

   960 					{

   961 					CleanupStack::PopAndDestroy();  // prevLuids

   962 					User::Leave ( KErrArgument );

   963 					}

   964 				}

   965 			if ( iStartAtomic && !iAdapters[i].startAtomicCalled )

   966 				{

   967 				iAdapters[i].startAtomicCalled = ETrue;

   968 				iAdapters[i].adapterPtr->StartAtomicL();

   969 				}

   970 			CallAdapterCommandL ( aCommand, i );

   971 			CleanupStack::PopAndDestroy();  // prevLuids					

   972 			TPckgBuf<TInt> cb = ( iCallbackList.Count() ) ? iCallbackList[0].callBack : ENSmlDmCallbackNone;

   973 			aMessage.WriteL ( 3, cb );

   974 			return;

   975 			}

   976 		}

   977 	CleanupStack::PopAndDestroy();  // prevLuids			

   978 	User::Leave ( KErrNotFound );

   979 	_DBG_FILE("CNSmlDMHostSession::FetchLeafChildUrisOrSizeL(): end");

   980 	}

   981 

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

   983 // CNSmlDMHostSession::FetchLinkL

   984 //	Called only from other DM Host Servers when they need to cross-reference AP -adapter. 

   985 //	Loads the AP dm plug in adapter (i.e. Internet adapter).

   986 //	Asks the DDF structure from the AP adapter.

   987 //	Checks that the given URI is found from the DDF structure.

   988 //	If the above actions are successful, calls the Fetch Leaf Object or Get Child URI List 

   989 //	commands of AP adapter.

   990 //	Writes the returned result to the chunk.

   991 //	@param aMessage. An object which encapsulates a client (other DM Host Server in this case) request. 

   992 // ------------------------------------------------------------------------------------------------

   993 //

   994 void CNSmlDMHostSession::FetchLinkL ( const RMessage2& aMessage )

   995 	{

   996 	_DBG_FILE("CNSmlDMHostSession::FetchLinkL(): begin");

   997 	

   998 	RPointerArray<HBufC8> versions;

   999 	CleanupStack::PushL ( PtrArrCleanupItemRArr ( HBufC8, &versions ) );

  1000 	RArray<TInt32> uids;

  1001 	CleanupClosePushL ( uids );

  1002 	

  1003 	CSmlDmAdapter* adapter = NULL;

  1004 	TUid uid = { GetAccessPointImplUid() };

  1005 	

  1006 	adapter = CSmlDmAdapter::NewL ( uid, *this );

  1007 	CleanupStack::PushL(adapter);

  1008 	AskInfoFromAdapterL ( adapter, versions, uids, uid.iUid );		

  1009 	CleanupStack::PopAndDestroy(3); // adapter, uids, versions 

  1010 	

  1011 	HBufC8* uri = HBufC8::NewLC ( aMessage.GetDesLengthL(0) );

  1012     TPtr8 uriPtr = uri->Des();

  1013     aMessage.ReadL ( 0, uriPtr, 0 );    

  1014 	

  1015 	CBufBase* buf = CBufFlat::NewL ( 16 );

  1016 	CleanupStack::PushL ( buf );

  1017 	MSmlDmAdapter::TError status = MSmlDmAdapter::EOk;

  1018 

  1019 	TUint32 adId(0);

  1020 	TNSmlDmDDFFormat nodeType;

  1021 	TBool adapterFound = AdapterIdFromUriL ( *uri, adId, nodeType );

  1022 	if ( adapterFound )

  1023 		{

  1024 		FetchLinkFromAdapterL ( *uri, adId, *buf, status, nodeType );

  1025 		}

  1026 	if ( !adapterFound || status != MSmlDmAdapter::EOk )

  1027 		{

  1028 		CleanupStack::PopAndDestroy(2); // buf, uri	

  1029 		User::Leave ( KErrNotFound );

  1030 		}

  1031 	

  1032 	// Write answer

  1033 	iChunk.Adjust ( 2 + buf->Size() );

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

  1035 	CleanupClosePushL ( writeStream );

  1036 	writeStream.WriteUint16L ( buf->Size() );

  1037 	writeStream.WriteL ( buf->Ptr(0) );

  1038 	CleanupStack::PopAndDestroy(3); // writestream, buf, uri

  1039 	_DBG_FILE("CNSmlDMHostSession::FetchLinkL(): end");

  1040 	}

  1041 

  1042 // ------------------------------------------------------------------------------------------------

  1043 // void CNSmlDMHostSession::StartAtomicL()

  1044 //	Sets a general atomic command state. 

  1045 //	When this state is set, StartAtomicL function of the adapters

  1046 //	is called when the first 'normal' command arrives.

  1047 //	In addition informs the client (DM Tree Module) if there are unread statuses, results or mappings.

  1048 //	@param aMessage. An object which encapsulates a client request. 

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

  1050 //

  1051 void CNSmlDMHostSession::StartAtomicL ( const RMessage2& aMessage )

  1052 	{

  1053 	_DBG_FILE("CNSmlDMHostSession::StartAtomicL(): begin");	

  1054 	iStartAtomic = ETrue;

  1055 	TPckgBuf<TInt> cb = ( iCallbackList.Count() ) ? iCallbackList[0].callBack : ENSmlDmCallbackNone;

  1056 	aMessage.WriteL ( 3, cb );

  1057 	_DBG_FILE("CNSmlDMHostSession::StartAtomicL(): end");

  1058 	}

  1059 

  1060 // ------------------------------------------------------------------------------------------------

  1061 // void CNSmlDMHostSession::CommitAtomicL()

  1062 //	Resets the general atomic command state (When atomic commands were successful). 

  1063 //	This command is forwarded only to those adapters which have received StartAtomicL call.

  1064 //	In addition informs the client (DM Tree Module) if there are unread statuses, results or mappings.

  1065 //	@param aMessage. An object which encapsulates a client request. 

  1066 // ------------------------------------------------------------------------------------------------

  1067 //

  1068 void CNSmlDMHostSession::CommitAtomicL ( const RMessage2& aMessage )

  1069 	{

  1070 	_DBG_FILE("CNSmlDMHostSession::CommitAtomicL(): begin");

  1071 	iStartAtomic = EFalse;

  1072 	for ( TInt i=0; i<iAdapters.Count(); i++ )

  1073 		{

  1074 		if ( iAdapters[i].startAtomicCalled && iAdapters[i].adapterPtr )

  1075 			{

  1076 			iAdapters[i].startAtomicCalled = EFalse;	

  1077 			iAdapters[i].adapterPtr->CommitAtomicL();	

  1078 			}

  1079 		}

  1080 	TPckgBuf<TInt> cb = ( iCallbackList.Count() ) ? iCallbackList[0].callBack : ENSmlDmCallbackNone;

  1081 	aMessage.WriteL ( 3, cb );		

  1082 	_DBG_FILE("CNSmlDMHostSession::CommitAtomicL(): end");

  1083 	}

  1084 

  1085 // ------------------------------------------------------------------------------------------------

  1086 // void CNSmlDMHostSession::RollbackAtomicL()

  1087 //	Resets the general atomic command state (When one or more atomic commands failed). 

  1088 //	This command is forwarded only to those adapters which have received StartAtomicL call.

  1089 //	In addition informs the client (DM Tree Module) if there are unread statuses, results or mappings.

  1090 //	@param aMessage. An object which encapsulates a client request. 

  1091 // ------------------------------------------------------------------------------------------------

  1092 //

  1093 void CNSmlDMHostSession::RollbackAtomicL ( const RMessage2& aMessage )

  1094 	{

  1095 	_DBG_FILE("CNSmlDMHostSession::RollbackAtomicL(): begin");

  1096 	iStartAtomic = EFalse;	

  1097 	for ( TInt i=0; i<iAdapters.Count(); i++ )

  1098 		{

  1099 		if ( iAdapters[i].startAtomicCalled && iAdapters[i].adapterPtr )

  1100 			{

  1101 			iAdapters[i].startAtomicCalled = EFalse;	

  1102 			iAdapters[i].adapterPtr->RollbackAtomicL();	

  1103 			}

  1104 		}

  1105 	TPckgBuf<TInt> cb = ( iCallbackList.Count() ) ? iCallbackList[0].callBack : ENSmlDmCallbackNone;

  1106 	aMessage.WriteL ( 3, cb );		

  1107 	_DBG_FILE("CNSmlDMHostSession::RollbackAtomicL(): end");

  1108 	}

  1109 

  1110 // ------------------------------------------------------------------------------------------------

  1111 // void CNSmlDMHostSession::CompleteCommandsL()

  1112 //	Calls CompleteOutstandingCmdsL -function of the DM plug-in adapters.

  1113 //	This command is issued only to those adapters which have received some adapter 

  1114 //	commands during the session.

  1115 //	In addition informs the client (DM Tree Module) if there are unread statuses, results or mappings.

  1116 //	@param aMessage. An object which encapsulates a client request. 

  1117 // ------------------------------------------------------------------------------------------------

  1118 //

  1119 void CNSmlDMHostSession::CompleteCommandsL ( const RMessage2& aMessage )

  1120 	{	

  1121 	_DBG_FILE("CNSmlDMHostSession::CompleteCommandsL(): begin");

  1122 	for ( TInt i=0; i<iAdapters.Count(); i++ )

  1123 		{

  1124 		if ( iAdapters[i].commandsCalled && iAdapters[i].adapterPtr )

  1125 			{

  1126 			iAdapters[i].commandsCalled = EFalse;	

  1127 			iAdapters[i].adapterPtr->CompleteOutstandingCmdsL();

  1128 			}

  1129 		}

  1130 	TPckgBuf<TInt> cb = ( iCallbackList.Count() ) ? iCallbackList[0].callBack : ENSmlDmCallbackNone;

  1131 	aMessage.WriteL ( 3, cb );		

  1132 	_DBG_FILE("CNSmlDMHostSession::CompleteCommandsL(): end");

  1133 	}

  1134