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:  Session for DS host server.

    15 *

    16 */

    17 

    18 

    19 // ------------------------------------------------------------------------------------------------

    20 // Includes

    21 // ------------------------------------------------------------------------------------------------

    22 

    23 #include <s32mem.h>

    24 #include <implementationinformation.h>

    25 #include <ecom.h>

    26 #include <badesca.h>

    27 #include <nsmldebug.h>

    28 #include <SmlDataFormat.h>

    29 

    30 #include "NSmlAdapterLog.h"

    31 #include "nsmldshostconstants.h"

    32 #include "Nsmldshostserver.h"

    33 #include "Nsmldshostsession.h"

    34 #include "nsmldsdpinformation.h"

    35 #include "Nsmldsdataproviderarray.h"

    36 

    37 #ifdef __HOST_SERVER_MTEST__

    38 #include "../../stif/DSHostServerTest/src/fakedataprovider.cpp"

    39 #else

    40 #include <nsmlchangefinder.h>	//for CNSmlDataItemUidSet

    41 #endif

    42 

    43 // ------------------------------------------------------------------------------------------------

    44 // CNSmlDSHostSession::TMemPtr::WriteStreamLC

    45 // ------------------------------------------------------------------------------------------------

    46 RWriteStream& CNSmlDSHostSession::TMemPtr::WriteStreamLC() const

    47     {

    48     RMemWriteStream* writeStream = new ( ELeave ) RMemWriteStream( Ptr(), Size() );

    49     CleanupStack::PushL( TCleanupItem ( CleanupWriteStream, writeStream ) );

    50     return *writeStream;

    51     }

    52 

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

    54 // CNSmlDSHostSession::TMemPtr::StreamBufferLC

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

    56 CNSmlDSHostSession::TMemPtr::TStreamBuffers* 

    57 	CNSmlDSHostSession::TMemPtr::StreamBufferLC() const

    58 	{

    59 	TStreamBuffers* cleanup = new ( ELeave ) TStreamBuffers;

    60 	CleanupStack::PushL( TCleanupItem ( CleanupStreamBuffer, cleanup ) );

    61 	cleanup->iBuffer = CBufFlat::NewL( 64 );

    62 	cleanup->iWrite = new ( ELeave ) RBufWriteStream( *cleanup->iBuffer );

    63 	cleanup->iRead = new ( ELeave ) RBufReadStream( *cleanup->iBuffer );

    64 	return cleanup;

    65 	}

    66 

    67 // ------------------------------------------------------------------------------------------------

    68 // CNSmlDSHostSession::TMemPtr::ReadStreamLC

    69 // ------------------------------------------------------------------------------------------------

    70 RReadStream& CNSmlDSHostSession::TMemPtr::ReadStreamLC() const

    71     {

    72     RMemReadStream* readStream = new ( ELeave ) RMemReadStream( Ptr(), iChunk.Size() );

    73     CleanupStack::PushL( TCleanupItem ( CleanupReadStream, readStream ) );

    74     return *readStream;

    75     }

    76     

    77 // ------------------------------------------------------------------------------------------------

    78 // CNSmlDSHostSession::TMemPtr::AdjustChunkIfNeededL

    79 // ------------------------------------------------------------------------------------------------    

    80 void CNSmlDSHostSession::TMemPtr::AdjustChunkIfNeededL( TInt iNeededSize )

    81 	{

    82 	if ( Size() < iNeededSize )

    83 		{

    84 		User::LeaveIfError( Adjust(iNeededSize) );

    85 		}

    86 	}

    87 

    88 // ------------------------------------------------------------------------------------------------

    89 // CNSmlDSHostSession::TMemPtr::CleanupWriteStream

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

    91 void CNSmlDSHostSession::TMemPtr::CleanupWriteStream( TAny* aP )

    92 	{

    93 	RMemWriteStream* writeStream = reinterpret_cast<RMemWriteStream*>( aP );

    94 	writeStream->Close();

    95 	delete writeStream;

    96 	}

    97 

    98 // ------------------------------------------------------------------------------------------------

    99 // CNSmlDSHostSession::TMemPtr::CleanupReadStream

   100 // ------------------------------------------------------------------------------------------------

   101 void CNSmlDSHostSession::TMemPtr::CleanupReadStream( TAny* aP )

   102 	{

   103 	RMemReadStream* readStream = reinterpret_cast<RMemReadStream*>( aP );

   104 	readStream->Close();

   105 	delete readStream;

   106 	}

   107 

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

   109 // CNSmlDSHostSession::TMemPtr::CleanupStreamBuffer

   110 // ------------------------------------------------------------------------------------------------

   111 void CNSmlDSHostSession::TMemPtr::CleanupStreamBuffer( TAny* aP )

   112 	{

   113 	TStreamBuffers* cleanup = reinterpret_cast<TStreamBuffers*>( aP );

   114 	

   115 	if ( cleanup->iWrite )

   116 		{

   117 		cleanup->iWrite->Close();

   118 		delete cleanup->iWrite;

   119 		}

   120 		

   121 	if ( cleanup->iRead )

   122 		{

   123 		cleanup->iRead->Close();

   124 		delete cleanup->iRead;

   125 		}

   126 	

   127 	delete cleanup->iBuffer;

   128 	delete cleanup;

   129 	}

   130 

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

   132 // CNSmlDSHostSession::TMemPtr::CancelAdjust

   133 // ------------------------------------------------------------------------------------------------	

   134 void CNSmlDSHostSession::TMemPtr::CancelAdjust( TAny* aP )

   135 	{

   136 	if ( aP )

   137 		{

   138 		TMemPtr* memptr = reinterpret_cast<TMemPtr*>( aP );

   139 		memptr->Adjust( KNSmlDSHostChunkMinSize );

   140 		}

   141 	}

   142 	

   143 // ------------------------------------------------------------------------------------------------

   144 // CNSmlDSHostSession::CNSmlServerDSHostItem::NewLC

   145 // ------------------------------------------------------------------------------------------------

   146 CNSmlDSHostSession::CNSmlServerDSHostItem* CNSmlDSHostSession::CNSmlServerDSHostItem::NewLC()

   147 	{

   148 	CNSmlServerDSHostItem* self = new ( ELeave ) CNSmlServerDSHostItem();

   149 	CleanupStack::PushL( self );

   150 	self->ConstructL();

   151 	return self;

   152 	}

   153 	

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

   155 // CNSmlDSHostSession::NewL

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

   157 CNSmlDSHostSession* CNSmlDSHostSession::NewL( CNSmlDSHostServer& aServer )

   158 	{

   159 	_DBG_FILE( "CNSmlDSHostSession::NewL(): begin" );

   160 	CNSmlDSHostSession* self= new ( ELeave ) CNSmlDSHostSession( aServer );

   161 	CleanupStack::PushL( self );

   162 	self->ConstructL();

   163 	CleanupStack::Pop(); // self

   164 	_DBG_FILE( "CNSmlDSHostSession::NewL(): end" );

   165 	return self;

   166 	}

   167 	

   168 // ------------------------------------------------------------------------------------------------

   169 // CNSmlDSHostSession::~CNSmlDSHostSession

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

   171 CNSmlDSHostSession::~CNSmlDSHostSession()

   172 	{

   173 	_DBG_FILE( "CNSmlDSHostSession::~CNSmlDSHostSession(): begin" );

   174     iMemPtr.iChunk.Close();

   175     iDataProviders.ResetAndDestroy();

   176     iStringPool.Close();

   177     REComSession::FinalClose();

   178     iServer.DecSessionCount();

   179 	_DBG_FILE( "CNSmlDSHostSession::~CNSmlDSHostSession(): end" );

   180 	}

   181 

   182 // ------------------------------------------------------------------------------------------------

   183 // CNSmlDSHostSession::ServiceL

   184 // ------------------------------------------------------------------------------------------------

   185 void CNSmlDSHostSession::ServiceL( const RMessage2& aMessage )

   186 	{

   187 	_DBG_FILE( "CNSmlDSHostSession::ServiceL(): begin" );

   188     TBool completeRequest( ETrue );

   189 	TRAPD( err, DispatchMessageL( aMessage, completeRequest ) );

   190 

   191     if ( completeRequest && !aMessage.IsNull() )

   192         {

   193         aMessage.Complete( err );

   194         }

   195 	DBG_FILE_CODE( err, _S8( "CNSmlDSHostSession::ServiceL() returned" ) );

   196 	}

   197 

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

   199 // CNSmlDSHostSession::DispatchMessageL

   200 // ------------------------------------------------------------------------------------------------

   201 void CNSmlDSHostSession::DispatchMessageL( const RMessage2& aMessage, TBool& aCompleteRequest )

   202 	{

   203 	_DBG_FILE( "CNSmlDSHostSession::DispatchMessageL(): begin" );

   204     aCompleteRequest = ETrue;

   205 

   206 	switch( aMessage.Function() )

   207         {

   208 	    case ENSmlDPOpen:

   209 	    	_DBG_FILE("CreateDataProvidersL"); 

   210 	        CreateDataProvidersL( aMessage );

   211 	        break;

   212 	    case ENSmlDPOpenExcept:

   213 	        _DBG_FILE("CreateDataProvidersExceptL"); 

   214 	        CreateDataProvidersExceptL( aMessage );

   215 	        break;

   216 	    case ENSmlDPInformation:

   217 	    	_DBG_FILE("DPInformation"); 

   218 	    	DPInformationL( aMessage );

   219 	    	break;

   220 		case ENSmlHandleChunk:

   221 			_DBG_FILE("HandleChunk"); 

   222 			HandleChunk( aMessage );

   223 	        break;

   224 		case ENSmlDPSupportsOperation:

   225 			_DBG_FILE("SupportsOperationL"); 

   226 	        SupportsOperationL( aMessage );

   227 	        break;

   228 		case ENSmlDPStoreFormat:

   229 			_DBG_FILE("StoreFormatL"); 

   230 	        StoreFormatL( aMessage );

   231 	        break;

   232 		case ENSmlDPlListStores:

   233 	        _DBG_FILE("ListStoresL"); 

   234 	        ListStoresL( aMessage );

   235 	        break;

   236 		case ENSmlDPDefaultStore:

   237 	        _DBG_FILE("DefaultStoreL"); 

   238 	        DefaultStoreL( aMessage );

   239 	        break;

   240 	    case ENSmlServerFilters:

   241 	    	_DBG_FILE("SupportedServerFiltersL"); 

   242 	        SupportedServerFiltersL( aMessage );

   243 	        break;

   244         case ENSmlUpdateServerFilters:

   245         	_DBG_FILE("CheckServerFiltersL");

   246         	CheckServerFiltersL( aMessage );

   247         	break;

   248         case ENSmlCheckSupportedServerFilters:

   249         	_DBG_FILE("CheckSupportedServerFiltersL");

   250         	CheckSupportedServerFiltersL( aMessage );

   251         	break;

   252         case ENSmlFilters:

   253         	_DBG_FILE("GetFiltersL");

   254         	GetFiltersL( aMessage );

   255         	break;

   256 		case ENSmlDSOpen:

   257 	        _DBG_FILE("OpenL"); 

   258 	        OpenL( aMessage ); aCompleteRequest = EFalse;

   259 	        break;

   260 		case ENSmlDSCancelRequest:

   261 	        _DBG_FILE("CancelRequestL"); 

   262 	        CancelRequestL( aMessage );

   263 	        break;

   264 		case ENSmlDSBeginTransaction:

   265 	        _DBG_FILE("BeginTransactionL"); 

   266 	        BeginTransactionL( aMessage );

   267 	        break;

   268 		case ENSmlDSCommitTransaction:

   269 	        _DBG_FILE("CommitTransactionL"); 

   270 	        CommitTransactionL( aMessage ); aCompleteRequest = EFalse;

   271 	        break;

   272 		case ENSmlDSRevertTransaction:

   273 	        _DBG_FILE("RevertTransactionL"); 

   274 	        RevertTransactionL( aMessage ); aCompleteRequest = EFalse;

   275 	        break;

   276 		case ENSmlDSBeginBatch:

   277 	        _DBG_FILE("BeginBatchL"); 

   278 	        BeginBatchL( aMessage );

   279 	        break;

   280 		case ENSmlDSCommitBatch:

   281 	        _DBG_FILE("CommitBatchL"); 

   282 	        CommitBatchL( aMessage ); aCompleteRequest = EFalse;

   283 	        break;

   284 		case ENSmlDSCancelBatch:

   285 	        _DBG_FILE("CancelBatchL"); 

   286 	        CancelBatchL( aMessage );

   287 	        break;

   288 		case ENSmlDSSetDataStoreFormat:

   289 	        _DBG_FILE("SetRemoteDataStoreFormatL"); 

   290 	        SetRemoteDataStoreFormatL( aMessage );

   291 	        break;

   292 		case ENSmlDSRemoteMaxObjSize:

   293 	        _DBG_FILE("SetRemoteMaxObjectSizeL"); 

   294 	        SetRemoteMaxObjectSizeL( aMessage );

   295 	        break;

   296 		case ENSmlMaxObjSize:

   297 	        _DBG_FILE("MaxObjectSizeL"); 

   298 	        MaxObjectSizeL( aMessage );

   299 	        break;

   300 		case ENSmlItemOpen:

   301 	        _DBG_FILE("OpenItemL"); 

   302 	        OpenItemL( aMessage ); aCompleteRequest = EFalse;

   303 	        break;

   304 		case ENSmlItemCreate:

   305 	        _DBG_FILE("CreateItemL"); 

   306 	        CreateItemL( aMessage ); aCompleteRequest = EFalse;

   307 	        break;

   308 		case ENSmlItemReplace:

   309 	        _DBG_FILE("ReplaceItemL"); 

   310 	        ReplaceItemL( aMessage ); aCompleteRequest = EFalse;

   311 	        break;

   312 		case ENSmlItemRead:

   313 	        _DBG_FILE("ReadItemL"); 

   314 	        ReadItemL( aMessage );

   315 	        break;

   316 		case ENSmlItemWrite:

   317 	        _DBG_FILE("WriteItemL"); 

   318 	        WriteItemL( aMessage );

   319 	        break;

   320 		case ENSmlItemCommit:

   321 	        _DBG_FILE("CommitItemL"); 

   322 	        CommitItemL( aMessage ); aCompleteRequest = EFalse;

   323 	        break;

   324 		case ENSmlItemClose:

   325 	        _DBG_FILE("CloseItemL"); 

   326 	        CloseItemL( aMessage );

   327 	        break;

   328 		case ENSmlItemMove:

   329 	        _DBG_FILE("MoveItemL"); 

   330 	        MoveItemL( aMessage ); aCompleteRequest = EFalse;

   331 	        break;

   332 		case ENSmlItemDelete:

   333 	        _DBG_FILE("DeleteItemL"); 

   334 	        DeleteItemL( aMessage ); aCompleteRequest = EFalse;

   335 	        break;

   336 		case ENSmlItemSoftDelete:

   337 	        _DBG_FILE("SoftDeleteItemL"); 

   338 	        SoftDeleteItemL( aMessage ); aCompleteRequest = EFalse;

   339 	        break;

   340 		case ENSmlItemDeleteAll:

   341 	        _DBG_FILE("DeleteAllItemsL"); 

   342 	        DeleteAllItemsL( aMessage ); aCompleteRequest = EFalse;

   343 	        break;

   344 		case ENSmlDSSyncHistory:

   345 	        _DBG_FILE("HasSyncHistoryL"); 

   346 	        HasSyncHistoryL( aMessage );

   347 	        break;

   348 		case ENSmlDSItemsAdded:

   349 	        _DBG_FILE("AddedItemsL"); 

   350 	        AddedItemsL( aMessage );

   351 	        break;

   352 		case ENSmlDSItemsDeleted:

   353 	        _DBG_FILE("DeletedItemsL"); 

   354 	        DeletedItemsL( aMessage );

   355 	        break;

   356 		case ENSmlDSItemsSofDeleted:

   357 	        _DBG_FILE("SoftDeleteItemsL"); 

   358 	        SoftDeleteItemsL( aMessage );

   359 	        break;

   360 		case ENSmlDSItemsModified:

   361 	        _DBG_FILE("ModifiedItemsL"); 

   362 	        ModifiedItemsL( aMessage );

   363 	        break;

   364 		case ENSmlDSItemsMoved:

   365 	        _DBG_FILE("MovedItemsL"); 

   366 	        MovedItemsL( aMessage );

   367 	        break;

   368 	    case ENSmlDSItemsAll:

   369 	    	_DBG_FILE("AllItems"); 

   370 	    	AllItemsL( aMessage ); aCompleteRequest = EFalse;

   371 	    	break;

   372 		case ENSmlDSResetChangeInfo:

   373 	        _DBG_FILE("ResetChangeInfoL"); 

   374 	        ResetChangeInfoL( aMessage ); aCompleteRequest = EFalse;

   375 	        break;

   376 		case ENSmlDSCommitChanges:

   377 	        _DBG_FILE("CommitChangesL"); 

   378 	        CommitChangesL( aMessage ); aCompleteRequest = EFalse;

   379 	        break;

   380 		case ENSmlDSCommitAllChanges:

   381 	        _DBG_FILE("CommitAllChangesL"); 

   382 	        CommitAllChangesL( aMessage ); aCompleteRequest = EFalse;

   383 	        break;

   384         case ENSmlDSUpdateServerId:

   385         	_DBG_FILE("Update server id"); 

   386         	UpdateServerIdL( aMessage );

   387         	break;

   388 		default:

   389 			_DBG_FILE("Unknown function"); 

   390 			PanicClient( aMessage, KErrNotSupported );

   391         }

   392 	_DBG_FILE( "CNSmlDSHostSession::DispatchMessageL(): end" );

   393 	}

   394 	

   395 // ------------------------------------------------------------------------------------------------

   396 // CNSmlDSHostSession::CNSmlDSHostSession

   397 // ------------------------------------------------------------------------------------------------

   398 CNSmlDSHostSession::CNSmlDSHostSession( CNSmlDSHostServer& aServer ) : 

   399     iServer( aServer )

   400 	{

   401 	_DBG_FILE( "CNSmlDSHostSession::CNSmlDSHostSession(): begin" );

   402 	iServer.IncSessionCount();

   403 	_DBG_FILE( "CNSmlDSHostSession::CNSmlDSHostSession(): end" );

   404 	}

   405 

   406 // ------------------------------------------------------------------------------------------------

   407 // CNSmlDSHostSession::ConstructL

   408 // ------------------------------------------------------------------------------------------------

   409 void CNSmlDSHostSession::ConstructL()

   410 	{

   411 	_DBG_FILE( "CNSmlDSHostSession::ConstructL(): begin" );

   412     iStringPool.OpenL();

   413 	_DBG_FILE( "CNSmlDSHostSession::ConstructL(): end" );

   414 	}

   415 	

   416 

   417 // ------------------------------------------------------------------------------------------------

   418 // CNSmlDSHostSession::HandleChunk

   419 // 

   420 // ------------------------------------------------------------------------------------------------

   421 void CNSmlDSHostSession::HandleChunk( const RMessage2& aMessage )

   422 	{

   423 	iMemPtr.iChunk.Close();

   424 	const TInt error = iMemPtr.iChunk.Open(aMessage, 0, EFalse);

   425 	}

   426 

   427 // ------------------------------------------------------------------------------------------------

   428 // CNSmlDSHostSession::CreateDataProvidersL

   429 // Creates Data Providers.

   430 // ------------------------------------------------------------------------------------------------

   431 void CNSmlDSHostSession::CreateDataProvidersL( const RMessage2& /*aMessage*/ )

   432 	{

   433 	

   434 	RArray<TInt> results;

   435     CleanupClosePushL( results );

   436     

   437     TMemPtr& ptr( MemPtrL() );

   438     RReadStream& readStream = ptr.ReadStreamLC();

   439     const TUint uidCount ( readStream.ReadInt32L() ) ;

   440 

   441     for( TUint i = 0; i < uidCount; i++ )

   442         {

   443         TSmlDataProviderId id;

   444         TPckg<TSmlDataProviderId> dpid( id );

   445         readStream.ReadL( dpid );

   446         TRAPD( err, CreateDataProviderL( dpid() ) );

   447         results.AppendL( err );

   448         }

   449     CleanupStack::PopAndDestroy(); //readStream

   450 

   451     //to chunk

   452     ptr.AdjustChunkIfNeededL( sizeof( TInt32 ) * ( results.Count() + 1 ) );

   453     RWriteStream& writeStream = ptr.WriteStreamLC();

   454     writeStream.WriteInt32L( results.Count() );

   455 

   456     for( TInt j = 0; j < results.Count(); j++ )

   457         {

   458         writeStream.WriteInt32L( results[j] );

   459         }

   460     writeStream.CommitL();

   461     CleanupStack::PopAndDestroy(2); //writeStream, results

   462 	}

   463 

   464 // ------------------------------------------------------------------------------------------------

   465 // CNSmlDSHostSession::CreateDataProvidersExceptL

   466 // ------------------------------------------------------------------------------------------------

   467 void CNSmlDSHostSession::CreateDataProvidersExceptL( const RMessage2& /*aMessage*/ )

   468     {

   469     iDataProviders.ResetAndDestroy();

   470     

   471     RArray<TSmlDataProviderId> results;

   472     CleanupClosePushL( results );

   473 

   474     TMemPtr& ptr( MemPtrL() );

   475     RReadStream& readStream = ptr.ReadStreamLC();

   476     

   477     //copying except uids to array.

   478     const TInt exceptIdCount ( readStream.ReadInt32L() );

   479     	

   480     RArray<TSmlDataProviderId> exceptIds( Max<TInt>( 2, exceptIdCount ) );

   481     CleanupClosePushL( exceptIds );

   482     

   483     for ( TInt i = 0; i < exceptIdCount; i++ )

   484     	{

   485     	TSmlDataProviderId id;

   486     	TPckg<TSmlDataProviderId> dpid( id );

   487         readStream.ReadL( dpid );

   488         exceptIds.AppendL( dpid() );

   489     	}

   490 

   491 	TUid DsUid = { KNSmlDSInterfaceUid };

   492 	RImplInfoPtrArray implArray;

   493     CleanupStack::PushL( PtrArrCleanupItemRArr( 

   494 			CImplementationInformation, &implArray ) );

   495 	REComSession::ListImplementationsL( DsUid, implArray );

   496 	

   497     for( TInt i = 0; i < implArray.Count(); i++ )

   498         {

   499         CImplementationInformation* implInfo = implArray[i];

   500         TSmlDataProviderId uid = implInfo->ImplementationUid().iUid;

   501 

   502         if ( exceptIds.Find( uid ) == KErrNotFound )

   503             {

   504             TRAPD( err, CreateDataProviderL( uid ) );

   505             if ( err == KErrNone )

   506                 {

   507                 results.AppendL( uid );

   508                 }

   509             }

   510         }

   511         

   512     CleanupStack::PopAndDestroy(3); //implArray, exceptIds, readStream

   513 

   514     //to chunk

   515     TStreamBuffers* sb = ptr.StreamBufferLC();

   516     sb->iWrite->WriteInt32L( results.Count() );

   517 

   518     for( TInt j = 0; j < results.Count(); j++ )

   519         {

   520         TPckgC<TSmlDataProviderId> dpid( results[j] );

   521         sb->iWrite->WriteL( dpid );

   522         }

   523     StreamBufferToChunkL( ptr, sb );

   524 	

   525     CleanupStack::PopAndDestroy(2); //sb, results

   526     }

   527     

   528 // ------------------------------------------------------------------------------------------------

   529 // CNSmlDSHostSession::CreateDataProviderL

   530 // ------------------------------------------------------------------------------------------------

   531 void CNSmlDSHostSession::CreateDataProviderL( TSmlDataProviderId aId )

   532     {

   533     CSmlDataProvider* dp = CSmlDataProvider::NewL( aId );

   534     CleanupStack::PushL( dp );

   535     TInt ret = iDataProviders.InsertL( dp );

   536     if ( ret == KErrNone )

   537         {

   538         CleanupStack::Pop( dp );    

   539         }

   540     else

   541         {

   542         CleanupStack::PopAndDestroy( dp );

   543         }

   544     }

   545 

   546 // ------------------------------------------------------------------------------------------------

   547 // CNSmlDSHostSession::DPInformationL

   548 // ------------------------------------------------------------------------------------------------

   549 void CNSmlDSHostSession::DPInformationL( const RMessage2& aMessage )

   550 	{

   551 	TSmlDataProviderId id( aMessage.Int0() );

   552 	CSmlDataProvider* dp = DataProviderL( id );

   553 	CNSmlDPInformation* dpi = CNSmlDPInformation::NewLC();

   554 	TMemPtr& ptr( MemPtrL() );

   555 	

   556 	const CSmlDataStoreFormat& storeFormat = dp->StoreFormatL();

   557 	dpi->SetId( id );

   558 	

   559 	CDesC8Array* mimetypes = new ( ELeave ) CDesC8ArrayFlat( storeFormat.MimeFormatCount() );

   560 	CleanupStack::PushL( mimetypes );

   561 	CDesC8Array* mimevers = new ( ELeave ) CDesC8ArrayFlat( storeFormat.MimeFormatCount() );

   562 	CleanupStack::PushL( mimevers );

   563 	

   564 	for ( TInt i = 0; i < storeFormat.MimeFormatCount(); i++ )

   565 		{

   566 		const CSmlMimeFormat& mf = storeFormat.MimeFormat(i);

   567 		mimetypes->AppendL( mf.MimeType().DesC() );

   568 		mimevers->AppendL( mf.MimeVersion().DesC() );

   569 		}

   570 	

   571 	dpi->SetMimeTypesL( mimetypes );

   572 	dpi->SetMimeVersL( mimevers );

   573 	

   574 	CleanupStack::Pop( 2 ); //mimetypes, mimevers

   575 	

   576 	if ( storeFormat.IsSupported( CSmlDataStoreFormat::EOptionHierarchial ) )

   577 		{

   578 		dpi->SetProtocolVersion( ESmlVersion1_2 );

   579 		}

   580 	else

   581 		{

   582 		dpi->SetProtocolVersion( ESmlVersion1_1_2 );

   583 		}

   584 	

   585 	TUid DsUid = { KNSmlDSInterfaceUid };

   586 	RImplInfoPtrArray implArray;

   587     CleanupStack::PushL( PtrArrCleanupItemRArr( 

   588 			CImplementationInformation, &implArray ) );

   589 	REComSession::ListImplementationsL( DsUid, implArray );

   590 	

   591     for( TInt i = 0; i < implArray.Count(); i++ )

   592         {

   593         CImplementationInformation* implInfo = implArray[i];

   594         if ( id == implInfo->ImplementationUid().iUid )

   595         	{

   596         	TVersion version( implInfo->Version(), 0, 0 );

   597         	dpi->SetVersion( version );

   598         	dpi->SetDisplayNameL( implInfo->DisplayName() );

   599         	}

   600         }

   601         

   602     CleanupStack::PopAndDestroy(); //implArray

   603     TStreamBuffers* sb = ptr.StreamBufferLC();

   604     dpi->ExternalizeL( *sb->iWrite );

   605     StreamBufferToChunkL( ptr, sb );

   606 	CleanupStack::PopAndDestroy( 2 ); //sb, dpi

   607 	}

   608 	

   609 // ------------------------------------------------------------------------------------------------

   610 // CNSmlDSHostSession::SupportsOperationL

   611 // Asks if Data Provider supports some operation.

   612 // ------------------------------------------------------------------------------------------------

   613 void CNSmlDSHostSession::SupportsOperationL( const RMessage2& aMessage )

   614 	{

   615     CSmlDataProvider* dp = DataProviderL( aMessage.Int0() );

   616     TMemPtr& ptr( MemPtrL() );

   617     TInt32 tmp(0);

   618     TPckg<TInt32> uidpck( tmp );

   619     ptr.CopyTo( uidpck );

   620     TUid uid( TUid::Uid( uidpck() ) );

   621     TBool retVal( dp->SupportsOperation( uid ) );

   622     TPckgC<TBool> respck( retVal );

   623     aMessage.WriteL( 2, respck );

   624 	}

   625 

   626 // ------------------------------------------------------------------------------------------------

   627 // CNSmlDSHostSession::StoreFormatL

   628 // Creates Data Store format of Data Provider.

   629 // ------------------------------------------------------------------------------------------------

   630 void CNSmlDSHostSession::StoreFormatL( const RMessage2& aMessage )

   631 	{

   632     CSmlDataProvider* dp = DataProviderL( aMessage.Int0() );

   633     TMemPtr& destPtr( MemPtrL() );

   634     

   635     TStreamBuffers* sb = destPtr.StreamBufferLC();

   636     const CSmlDataStoreFormat& dsf = dp->StoreFormatL();

   637     dsf.ExternalizeL( *sb->iWrite );

   638     StreamBufferToChunkL( destPtr, sb );

   639     

   640     CleanupStack::PopAndDestroy(); //sb

   641 	}

   642 	

   643 // ------------------------------------------------------------------------------------------------

   644 // CNSmlDSHostSession::ListStoresL

   645 // Creates list of Data Store names of Data Provider.

   646 // ------------------------------------------------------------------------------------------------	

   647 void CNSmlDSHostSession::ListStoresL( const RMessage2& aMessage )

   648 	{

   649     CSmlDataProvider* dp = DataProviderL( aMessage.Int0() );

   650     CDesCArray* stores = dp->ListStoresLC();

   651 

   652     TMemPtr& destPtr( MemPtrL() );

   653     TInt size( sizeof( TInt32 ) );

   654     

   655     if ( stores )

   656     	{

   657 	    for ( TInt i = 0; i < stores->Count(); i++ )

   658 	        {

   659 	        size += ( *stores )[i].Size() + sizeof( TInt32 );

   660 	        }

   661     	}

   662     	

   663     destPtr.AdjustChunkIfNeededL( size );

   664 	RWriteStream& wStream = destPtr.WriteStreamLC();

   665 	

   666 	if ( stores )

   667 		{

   668 		wStream.WriteInt32L( stores->Count() );

   669 	    for ( TInt i = 0; i < stores->Count(); i++ )

   670 	        {

   671 	        wStream.WriteInt32L( ( *stores )[i].Length() );

   672 	        wStream << ( *stores )[i];

   673 	        }

   674     	}

   675     else

   676     	{

   677     	wStream.WriteInt32L( 0 );

   678     	}

   679 

   680 	wStream.CommitL();

   681     CleanupStack::PopAndDestroy(2); //wStream, stores

   682 	}

   683 

   684 // ------------------------------------------------------------------------------------------------

   685 // CNSmlDSHostSession::DefaultStoreL

   686 // Creates default name for Data Store of Data Provider.

   687 // ------------------------------------------------------------------------------------------------	

   688 void CNSmlDSHostSession::DefaultStoreL( const RMessage2& aMessage )

   689 	{

   690     CSmlDataProvider* dp = DataProviderL( aMessage.Int0() );

   691     const TDesC& defStore = dp->DefaultStoreL();

   692     TMemPtr& dest( MemPtrL() );

   693     dest.AdjustChunkIfNeededL( defStore.Size() + sizeof( TInt32 ) + 2 );

   694     RWriteStream& wStream = dest.WriteStreamLC();

   695     wStream.WriteInt32L( defStore.Length() );

   696     wStream << defStore;

   697     wStream.CommitL();

   698     CleanupStack::PopAndDestroy(); //wStream

   699 	}

   700 

   701 // ------------------------------------------------------------------------------------------------

   702 // CNSmlDSHostSession::SupportedServerFiltersL

   703 // This method returns the set of filters that can be used to send to the Sync Partner.

   704 // ------------------------------------------------------------------------------------------------	

   705 void CNSmlDSHostSession::SupportedServerFiltersL( const RMessage2& aMessage )

   706 	{

   707     CSmlDataProvider* dp = DataProviderL( aMessage.Int0() );

   708     

   709     TBool suppOp( dp->SupportsOperation( KUidSmlSupportsUserSelectableMatchType ) );

   710     TSyncMLFilterMatchType matchType( ESyncMLMatchDisabled );

   711     if ( suppOp )

   712     	{

   713     	matchType = ESyncMLMatchNotSelected;

   714     	}

   715     	

   716     TPckgC<TSyncMLFilterMatchType> matchTypePckg( matchType );

   717     aMessage.WriteL( 2, matchTypePckg );

   718     

   719     const RPointerArray<CSyncMLFilter>& filters = dp->SupportedServerFiltersL();

   720     

   721     TMemPtr& dest( MemPtrL() );

   722     TStreamBuffers* sb = dest.StreamBufferLC();

   723     ExternalizeFiltersL( *sb->iWrite, filters );

   724     StreamBufferToChunkL( dest, sb );

   725     

   726     CleanupStack::PopAndDestroy(); //sb

   727 	}

   728 

   729 // ------------------------------------------------------------------------------------------------

   730 // CNSmlDSHostSession::CheckServerFiltersL

   731 // This method updates dynamic filters up-to-date

   732 // ------------------------------------------------------------------------------------------------		

   733 void CNSmlDSHostSession::CheckServerFiltersL( const RMessage2& aMessage )

   734 	{

   735 	CSmlDataProvider* dp = DataProviderL( aMessage.Int0() );

   736 	

   737 	RPointerArray<CSyncMLFilter> *filters = new ( ELeave ) RPointerArray<CSyncMLFilter>();

   738 	CleanupRPtrArrayPushL( filters );

   739 	

   740 	TMemPtr& memptr( MemPtrL() );

   741     RReadStream& rStream = memptr.ReadStreamLC();

   742     TSyncMLFilterChangeInfo changeInfo( static_cast<TSyncMLFilterChangeInfo>( rStream.ReadInt32L() ) );

   743     

   744     InternalizeFiltersL( rStream, *filters );

   745     CleanupStack::PopAndDestroy(); //rStream

   746     

   747     dp->CheckServerFiltersL( *filters, changeInfo );

   748     

   749     TStreamBuffers* sb = memptr.StreamBufferLC();

   750     sb->iWrite->WriteInt32L( changeInfo );

   751     ExternalizeFiltersL( *sb->iWrite, *filters );

   752     StreamBufferToChunkL( memptr, sb );

   753 

   754     CleanupStack::PopAndDestroy(2); //sb, filters

   755 	}

   756 	

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

   758 // CNSmlDSHostSession::CheckSupportedServerFiltersL

   759 // Calls CSmlDataProvider::CheckSupportedServerFiltersL.

   760 // ------------------------------------------------------------------------------------------------

   761 void CNSmlDSHostSession::CheckSupportedServerFiltersL( const RMessage2& aMessage )

   762 	{

   763 	CSmlDataProvider* dp = DataProviderL( aMessage.Int0() );

   764 	

   765 	RPointerArray<CSyncMLFilter> *filters = new ( ELeave ) RPointerArray<CSyncMLFilter>();

   766 	CleanupRPtrArrayPushL( filters );

   767 	

   768 	TMemPtr& memptr( MemPtrL() );

   769     RReadStream& rStream = memptr.ReadStreamLC();

   770     TSyncMLFilterChangeInfo changeInfo( static_cast<TSyncMLFilterChangeInfo>( rStream.ReadInt32L() ) );

   771     CSmlDataStoreFormat* dataStoreFormat = CSmlDataStoreFormat::NewLC( iStringPool, rStream );

   772     InternalizeFiltersL( rStream, *filters );

   773     

   774     dp->CheckSupportedServerFiltersL(*dataStoreFormat, *filters, changeInfo );    

   775     CleanupStack::PopAndDestroy(2); //rStream, dataStoreFormat

   776     

   777     TStreamBuffers* sb = memptr.StreamBufferLC();

   778     sb->iWrite->WriteInt32L( changeInfo );

   779     ExternalizeFiltersL( *sb->iWrite, *filters );

   780     StreamBufferToChunkL( memptr, sb );

   781 

   782     CleanupStack::PopAndDestroy(2); //sb, filters

   783 	}

   784 	

   785 // ------------------------------------------------------------------------------------------------

   786 // CNSmlDSHostSession::GetFiltersL

   787 // This method updates dynamic filters up-to-date

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

   789 void CNSmlDSHostSession::GetFiltersL( const RMessage2& aMessage )

   790 	{

   791 	CSmlDataProvider* dp = DataProviderL( aMessage.Int0() );

   792 	

   793 	HBufC* storename = DataStoreNameLC( aMessage );

   794 	

   795 	RPointerArray<CSyncMLFilter>* filters = new ( ELeave ) RPointerArray<CSyncMLFilter>();

   796 	CleanupRPtrArrayPushL( filters );

   797 	

   798 	TMemPtr& memptr( MemPtrL() );

   799     RReadStream& rStream ( memptr.ReadStreamLC() );

   800     TSyncMLFilterMatchType matchType ( static_cast<TSyncMLFilterMatchType>( rStream.ReadInt32L() ) );

   801     InternalizeFiltersL( rStream, *filters );

   802     

   803     TBuf<64> recordMimeType;

   804     

   805     TSyncMLFilterType filterType( ESyncMLTypeInclusive );

   806     HBufC* query = dp->GenerateRecordFilterQueryLC( *filters, matchType, recordMimeType, filterType, *storename );

   807     

   808     RPointerArray<CSmlDataProperty> properties;

   809     CleanupStack::PushL( PtrArrCleanupItemRArr( 

   810 			CSmlDataProperty, &properties ) );

   811 			

   812 	TBuf<64> fieldMimeType;

   813     

   814     dp->GenerateFieldFilterQueryL( *filters, fieldMimeType, properties, *storename );

   815     

   816     TStreamBuffers* sb = memptr.StreamBufferLC();

   817     sb->iWrite->WriteInt32L( filterType );

   818     if ( query )

   819     	{

   820     	sb->iWrite->WriteInt32L( query->Length() );

   821     	(*sb->iWrite) << *query;

   822     	}

   823     else

   824     	{

   825     	sb->iWrite->WriteInt32L( 0 );

   826     	(*sb->iWrite) << KNullDesC;

   827     	}

   828     

   829     sb->iWrite->WriteInt32L( recordMimeType.Length() );

   830     (*sb->iWrite) << recordMimeType;

   831     sb->iWrite->WriteInt32L( fieldMimeType.Length() );

   832     (*sb->iWrite) << fieldMimeType;

   833     

   834     sb->iWrite->WriteInt32L( properties.Count() );

   835     for ( TInt i = 0; i < properties.Count(); i++ )

   836     	{

   837     	properties[i]->ExternalizeL( *sb->iWrite );

   838     	}

   839 

   840 	StreamBufferToChunkL( memptr, sb );

   841     

   842     CleanupStack::PopAndDestroy(6); //sb, properties, query, rStream, filters, storename

   843 	

   844 	}

   845 

   846 // ------------------------------------------------------------------------------------------------

   847 // CNSmlDSHostSession::OpenL

   848 // Opens the data store specified by aStoreName.

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

   850 void CNSmlDSHostSession::OpenL( const RMessage2& aMessage )

   851     {

   852     if ( HasDataStoreL( aMessage ) )

   853     	{

   854     	User::Leave( KErrAlreadyExists );

   855     	}

   856     

   857     CNSmlDSAsyncCallBackForOpen* p = new ( ELeave ) CNSmlDSAsyncCallBackForOpen( 

   858     	this, aMessage, OpenFinishedL );

   859     CleanupStack::PushL( p );

   860     

   861     p->iDpi = DataProviderItemL( aMessage.Int0() );

   862     CSmlDataProvider* dp = p->iDpi->iDataprovider;

   863     TMemPtr& memptr( MemPtrL() );

   864     RReadStream& rStream = memptr.ReadStreamLC();

   865     

   866     //server id

   867     TInt tempLength = rStream.ReadUint32L();

   868 	p->iServerId = HBufC::NewL( rStream, tempLength );

   869 	

   870 	//remotedb

   871 	tempLength = rStream.ReadUint32L();

   872 	p->iRemoteDB = HBufC::NewL( rStream, tempLength );

   873 	

   874 	CleanupStack::PopAndDestroy(); //rStream

   875     

   876     //Localdb same as storename 

   877     HBufC* storeName = DataStoreNameLC( aMessage );

   878     

   879     CNSmlAdapterLog* adpLog = CNSmlAdapterLog::NewL();

   880     CleanupStack::PushL( adpLog );

   881     

   882     adpLog->SetAdapterLogKeyL( dp->Identifier(), *storeName, *p->iServerId, *p->iRemoteDB );

   883     CSmlDataStore* ds = dp->NewStoreInstanceLC();

   884     p->iDSItem = iDataProviders.InsertL( p->iDpi, ds, storeName );

   885     p->iDSItem->iAdpLog = adpLog;

   886     CleanupStack::Pop( 3 ); //ds, adpLog, storeName. iDataProviders takes the ownership

   887     

   888     p->CallDSAsyncLC().OpenL( *storeName, *adpLog, p->iStatus );

   889     

   890     CleanupStack::Pop( 2 ); //CallDSAsyncLC, p

   891     }

   892 

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

   894 // CNSmlDSHostSession::OpenFinished

   895 // called when OpenL request is finished.

   896 // Note! when aOperation is CNSmlDSAsyncCallBack::ECanceled or CNSmlDSAsyncCallBack::EFree, 

   897 // aDSAO->iDSItem might be NULL.

   898 // ------------------------------------------------------------------------------------------------	

   899 TInt CNSmlDSHostSession::OpenFinishedL( CNSmlDSAsyncCallBack* aDSAO, TCallBackOperation aOperation )

   900     {

   901     CNSmlDSAsyncCallBackForOpen* p = static_cast<CNSmlDSAsyncCallBackForOpen*> ( aDSAO );

   902     TInt err( aDSAO->iStatus.Int() );

   903     

   904     switch( aOperation )

   905     	{

   906 		case CNSmlDSAsyncCallBack::EFinished:

   907 			if ( err == KErrNone )

   908 				{

   909 				aDSAO->iDSItem->SetOpened();

   910 				}

   911 			else

   912 				{

   913 				//calling recursively

   914 				OpenFinishedL( aDSAO, CNSmlDSAsyncCallBack::ECanceled );

   915 				}

   916 	    	break;

   917 	    case CNSmlDSAsyncCallBack::ECanceled:

   918 	    	iDataProviders.Remove( p->iDpi, 

   919 	    		p->iDSItem ); //aDSAO->iDSItem might be NULL, but remove checks that.

   920 	    	err = KErrNone;

   921 	    	break;

   922 	    case CNSmlDSAsyncCallBack::EFree:

   923 			delete p->iServerId;

   924 			p->iServerId = NULL;

   925 			delete p->iRemoteDB;

   926 			p->iRemoteDB = NULL;

   927 			

   928 	    	aDSAO->iPtr = NULL;

   929 	    	break;

   930 		default:

   931 			User::Leave( KErrUnknown );

   932     	};

   933 

   934     return err;

   935     }

   936 

   937 // ------------------------------------------------------------------------------------------------

   938 // CNSmlDSHostSession::CancelRequest

   939 // Cancel the current asynchronous request.

   940 // ------------------------------------------------------------------------------------------------	

   941 void CNSmlDSHostSession::CancelRequestL( const RMessage2& aMessage )

   942 	{

   943     TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage );

   944     CNSmlDSAsyncRequestHandler* dsao = dsi->iDSAO;

   945     //Note! it is possible, that after deleting dsao, 

   946     //dsi may not exist anymore.

   947     dsi = NULL;

   948     

   949     if ( dsao )

   950         {

   951     	delete dsao;

   952     	dsao = NULL;

   953         }

   954 	}

   955 

   956 // ------------------------------------------------------------------------------------------------

   957 // CNSmlDSHostSession::BeginTransaction

   958 // Starts the transaction mode.

   959 // ------------------------------------------------------------------------------------------------	

   960 void CNSmlDSHostSession::BeginTransactionL( const RMessage2& aMessage )

   961 	{

   962     TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage );

   963 

   964     CSmlDataStore* ds = dsi->iDataStore;

   965     ds->BeginTransactionL();

   966     dsi->iHostMode = ENSmlTransactionMode;

   967 	}

   968 

   969 // ------------------------------------------------------------------------------------------------

   970 // CNSmlDSHostSession::CommitTransaction

   971 // Method will be called at the end of a successful transaction.

   972 // ------------------------------------------------------------------------------------------------	

   973 void CNSmlDSHostSession::CommitTransactionL( const RMessage2& aMessage )

   974 	{

   975     TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage );

   976    

   977     CNSmlDSAsyncCallBack* dsao = new ( ELeave ) CNSmlDSAsyncCallBack( this, dsi, aMessage );

   978     CleanupStack::PushL( dsao );

   979     dsao->CallDSAsyncLC().CommitTransactionL( dsao->iStatus );

   980     dsi->iHostMode = ENSmlNormalMode;

   981     CleanupStack::Pop( 2 ); //CallDSAsyncLC(), dsao

   982 	}

   983 

   984 // ------------------------------------------------------------------------------------------------

   985 // CNSmlDSHostSession::RevertTransaction

   986 // Method will be called to abort an ongoing transaction.

   987 // ------------------------------------------------------------------------------------------------	

   988 void CNSmlDSHostSession::RevertTransactionL( const RMessage2& aMessage )

   989 	{

   990     TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage );

   991     

   992     CNSmlDSAsyncCallBack* dsao = new ( ELeave ) CNSmlDSAsyncCallBack( this, dsi, aMessage );

   993     CleanupStack::PushL( dsao );

   994     dsao->CallDSAsyncLC().RevertTransaction( dsao->iStatus );

   995     dsi->iHostMode = ENSmlNormalMode;

   996     CleanupStack::Pop( 2 ); //CallDSAsyncLC(), dsao

   997 	}

   998 

   999 // ------------------------------------------------------------------------------------------------

  1000 // CNSmlDSHostSession::BeginBatch

  1001 // Starts the batch mode.

  1002 // ------------------------------------------------------------------------------------------------	

  1003 void CNSmlDSHostSession::BeginBatchL( const RMessage2& aMessage )

  1004 	{

  1005     TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage );

  1006 

  1007     RBatchItemUidArray* biua= new ( ELeave ) RBatchItemUidArray();

  1008     CleanupRPtrArrayPushL( biua );

  1009     CSmlDataStore* ds = dsi->iDataStore;

  1010     ds->BeginBatchL();

  1011     dsi->iHostMode = ENSmlBatchMode;

  1012     dsi->iBatchItemUids = biua;

  1013     CleanupStack::Pop( biua );

  1014 	}

  1015 	

  1016 // ------------------------------------------------------------------------------------------------

  1017 // CNSmlDSHostSession::CommitBatchL

  1018 // Method will be called at the end of the batch mode.

  1019 // ------------------------------------------------------------------------------------------------	

  1020 void CNSmlDSHostSession::CommitBatchL( const RMessage2& aMessage )

  1021 	{

  1022     TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage );

  1023    

  1024     RArray<TInt>* resultArray = new ( ELeave ) RArray<TInt>;

  1025     CleanupStack::PushL( resultArray );

  1026     CNSmlDSAsyncCallBack* dsao = new ( ELeave ) CNSmlDSAsyncCallBack( 

  1027     	this, dsi, aMessage, CommitBatchRequestFinishedL, resultArray );

  1028     CleanupStack::Pop( resultArray ); //dsao takes ownership

  1029     

  1030     CleanupStack::PushL( dsao );

  1031     dsao->CallDSAsyncLC().CommitBatchL( *resultArray, dsao->iStatus );

  1032     CleanupStack::Pop( 2 ); //CallDSAsyncLC(), dsao

  1033 	}

  1034 

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

  1036 // CNSmlDSHostSession::CommitBatchRequestFinished

  1037 // Called when commitBatchL request is finished

  1038 // ------------------------------------------------------------------------------------------------	

  1039 TInt CNSmlDSHostSession::CommitBatchRequestFinishedL( CNSmlDSAsyncCallBack* aDSAO, 

  1040 	TCallBackOperation aOperation )

  1041     {

  1042     TInt status ( aDSAO->iStatus.Int() );

  1043     TNSmlDSDataStoreElement* dsi = aDSAO->iDSItem;

  1044     RArray<TInt>* resultArray = reinterpret_cast<RArray<TInt>*>( aDSAO->iPtr );

  1045     

  1046     switch( aOperation )

  1047     	{

  1048 		case CNSmlDSAsyncCallBack::EFinished:

  1049 			dsi->iHostMode = ENSmlNormalMode;

  1050 			if ( status == KErrNone )

  1051 				{

  1052 		        TMemPtr& dest( MemPtrL() );

  1053 		        TStreamBuffers* sb = dest.StreamBufferLC();

  1054 		        

  1055 		        // write results

  1056 				sb->iWrite->WriteInt32L( resultArray->Count() );

  1057 				for ( TInt i = 0; i < resultArray->Count(); i++ )

  1058 					{

  1059 					sb->iWrite->WriteInt32L( ( *resultArray )[i] );

  1060 					}

  1061 				// write uids that are added.

  1062 				if ( dsi->iBatchItemUids )

  1063 					{

  1064 					sb->iWrite->WriteInt32L( dsi->iBatchItemUids->Count() );

  1065 					for ( TInt i = 0; i < dsi->iBatchItemUids->Count(); i++ )

  1066 						{

  1067 						TPckgC<TSmlDbItemUid> uid( *( *dsi->iBatchItemUids )[i] );

  1068 						sb->iWrite->WriteL( uid );

  1069 						}

  1070 					}

  1071 				else

  1072 					{

  1073 					sb->iWrite->WriteInt32L( 0 );

  1074 					}

  1075 				StreamBufferToChunkL( dest, sb );

  1076 				CleanupStack::PopAndDestroy(); //sb

  1077 		        status = aDSAO->iStatus.Int();

  1078 				}

  1079 	    	break;

  1080 	    case CNSmlDSAsyncCallBack::ECanceled:

  1081 	    	break;

  1082 	    case CNSmlDSAsyncCallBack::EFree:

  1083 	    	dsi->FreeBatchItemArray();

  1084 	    	resultArray->Close();

  1085 	    	delete resultArray;

  1086 	    	aDSAO->iPtr = NULL;

  1087 	    	break;

  1088 		default:

  1089 			User::Leave( KErrUnknown );

  1090     	}

  1091 

  1092     return status;

  1093     }

  1094 

  1095 // ------------------------------------------------------------------------------------------------

  1096 // CNSmlDSHostSession::CancelBatchL

  1097 // Method will be called to abort an ongoing batch mode.

  1098 // ------------------------------------------------------------------------------------------------	

  1099 void CNSmlDSHostSession::CancelBatchL( const RMessage2& aMessage )

  1100 	{

  1101     TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage );

  1102 

  1103     CSmlDataStore* ds = dsi->iDataStore;

  1104     ds->CancelBatch();

  1105     dsi->iHostMode = ENSmlNormalMode;

  1106     dsi->FreeBatchItemArray();

  1107 	}

  1108 	

  1109 // ------------------------------------------------------------------------------------------------

  1110 // CNSmlDSHostSession::SetRemoteDataStoreFormatL

  1111 // Sets the Sync Partner Data Format.

  1112 // ------------------------------------------------------------------------------------------------	

  1113 void CNSmlDSHostSession::SetRemoteDataStoreFormatL( const RMessage2& aMessage )

  1114 	{

  1115 	TNSmlDSDataStoreElement* dsi = DataStoreItemL( aMessage );

  1116     CSmlDataStore* ds = dsi->iDataStore;

  1117     TMemPtr& ptr( MemPtrL() );

  1118     RReadStream& readStream = ptr.ReadStreamLC();

  1119 

  1120     CSmlDataStoreFormat* serverDataStoreFormat = CSmlDataStoreFormat::NewLC( iStringPool, readStream );

  1121     ds->SetRemoteStoreFormatL( *serverDataStoreFormat );

  1122     dsi->setStoreFormat( serverDataStoreFormat );

  1123     CleanupStack::Pop(); //serverDataStoreFormat

  1124     CleanupStack::PopAndDestroy(); //readStream

  1125 	}

  1126 	

  1127 // ------------------------------------------------------------------------------------------------

  1128 // CNSmlDSHostSession::SetRemoteMaxObjectSizeL

  1129 // Sets the SyncML server Sync Partner maximum object size.

  1130 // ------------------------------------------------------------------------------------------------	

  1131 void CNSmlDSHostSession::SetRemoteMaxObjectSizeL( const RMessage2& aMessage )

  1132 	{

  1133     CSmlDataStore* ds = DataStoreL( aMessage );

  1134