1 // Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #ifdef _DEBUG

    17 #undef _NO_SERVER_LOGGING_

    18 #endif

    19 

    20 

    21 

    22 #include <e32std.h>

    23 #include <s32mem.h>

    24 #include <tmsvsystemprogress.h>

    25 

    26 #include "MSVSTD.H"

    27 #include "MSVIPC.H"

    28 #include "MSVREG.H"

    29 #include "MSVREGIP.H"

    30 #include "MSVIDS.H"

    31 #include "MSVUIDS.H"

    32 #include "MSVENTRY.H"

    33 #include "MSERVER.H"

    34 #include "MSVSERV.H"

    35 #include "MSVLOPS.H"

    36 #include "MSVROPS.H"

    37 #include "MSVUTILS.H"

    38 #include "MTSR.H"

    39 #include "MSVPANIC.H"

    40 #include "CMsvChangeBuffer.h"

    41 #include "MsvSecurityCapabilitySet.h"

    42 #include "cmsvcopystoreoperation.h"

    43 #include "cmsvdeletestoreoperation.h"

    44 #include "MSVAPI.H"

    45 #include "msvindexadapter.h"

    46 #include "msvcacheentry.h"

    47 #include "msvsearchsortcacheentry.h"

    48 #include "msvsearchsortcachemanager.h"

    49 #include "msvsearchsortdeltacache.h"

    50 #include <msvsearchsortquery.h>

    51 #include <msvsearchsortoperation.h>

    52 

    53 #if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

    54 #include <u32std.h>

    55 #include "cmsvconverterwaiter.h"

    56 #endif

    57 

    58 const TInt KMsvOperationIndexGranularity=8;

    59 const TInt KMsvOperationDataArrayGranularity=4;

    60 const TInt KMsvMtmRefCountArrayGranularity=4;

    61 

    62 _LIT(KMsvClientPanicString, "MSGS Client");

    63 

    64 //**********************************

    65 // TMtmGroupRefCount

    66 //**********************************

    67 

    68 TMtmGroupRefCount::TMtmGroupRefCount(TUid aMtmTypeUid)

    69 : iMtmTypeUid(aMtmTypeUid), iRefCount(0)

    70 	{}

    71 

    72 //**********************************

    73 // CMsvOperationData

    74 //**********************************

    75 

    76 CMsvOperationData::CMsvOperationData(TMsvOp aOpId)

    77 : iOpId(aOpId)

    78 	{

    79 	__DECLARE_NAME(_S("CMsvOperationData"));

    80 	}

    81 

    82 CMsvOperationData::~CMsvOperationData()

    83 	{

    84 	delete iBuffer;

    85 	}

    86 

    87 //**********************************

    88 // CMsvServerSession

    89 //**********************************

    90 

    91 CMsvServerSession::CMsvServerSession(CMsvServer& aServer)

    92 :   CSession2(),

    93 	iMsvServer(aServer),

    94 	iOperations(KMsvOperationIndexGranularity),

    95 	iMtmGroupRefCountArray(KMsvMtmRefCountArrayGranularity),

    96 	iOperationDataArray(KMsvOperationDataArrayGranularity),

    97 	iReceiveEntryEvents(ETrue)

    98 	{

    99 	__DECLARE_NAME(_S("CMsvServerSession"));

   100 	iSessionId = iMsvServer.SessionId();

   101 	}

   102 

   103 CMsvServerSession* CMsvServerSession::NewL(CMsvServer& aServer, const RMessage2 &aMessage)

   104 	{

   105 	CMsvServerSession* self = new(ELeave) CMsvServerSession(aServer);

   106 	CleanupStack::PushL(self);

   107 	self->ConstructL(aMessage);

   108 	CleanupStack::Pop();

   109 	return self;

   110 	}

   111 

   112 

   113 void CMsvServerSession::ConstructL(const RMessage2 &aMessage)

   114 	{

   115 	iChangeBuffer = CMsvChangeBuffer::NewL();

   116 	iBuffer = HBufC8::NewL(KMsvSessionBufferLength);

   117 	iChildrenSelection = new(ELeave) CArrayPtrSeg<const TMsvEntry>(16);

   118 	iChildrenSelectionIds = new(ELeave) CMsvEntrySelection;

   119 	

   120 	// if the index is already loaded, tell the client

   121 	if (iMsvServer.HasContext() && iMsvServer.Context().State()==TMsvIndexLoadProgress::EIndexComplete)

   122 		{

   123 		TMsvNotifBuffer buffer;

   124 		TMsvPackedChangeNotification package(buffer);

   125 		package.Pack(EMsvIndexLoaded, 0, 0, 0);

   126 		NotifyChangedL(buffer);

   127 

   128 		// Send disk status notifications

   129 		if (iMsvServer.StartupState() != EMsvNullNotification)

   130 			{

   131 			package.Pack(iMsvServer.StartupState(), KMsvNullIndexEntryId, iMsvServer.Context().Config().iDrive, 0);

   132 			NotifyChangedL(buffer);

   133 			}

   134 	

   135 	#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

   136 			// if we have unsupported drives, notify the client

   137 		if(FoundUnSupportedDrives())

   138 			{

   139 			package.Pack(EMsvMessageStoreNotSupported, 0, 0, 0);

   140 			NotifyChangedL(buffer);

   141 			}

   142 	#endif

   143 		}

   144 

   145 	RThread thread;

   146 	aMessage.Client(thread);

   147 	iProcessName = thread.Name();

   148 	thread.Close();

   149 	}

   150 

   151 

   152 CMsvServerSession::~CMsvServerSession()

   153 	{

   154 	// releasing locks

   155 	__ASSERT_DEBUG(iLockedStores.Count()==0, PanicClient(iQueuedMessage, EMsvLockedStoresOnExit));

   156 	TInt count = iLockedStores.Count();

   157 	while (count--)

   158 		{

   159 		iMsvServer.IndexAdapter().ReleaseStore(iLockedStores.At(count)); // ignore any errors

   160 		}

   161 

   162 

   163 	// deleting outstanding operations

   164 	__ASSERT_DEBUG(iOperations.Count()==0, PanicClient(iQueuedMessage, EMsvOutstandingOperationsOnExit));

   165 	count=iOperations.Count();

   166 	while (count--)

   167 		{

   168 		delete iOperations.At(count); // operation are deleted last in first out order

   169 		iOperations.Delete(count);

   170 		}

   171 

   172 	iOperationDataArray.ResetAndDestroy();

   173 	iMtmGroupRefCountArray.Reset();

   174 

   175 	// Set request queued flag to false so we're not notified to close the session

   176 	iRequestQueued = EFalse;

   177 

   178 	iMsvServer.ClosingSession(iSessionId);

   179 

   180 	delete iChildrenSelection;

   181 	delete iChildrenSelectionIds;

   182 	if(iChangeBuffer != NULL)

   183 		{

   184 		delete iChangeBuffer;

   185 		}

   186 	if(iBuffer != NULL)

   187 		{

   188 		delete iBuffer;

   189 		

   190 		}

   191 	}

   192 

   193 void CMsvServerSession::ServiceL(const RMessage2& aMessage)

   194 //

   195 //

   196 //

   197 	{

   198 	if ((!iMsvServer.HasContext() || iMsvServer.Context().State()!=TMsvIndexLoadProgress::EIndexComplete) && aMessage.Function()!=EMsvNotifySessionEvent && aMessage.Function()!=EMsvCancelSessionEventNotification)

   199 		aMessage.Complete(KErrNotReady);

   200 	else

   201 		{

   202 		TRAPD(error, DoServiceL(aMessage));

   203 		if (error)

   204 			aMessage.Complete(error);

   205 		}

   206 	}

   207 

   208 void CMsvServerSession::DoServiceL(const RMessage2& aMessage)

   209 //

   210 // service a client request; test the opcode and then do appropriate servicing

   211 //

   212 	{

   213 	// all functions called should ensure that all synchronous messages have been completed

   214 	switch (aMessage.Function())

   215 		{

   216 		case EMsvNotifySessionEvent:

   217 			QueueSessionEventRequestL(aMessage);

   218 			break;

   219 		case EMsvCancelSessionEventNotification:

   220 			CancelSessionEventRequest(aMessage);

   221 			break;

   222 		case EMsvOperationData:

   223 			CopyOperationDataL(aMessage);

   224 			break;

   225 		case EMsvCommandData:

   226 			CopyCommandDataL(aMessage);

   227 			break;

   228 		case EMsvCreateEntry:

   229 			CreateEntryL(aMessage);

   230 			break;

   231 		case EMsvGetEntry:

   232 			GetEntryL(aMessage);

   233 			break;

   234 		case EMsvChangeEntry:

   235 			ChangeEntryL(aMessage);

   236 			break;

   237 		case EMsvGetChildren:

   238 			GetChildrenL(aMessage);

   239 			break;

   240 		case EMsvGetRemainingChildren:

   241 			GetRemainingChildrenL(aMessage);

   242 			break;

   243 		case EMsvDeleteEntries:

   244 			DeleteEntriesL(aMessage);

   245 			break;

   246 		case EMsvLockEntry:

   247 			LockEntryL(aMessage);

   248 			break;

   249 		case EMsvReleaseEntry:

   250 			ReleaseEntryL(aMessage);

   251 			break;

   252 		case EMsvReadStore:

   253 			ReadStoreL(aMessage);

   254 			break;

   255 		case EMsvLockStore:

   256 			LockStoreL(aMessage);

   257 			break;

   258 		case EMsvReleaseStore:

   259 			ReleaseStoreL(aMessage);

   260 			break;

   261 		case EMsvCancelOperation:

   262 			CancelOperationL(aMessage);

   263 			break;

   264 		case EMsvOperationCompletion:

   265 			OperationCompletionL(aMessage);

   266 			break;

   267 		case EMsvOperationProgress:

   268 			OperationProgressL(aMessage);

   269 			break;

   270 		case EMsvOperationSystemProgress:

   271 			OperationSystemProgressL(aMessage);

   272 			break;

   273 		case EMsvOperationMtm:

   274 			OperationMtmL(aMessage);

   275 			break;

   276 		case EMsvMoveEntries:

   277 			MoveEntriesL(aMessage);

   278 			break;

   279 		case EMsvCopyEntries:

   280 			CopyEntriesL(aMessage);

   281 			break;

   282 		case EMsvMtmCommand:

   283 			TransferCommandL(aMessage);

   284 			break;

   285 		case EMsvFillRegisteredMtmDllArray:

   286 			FillRegisteredMtmDllArray(aMessage);

   287 			break;

   288 		case EMsvInstallMtmGroup:

   289 			MtmGroupL(aMessage, ETrue);

   290 			break;

   291 		case EMsvDeInstallMtmGroup:

   292 			MtmGroupL(aMessage, EFalse);

   293 			break;

   294 		case EMsvUseMtmGroup:

   295 			UseMtmGroup(aMessage);

   296 			break;

   297 		case EMsvReleaseMtmGroup:

   298 			ReleaseMtmGroup(aMessage);

   299 			break;

   300 		case EMsvGetMtmGroupData:

   301 			GetMtmGroupDataL(aMessage);

   302 			break;

   303 		case EMsvGetMtmRequiredCapabilities:

   304 			GetMtmRequiredCapabilitiesL(aMessage);

   305 			break;

   306 		case EMsvCloseServer:

   307 			iMsvServer.CloseServer(aMessage);

   308 			break;

   309 		case EMsvStopService:

   310 			iMsvServer.StopServiceL(aMessage);

   311 			break;

   312 		case EMsvServiceActive:

   313 			iMsvServer.ServiceActive(aMessage);

   314 			break;

   315 		case EMsvServiceProgress:

   316 			ServiceProgressL(aMessage);

   317 			break;

   318 		case EMsvRemoveEntry:

   319 			RemoveEntry(aMessage);

   320 			break;

   321 		case EMsvGetMessageDirectory:

   322 			MessageFolderL(aMessage);

   323 			break;

   324 		case EMsvSlotAvailable:

   325 			if (iOperations.Count()<KMsvMaxSlotsAvailable)

   326 				aMessage.Complete(KErrNone);

   327 			else

   328 				aMessage.Complete(KErrServerBusy);

   329 			break;

   330 		case EMsvSetSessionAsObserver:

   331 			iObserverOnly=ETrue;

   332 			aMessage.Complete(KErrNone);

   333 			break;

   334 		case EMsvSetFailure:

   335 			iMsvServer.SetFailure((TMsvFailure)aMessage.Int0(), aMessage.Int1(), aMessage.Int2(), aMessage.Int3());

   336 			aMessage.Complete(KErrNone);

   337 			break;

   338 		case EMsvChangeAttributes:

   339 			ChangeAttributesL(aMessage);

   340 			break;

   341 		case EMsvGetChildIds:

   342 			GetChildIdsL(aMessage);

   343 			break;

   344 		case EMsvChangeDrive:

   345 			ChangeDriveL(aMessage);

   346 			break;

   347 		case EMsvOutstandingOperations:

   348 			OutstandingOperationsL(aMessage);

   349 			break;

   350 		case EMsvGetNotifySequence:

   351 			GetNotifySequenceL(aMessage);

   352 			break;

   353 		case EMsvSetReceiveEntyEvents:

   354 			SetReceiveEntryEvents(aMessage);

   355 			break;

   356 		case EMsvDecStoreReaderCount:

   357 			DecStoreReaderCountL(aMessage);

   358 			break;

   359 		case EMsvGetMessageDrive:

   360 #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

   361 			MessageDrive(aMessage);

   362 #else

   363 			aMessage.Complete(iMsvServer.Context().Config().iDrive);

   364 #endif

   365 			break;

   366 		case EMsvCreateAttachmentForWrite:

   367 			CreateAttachmentForWriteL(aMessage);

   368 			break;

   369 		case EMsvReplaceAttachmentForWrite:

   370 			ReplaceAttachmentForWriteL(aMessage);

   371 			break;

   372 		case EMsvOpenAttachment:

   373 			OpenAttachmentL(aMessage);

   374 			break;

   375 		case EMsvOpenAttachmentForWrite:

   376 			OpenAttachmentForWriteL(aMessage);

   377 			break;

   378 		case EMsvDeleteAttachment:

   379 			DeleteAttachmentL(aMessage);

   380 			break;

   381 		case EMsvRenameAttachment:

   382 			RenameAttachmentL(aMessage);

   383 			break;

   384 		case EMsvFileExists :

   385 			FileExistsL(aMessage);

   386 			break;

   387 		case EMsvGetAttachmentFilePath:

   388 			GetAttachmentFilePathL(aMessage);

   389 			break;

   390 		case EMsvOpenFileStoreForRead:

   391 			OpenFileStoreForReadL(aMessage);

   392 			break;

   393 		case EMsvOpenTempStoreFile:

   394 			OpenTempStoreFileL(aMessage);

   395 			break;

   396 		case EMsvReplaceFileStore:

   397 			ReplaceFileStoreL(aMessage);

   398 			break;

   399 		case EMsvDeleteFileStore:

   400 			DeleteFileStoreL(aMessage);

   401 			break;

   402 		case EMsvFileStoreExists:

   403 			FileStoreExistsL(aMessage);

   404 			break;

   405 		case EMsvGetAndClearIndexCorruptFlag:

   406 			aMessage.Complete(iMsvServer.Context().GetAndClearIndexCorruptFlagL());

   407 			break;

   408 		case EMsvCopyStore:

   409 			CopyStoreL(aMessage);

   410 			break;

   411 		case EMsvDeleteStore:

   412 			DeleteStoreL(aMessage);

   413 			break;

   414 		case EMsvDriveContainsStore:

   415 			aMessage.Complete(MessageServer::DriveContainsStore(iMsvServer.FileSession(),aMessage.Int0()));

   416 			break;

   417 		case EMsvMessageStoreDrivePresent:

   418 			aMessage.Complete(MessageServer::IsMessageStoreDrivePresentL(iMsvServer.FileSession()));			

   419 			break;

   420 		case EMsvGetBodyTextFilePath:

   421 			 BodyTextFilePathL(aMessage);

   422 			 break;

   423 		case EMsvOpenTextFileForRead:

   424 			 OpenPlainTextFileL(aMessage);

   425 			 break;

   426 		case EMsvCreatePlainTextFile:

   427 			 CreatePlainTextFileL(aMessage);

   428 			 break;

   429 		case EMsvDeletePlainTextFile:

   430 			DeletePlainTextFileL(aMessage); 

   431 			break;

   432 		case EMsvReplacePlainTextFile:

   433 			ReplacePlainTextFileL(aMessage);

   434 			break;

   435 

   436 		case EMsvGetNonOperationMtmData:

   437 			{

   438 			GetNonOperationMtmDataL(aMessage);

   439 			break;

   440 			}

   441 		case EMsvSearchSortOperation: // On HEADER AND BODY

   442 			SearchSortOnHeaderAndBodytMsgL(aMessage);

   443 			break;

   444 	

   445 		case EMsvSearchSortOnIndexEntry: //On INDEX ENTRY.

   446 			SearchSortOnIndexEntryL(aMessage);

   447 			break;

   448 

   449 		case EMsvGetResult ://Index entry result.

   450 			SendSearchSortIndexEntryResultL(aMessage);

   451 			break;

   452 		

   453 		case EMsvGetIdsOrResult://header result.

   454 			SendResultOrIdsToSearchL(aMessage);

   455 			break;

   456 		

   457 		case EMsvGetResultCount:

   458 			GetSearchSortResultCountL(aMessage);

   459 			break;

   460 			

   461 		case EMsvGetNextId:

   462 			GetResultInIteratorL(aMessage);

   463 			break;

   464 		

   465 		case EMsvGetNextEntry:

   466 			GetNextEntryInIteratorL(aMessage);

   467 			break;

   468 		

   469 		case EMsvGetQueryId:

   470 			GetQueryIDL(aMessage);

   471 			break;

   472 	

   473 		case EMsvUnmarQueryId:

   474 			QueryUnMarkedL(aMessage);

   475 			break;

   476 

   477 		case EMsvIdWithSortFiled:

   478 			UpdateSearchSortCacheWithSortFiledL(aMessage);

   479 			break;

   480 	

   481 		case EMsvSearchSortQueryId:

   482 			GetResultForQueryIDL(aMessage);

   483 			break;

   484 

   485 		case EMsvQueryData:

   486 			CopyQueryDataL(aMessage);

   487 			break;

   488 			

   489 		case EMsvGetSearchSortProgress:

   490 			GetSearchSortProgressInfoL(aMessage);

   491 			break;

   492 			

   493 		case EMsvCancelSearchSortOp:

   494 			SearchSortOperationCancelL(aMessage);

   495 			break;

   496 			

   497 		case EMsvUpdateAndSort:

   498 			UpdateSearchSortResultsAndSortByEntryL(aMessage);

   499 			break;

   500 

   501 // Code changes for PREQ 557.	   

   502 #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

   503 		case EMsvGetChildrenALL:

   504 			GetChildrenAllL(aMessage);

   505 			break;

   506 		case EMsvGetChildIdsALL:

   507 			GetChildIdsAllL(aMessage);

   508 			break;

   509 		case EMsvGetCurrentDriveInfo:

   510 			CurrentDriveInfoL(aMessage);

   511 			break;

   512 		case EMsvGetDriveList:

   513 			DriveListL(aMessage);	   

   514 			break;

   515 		case EMsvGetAvailableDriveList:

   516 			AvailableDriveListL(aMessage);

   517 			break;

   518 		case EMsvAddDriveToDriveList:

   519 			AddDriveL(aMessage);

   520 			break;

   521 		case EMsvRemoveDriveFromDriveList:

   522 			RemoveDriveL(aMessage); 

   523 			break;

   524 		case EMsvUpdateDrivePriority:

   525 			UpdateDrivePriorityL(aMessage);

   526 			break;

   527 #if (defined SYMBIAN_MESSAGESTORE_UNIT_TESTCODE)

   528 		case EMsvResetRepository:

   529 			ResetRepositoryL(aMessage);

   530 			break;

   531 		case EMsvPrintCache:

   532 			PrintCache(aMessage);

   533 			break;

   534 #endif	  // #if (defined SYMBIAN_MESSAGESTORE_UNIT_TESTCODE)

   535 #endif	  // #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

   536 

   537 

   538 #if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

   539 		case EMsvCreateStore:

   540 			CreateHeaderTableL(aMessage);

   541 			break;

   542 		case EMsvCheckStoreExists:

   543 			DoesStoreExistsL(aMessage);

   544 			break;

   545 		case EMsvLastErrorMessage:

   546 			LastErrorMessageL(aMessage);

   547 			break;

   548 		case EMsvCreateHeaderEntry:

   549 			CreateHeaderEntryL(aMessage);

   550 			break;

   551 		case EMsvLoadHeaderEntry:

   552 			LoadHeaderEntryL(aMessage);

   553 			break;

   554 		case EMsvUpdateHeaderEntry:

   555 			UpdateHeaderEntryL(aMessage);

   556 			break;

   557 		case EMsvDeleteHeaderEntry:

   558 			DeleteHeaderEntryL(aMessage);

   559 			break;							  

   560 		case EMsvCheckAnyStoreExists:

   561 			DoesAnyStoreExists(aMessage);

   562 			break;

   563 		case EMsvCheckHeaderTableExist:

   564 			{

   565 			DoesHeaderTableExist(aMessage);

   566 			break;

   567 			}

   568 		case EMsvGetConvertibleDriveList:

   569 			GetConvertibleDriveListL(aMessage);

   570 			break;

   571 		case EMsvConvertMessageStore:

   572 			ConvertMessageStoreL(aMessage);

   573 			break;

   574 		case EMsvGetConversionStatus:

   575 			GetConversionStatus(aMessage);

   576 			break;

   577 		case EMsvCancelConversionRequest:

   578 			CancelConversionRequestL(aMessage);

   579 			break;

   580 #endif	  // #if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)

   581 		case EMsvChangeEntries:

   582 		     ChangeEntriesL(aMessage);

   583 		     break;

   584 		default:

   585 			PanicClient(aMessage, EMsvBadRequest);

   586 			break;

   587 		}

   588 	}

   589 

   590 

   591 void CMsvServerSession::QueueSessionEventRequestL(const RMessage2 &aMessage)

   592 //

   593 // The client is requesting notifcation of any changes

   594 //

   595 	{

   596 	if (iRequestQueued)

   597 		{

   598 		PanicClient(aMessage, EMsvDuplicatedChangeRequest);

   599 		return;

   600 		}

   601 

   602 	if (iChangeBuffer->IsEmpty())

   603 		{

   604 		// queue this request until a change occurs

   605 		iQueuedMessage = aMessage;

   606 		iRequestQueued = ETrue;

   607 		}

   608 	else

   609 		{

   610 		// inform client of change which has been queued

   611 		SendNotificationL(aMessage);

   612 		}

   613 	}

   614 

   615 void CMsvServerSession::SendNotificationL(const RMessage2& aMessage)

   616 	{

   617 	// inform client of change which has been queued

   618 	TPckgBuf<TUint32> sequence;

   619 	aMessage.WriteL(0, iChangeBuffer->Next(sequence()));

   620 

   621 	// Tell the client the notification sequence number

   622 	aMessage.WriteL(1, sequence);

   623 

   624 #ifndef _NO_SERVER_LOGGING_

   625 	iMsvServer.Log(_L("Sending notification sequence %d"), sequence());

   626 #endif

   627 

   628 	aMessage.Complete(KErrNone);

   629 	iChangeBuffer->Out();

   630 	}

   631 

   632 void CMsvServerSession::CancelSessionEventRequest(const RMessage2 &aMessage)

   633 //

   634 // The client is cancelling the outstanding request

   635 //

   636 	{

   637 	if (iRequestQueued)

   638 		{

   639 		iQueuedMessage.Complete(KErrNone);

   640 		iRequestQueued = EFalse;

   641 		}

   642 	aMessage.Complete(KErrNone);

   643 	}

   644 

   645 

   646 

   647 void CMsvServerSession::ReadBufferL(const RMessage2& aMessage, TInt aParam, HBufC8*& aBuffer)

   648 //

   649 // Copies a buffer from the client

   650 // Only fails if there is not enough memory to increase the buffer size (if needed)

   651 //

   652 	{

   653 	TInt desLen = aMessage.GetDesLength(aParam);

   654 

   655 	if(desLen >= 0)

   656 		{

   657 		TBool alloced=EFalse;

   658 		HBufC8* localBuffer=NULL;

   659 		

   660 		if (aBuffer==NULL)

   661 			{

   662 			localBuffer = HBufC8::NewLC(desLen);

   663 			alloced=ETrue;

   664 			}

   665 		else if (desLen > aBuffer->Des().MaxLength())

   666 			{

   667 			// we have to increase the size of iBuffer

   668 			aBuffer->Des().SetLength(0); // to avoid copying the contents

   669 			localBuffer = aBuffer->ReAlloc(desLen);

   670 			if (localBuffer==NULL)

   671 				{

   672 				User::Leave(KErrNoMemory); // unable to create buffer large enough

   673 				}

   674 			}

   675 		

   676 		if(localBuffer)

   677 			{

   678 			TPtr8 desPtr = localBuffer->Des();

   679 			aMessage.ReadL(aParam, desPtr);

   680 				

   681 			if (alloced)

   682 				{

   683 				CleanupStack::Pop(); // localBuffer

   684 				}

   685 			

   686 			aBuffer = localBuffer;  

   687 			}

   688 		//use aBuffer

   689 		else

   690 			{

   691 			TPtr8 desPtr = aBuffer->Des();

   692 			aMessage.ReadL(aParam, desPtr); 

   693 			}

   694 		}

   695 	else

   696 		{

   697 		// desLen is negative leave with an error.

   698 		User::Leave(KErrArgument);

   699 		}

   700 	}

   701 

   702 void CMsvServerSession::WriteBufferL(const RMessage2& aMessage, TInt aParam)

   703 //

   704 // Copies the packed entry buffer from the client

   705 // Only fails if the client buffer is not large enough

   706 //

   707 	{

   708 	TInt desLen = aMessage.GetDesMaxLength(aParam);

   709 	if (desLen < iBuffer->Des().Length())

   710 		User::Leave(KErrOverflow);

   711 	aMessage.WriteL(aParam, iBuffer->Des());

   712 	}

   713 

   714 

   715 void CMsvServerSession::WriteL(const RMessage2& aMessage, TInt aParam, const TDesC8& aDes)

   716 //

   717 // Write a descriptor to the client thread; if unsuccessful,leave so that client can handle it.

   718 //

   719 	{

   720 	TInt error = aMessage.Write(aParam, aDes);

   721 	if (error)

   722 		{

   723 		User::Leave(error);

   724 		}

   725 	}

   726 

   727 

   728 void CMsvServerSession::ReadL(const RMessage2& aMessage, TInt aParam, TDes8& aDes)

   729 //

   730 // Reads a descriptor from the client thread; if unsuccessful,leave so that client can handle it

   731 //

   732 	{

   733 	TInt error = aMessage.Read(aParam, aDes);

   734 	if (error)

   735 		{

   736 		User::Leave(error);

   737 		}

   738 	}

   739 

   740 

   741 

   742 void CMsvServerSession::CopyOperationDataL(const RMessage2 &aMessage)

   743 //

   744 // Copies operation data from the client and stores for the asynchronous operation request

   745 //

   746 	{

   747 	TMsvOp operationId = aMessage.Int0();

   748 	CMsvOperationData* opData = new (ELeave) CMsvOperationData(operationId);

   749 	CleanupStack::PushL(opData);

   750 	ReadBufferL(aMessage, 1, opData->iBuffer);

   751 	iOperationDataArray.AppendL(opData);

   752 	CleanupStack::Pop(); // opData

   753 	aMessage.Complete(KErrNone);

   754 	}

   755 

   756 void CMsvServerSession::CopyCommandDataL(const RMessage2 &aMessage)

   757 //

   758 // Copies operation data from the client and stores for the asynchronous operation request

   759 //

   760 	{

   761 	TMsvOp operationId = aMessage.Int0();

   762 	// operation data

   763 	CMsvOperationData* opData = new (ELeave) CMsvOperationData(operationId);

   764 	CleanupStack::PushL(opData);

   765 	ReadBufferL(aMessage, 1, opData->iBuffer);

   766 

   767 	// This is to check if the buffer is a valid , before it is added to 

   768 	// the operationData array

   769 	TMsvPackedOperation packedOperation(opData->iBuffer);

   770 	CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;

   771 	CleanupStack::PushL(selection);

   772 	TInt command, temp;

   773 	packedOperation.UnpackL(*selection, command, temp);

   774 	CleanupStack::PopAndDestroy(selection);

   775 

   776 	iOperationDataArray.AppendL(opData);

   777 	

   778 	// additional parameter

   779 	CMsvOperationData* opParam = new (ELeave) CMsvOperationData(operationId);

   780 	CleanupStack::PushL(opParam);

   781 	ReadBufferL(aMessage, 2, opParam->iBuffer);

   782 	iOperationDataArray.AppendL(opParam);

   783 	CleanupStack::Pop(2, opData); // opParam, opData

   784 	//

   785 	aMessage.Complete(KErrNone);

   786 	}

   787 

   788 

   789 HBufC8* CMsvServerSession::RecoverOperationData(TMsvOp aOpId)

   790 //

   791 // Returns the operation data previously copied from the client

   792 // NOTE the calling function is responsible for deleting the returned HBufC

   793 //

   794 	{

   795 	// find the data

   796 	TInt count = 0;

   797 	TInt totalCount=iOperationDataArray.Count();

   798 	for (; count<totalCount; count++)

   799 		{

   800 		if (iOperationDataArray.At(count)->OperationId()==aOpId)

   801 			break;

   802 		}

   803 	// Panic during debug if cannot find data

   804 	__ASSERT_DEBUG(count<iOperationDataArray.Count(), PanicServer(EMsvEntryDataNotFound));

   805 	// At runtime, return NULL.

   806 	if(count >= iOperationDataArray.Count())

   807 		{

   808 		return NULL;

   809 		}

   810 	// return the data to the caller, and delete the container object

   811 	HBufC8* opData = iOperationDataArray.At(count)->iBuffer;

   812 	iOperationDataArray.At(count)->iBuffer = NULL;

   813 	delete iOperationDataArray.At(count);

   814 	iOperationDataArray.Delete(count);

   815 	return opData;

   816 	}

   817 

   818 

   819 void CMsvServerSession::CreateEntryL(const RMessage2 &aMessage)

   820 //

   821 // Create a entry in the index

   822 //

   823 	{

   824 	// Recover the operation data

   825 	TMsvOp operationId = aMessage.Int0();

   826 	HBufC8* opData = RecoverOperationData(operationId);

   827 	// Check for NULL data entry to be changed, must have been given incorrect id for argument.

   828 	if(opData == NULL)

   829 		{

   830 		aMessage.Complete(KErrArgument);

   831 		return;

   832 		}

   833 	

   834 	CleanupStack::PushL(opData);

   835 	// Unpack the data

   836 	TMsvPackedEntry packedEntry(opData);

   837 	TMsvEntry entry;

   838 	packedEntry.UnpackEntry(entry);

   839 

   840 	// Check the content of the entry are conforming to policy

   841 	if (!MsvUtils::ValidEntry(entry, ETrue))

   842 		{

   843 		PanicClient(aMessage, EMsvIncorrectEntry);

   844 		User::Leave(KErrNotSupported);

   845 		}

   846 

   847 	// Check if the entry is local or the entry is a service

   848 	TBool local=ETrue;

   849 	// Police request - client must be able to create the entry.

   850 	iMsvServer.PoliceCreateEntryL(aMessage, entry, local, __PLATSEC_DIAGNOSTIC_STRING("Checked by CMsvServerSession::CreateEntryL"));

   851 

   852 	// For purpose of creating a service entry, it is considered local as an MTM

   853 	// is not required to do the work.

   854 	if( entry.iType == KUidMsvServiceEntry )

   855 		local = ETrue;

   856 

   857 	// start the change for local or remote entries

   858 	if (local)

   859 		{

   860 		TSecureId ownerId = aMessage.Int1();

   861 

   862 		DoCreateLocalEntryL(entry, operationId, aMessage, ownerId);

   863 		}

   864 	else

   865 		DoCreateRemoteEntryL(entry, operationId, aMessage);

   866 

   867 	CleanupStack::PopAndDestroy(); // opData

   868 	}

   869 

   870 void CMsvServerSession::DoCreateLocalEntryL(const TMsvEntry& aEntry, TMsvOp aOpId, const RMessage2 &aMessage, TSecureId aOwnerId)

   871 //

   872 // Create a local entry in the index

   873 //

   874 	{

   875 	CMsvLocalCreateOperation* operation = new(ELeave) CMsvLocalCreateOperation(aMessage, aOpId, aEntry, iMsvServer);

   876 	CleanupStack::PushL(operation);

   877 	iOperations.AppendL(operation);

   878 	CleanupStack::Pop(operation);

   879 	operation->Start(aOwnerId);

   880 	}

   881 

   882 void CMsvServerSession::DoCreateRemoteEntryL(const TMsvEntry& aEntry, TMsvOp aOpId, const RMessage2 &aMessage)

   883 //

   884 // Create a remote entry in the index

   885 //

   886 	{

   887 	// make sure that the operation can be added to the list

   888 	iOperations.SetReserveL(iOperations.Count()+1);

   889 

   890 	// create the operation and pass it to the server for starting/queuing

   891 	CMsvMtmOperation* operation = CMsvMtmOperation::NewL(aMessage, aOpId, aEntry.iMtm, aEntry.iServiceId, iSessionId, iMsvServer);

   892 	CleanupStack::PushL(operation);

   893 	operation->CreateL(aEntry);

   894 	iMsvServer.StartOperationL(*operation, iSessionId, aMessage, ETrue);

   895 	iOperations.AppendL(operation); // will not fail - see start of function

   896 	CleanupStack::Pop(); // operation

   897 	}

   898 

   899 

   900 void CMsvServerSession::ChangeEntryL(const RMessage2 &aMessage)

   901 //

   902 // Changes the entry

   903 //

   904 	{

   905 	// Recover the operation data

   906 	TMsvOp operationId = aMessage.Int0();

   907 	HBufC8* opData = RecoverOperationData(operationId);

   908 	// Check for NULL data entry to be changed, must have been given incorrect id for argument.

   909 	if(opData == NULL)

   910 		{

   911 		aMessage.Complete(KErrArgument);

   912 		return;

   913 		}

   914 		

   915 	CleanupStack::PushL(opData);

   916 	// Unpack the data

   917 	TMsvPackedEntry packedEntry(opData);

   918 	TMsvEntry entry;

   919 	packedEntry.UnpackEntry(entry);

   920 

   921 	// Check the content of the entry are conforming to policy

   922 	__ASSERT_DEBUG(MsvUtils::ValidEntry(entry), PanicClient(aMessage, EMsvIncorrectEntry));

   923 	if (!MsvUtils::ValidEntry(entry))

   924 		User::Leave(KErrNotSupported);

   925 

   926 	// Check if the entry is local or the entry is a service

   927 	TBool local=ETrue;

   928 	// Police request - client must be able to modify the entry.

   929 	iMsvServer.PoliceModifyEntryL(aMessage, entry, local, __PLATSEC_DIAGNOSTIC_STRING("Checked by CMsvServerSession::ChangeEntryL"));

   930 

   931 	// For purpose of changing a service entry, it is considered local as an MTM

   932 	// is not required to do the work.

   933 	if( entry.iType == KUidMsvServiceEntry )

   934 		local = ETrue;

   935 

   936 	// start the change for local or remote entries

   937 	if (local)

   938 		{

   939 		// Extract the owner ID from the message.

   940 		TSecureId ownerId = aMessage.Int1();

   941 

   942 		DoChangeLocalEntryL(entry, operationId, aMessage, ownerId);

   943 		}

   944 	else

   945 		DoChangeRemoteEntryL(entry, operationId, aMessage);

   946 

   947 	CleanupStack::PopAndDestroy(); // opData

   948 	}

   949 

   950 //

   951 // Changes the selection of id.

   952 //

   953 

   954 void CMsvServerSession::ChangeEntriesL(const RMessage2 &aMessage)

   955     {

   956      // Recover the operation data

   957      TMsvOp operationId = aMessage.Int0();

   958      HBufC8* opData = RecoverOperationData(operationId);

   959      // Check for NULL data entry to be changed, must have been given incorrect id for argument.

   960      if(opData == NULL)

   961          {

   962          aMessage.Complete(KErrArgument);

   963          return;

   964          }

   965      CleanupStack::PushL(opData);

   966 

   967      // unpack the data

   968      TMsvPackedOperation packedOperation(opData);

   969      

   970      CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;

   971      CleanupStack::PushL(selection);

   972      TInt target,temp;

   973      packedOperation.UnpackL(*selection, target, temp);

   974 

   975      if (selection->Count() == 0)

   976          {

   977          PanicClient(aMessage, EMsvNoEntriesInChangeSelection);

   978          aMessage.Complete(KErrNotFound);

   979          return;

   980          }

   981      // Find the first entry in the selection which exists

   982      TInt count=selection->Count();

   983      while (count--)

   984          {

   985          TBool entryExsists = EFalse;

   986          entryExsists = iMsvServer.IndexAdapter().EntryExists(selection->At(count));

   987          if (entryExsists)

   988              break;

   989          }

   990  

   991        // Check if the entry is local or the entry is a service

   992       TBool local=ETrue;

   993       TMsvEntry* entry=NULL;

   994       User::LeaveIfError(iMsvServer.IndexAdapter().GetEntry(selection->At(0), entry));

   995      

   996       // Police request - client must be able to modify the entry.

   997       iMsvServer.PoliceModifyEntryL(aMessage, *entry, local, __PLATSEC_DIAGNOSTIC_STRING("Checked by CMsvServerSession::ChangeEntryL"));

   998              

   999       // For purpose of changing a service entry, it is considered local as an MTM

  1000       // is not required to do the work.

  1001       if( entry->iType == KUidMsvServiceEntry )

  1002           local = ETrue;

  1003 

  1004       // start the change for local or remote entries

  1005       if (local)

  1006           {

  1007           // Extract the owner ID from the message.

  1008           TSecureId ownerId = aMessage.Int1();

  1009 

  1010           DoChangeLocalEntriesL(selection, operationId, aMessage, ownerId, target);

  1011           }

  1012       else

  1013           DoChangeRemoteEntriesL(selection, operationId, aMessage,target);

  1014 

  1015       CleanupStack::PopAndDestroy(); // opData

  1016     }

  1017 

  1018 void CMsvServerSession::DoChangeLocalEntriesL(CMsvEntrySelection*& aSelection, TMsvOp aOpId, const RMessage2 &aMessage, TSecureId aOwnerId, TInt mark)

  1019     {

  1020     CMsvLocalChangeEntriesOperation* operation = new(ELeave) CMsvLocalChangeEntriesOperation(aMessage, aOpId, aSelection, iMsvServer,mark);

  1021     CleanupStack::Pop(); // selection

  1022     CleanupStack::PushL(operation);

  1023    

  1024     TBool forcedUpdate = (aOwnerId != aMessage.SecureId());

  1025     operation->StartL(aOwnerId, forcedUpdate);

  1026 

  1027     iOperations.AppendL(operation);

  1028     CleanupStack::Pop(); // operation

  1029 

  1030     

  1031     }

  1032 

  1033 void CMsvServerSession::DoChangeRemoteEntriesL(CMsvEntrySelection*& aSelection, TMsvOp aOpId, const RMessage2 &aMessage,TInt mark)

  1034 //

  1035 // Change a selection of entry under a remote service

  1036 //

  1037     {

  1038      // make sure that the operation can be added to the list

  1039      iOperations.SetReserveL(iOperations.Count()+1);

  1040 

  1041      TMsvEntry* entry=NULL;

  1042      User::LeaveIfError(iMsvServer.IndexAdapter().GetEntry(aSelection->At(0), entry));

  1043  

  1044      // create the operation

  1045      CMsvMtmOperation* operation = CMsvMtmOperation::NewL(aMessage, aOpId, entry->iMtm, entry->iServiceId, iSessionId, iMsvServer);

  1046      CleanupStack::Pop(); // aSelection

  1047      CleanupStack::PushL(operation);

  1048      operation->ChangeEntriesL(aSelection,mark);

  1049      

  1050      iMsvServer.StartOperationL(*operation, iSessionId, aMessage, ETrue);

  1051      iOperations.AppendL(operation); // will not fail - see start of function

  1052      CleanupStack::Pop(); // operation

  1053 	}

  1054 

  1055 

  1056 void CMsvServerSession::DoChangeLocalEntryL(const TMsvEntry& aEntry, TMsvOp aOpId, const RMessage2 &aMessage, TSecureId aOwnerId)

  1057 //

  1058 // Create a local entry in the index

  1059 //

  1060 	{

  1061 	CMsvLocalChangeOperation* operation = new(ELeave) CMsvLocalChangeOperation(aMessage, aOpId, aEntry, iMsvServer);

  1062 	CleanupStack::PushL(operation);

  1063 	// Check the given owner ID - if NULL then this is not a forced update, but

  1064 	// need to set the ID to that of the requesting process.

  1065 	TBool forcedUpdate = (aOwnerId != aMessage.SecureId());

  1066 

  1067 	operation->StartL(aOwnerId, forcedUpdate);

  1068 	iOperations.AppendL(operation);

  1069 	CleanupStack::Pop(); //operation

  1070 	}

  1071 

  1072 

  1073 void CMsvServerSession::DoChangeRemoteEntryL(const TMsvEntry& aEntry, TMsvOp aOpId, const RMessage2 &aMessage)

  1074 //

  1075 // Change a entry under a remote service

  1076 //

  1077 	{

  1078 	// make sure that the operation can be added to the list

  1079 	iOperations.SetReserveL(iOperations.Count()+1);

  1080 

  1081 	// create the operation

  1082 	CMsvMtmOperation* operation = CMsvMtmOperation::NewL(aMessage, aOpId, aEntry.iMtm, aEntry.iServiceId, iSessionId, iMsvServer);

  1083 	CleanupStack::PushL(operation);

  1084 	operation->ChangeL(aEntry);

  1085 	iMsvServer.StartOperationL(*operation, iSessionId, aMessage, ETrue);

  1086 	iOperations.AppendL(operation); // will not fail - see start of function

  1087 	CleanupStack::Pop(); // operation

  1088 	}

  1089 

  1090 

  1091 void CMsvServerSession::PackEntryAndWriteBufferL(const RMessage2 &aMessage, const TInt aParam, const TMsvEntry& aEntry, const TMsvId& aServiceId)

  1092 //

  1093 //

  1094 	{

  1095 	// package the entry and service id in same buffer

  1096 	TMsvPackedEntry packedEntry(iBuffer);

  1097 	TInt error = packedEntry.PackEntryAndService(aEntry, aServiceId);

  1098 	while(error!=KErrNone)

  1099 		{

  1100 		// increase the size of the buffer and try again

  1101 		iBuffer->Des().SetLength(0); // to avoid copying contents

  1102 		iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength);

  1103 		error = packedEntry.PackEntryAndService(aEntry, aServiceId);

  1104 		}

  1105 	// max destination length is passed from client

  1106 	TInt maxDesLen = aMessage.Int2();

  1107     if (maxDesLen < iBuffer->Des().Length())

  1108 		{

  1109         User::Leave(KErrOverflow);

  1110 		}

  1111 

  1112     aMessage.WriteL(aParam, iBuffer->Des());

  1113 	}

  1114 

  1115 void CMsvServerSession::GetEntryL(const RMessage2 &aMessage)

  1116 //

  1117 // Returns the index entry for the given id

  1118 //

  1119 	{

  1120 	// copy across the entry id to get

  1121 	TMsvId id = aMessage.Int0();

  1122 	TMsvEntry* entryPtr;

  1123 	TSecureId ownerId;

  1124 	TInt error = KErrNone;

  1125 	error = iMsvServer.IndexAdapter().GetEntry(id, entryPtr, ownerId);

  1126 	if (error==KErrNone)

  1127 		{

  1128 		// Police request - client must be able to read the entry.

  1129 		iMsvServer.PoliceReadEntryL(aMessage, ownerId, __PLATSEC_DIAGNOSTIC_STRING("Checked by CMsvServerSession::GetEntryL"));

  1130 

  1131 		// get the owning service and write that back

  1132 		TMsvId service;

  1133 		if (id == KMsvRootIndexEntryId)

  1134 			service = KMsvRootIndexEntryId;

  1135 		else