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 		default:

   582 			PanicClient(aMessage, EMsvBadRequest);

   583 			break;

   584 		}

   585 	}

   586 

   587 

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

   589 //

   590 // The client is requesting notifcation of any changes

   591 //

   592 	{

   593 	if (iRequestQueued)

   594 		{

   595 		PanicClient(aMessage, EMsvDuplicatedChangeRequest);

   596 		return;

   597 		}

   598 

   599 	if (iChangeBuffer->IsEmpty())

   600 		{

   601 		// queue this request until a change occurs

   602 		iQueuedMessage = aMessage;

   603 		iRequestQueued = ETrue;

   604 		}

   605 	else

   606 		{

   607 		// inform client of change which has been queued

   608 		SendNotificationL(aMessage);

   609 		}

   610 	}

   611 

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

   613 	{

   614 	// inform client of change which has been queued

   615 	TPckgBuf<TUint32> sequence;

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

   617 

   618 	// Tell the client the notification sequence number

   619 	aMessage.WriteL(1, sequence);

   620 

   621 #ifndef _NO_SERVER_LOGGING_

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

   623 #endif

   624 

   625 	aMessage.Complete(KErrNone);

   626 	iChangeBuffer->Out();

   627 	}

   628 

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

   630 //

   631 // The client is cancelling the outstanding request

   632 //

   633 	{

   634 	if (iRequestQueued)

   635 		{

   636 		iQueuedMessage.Complete(KErrNone);

   637 		iRequestQueued = EFalse;

   638 		}

   639 	aMessage.Complete(KErrNone);

   640 	}

   641 

   642 

   643 

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

   645 //

   646 // Copies a buffer from the client

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

   648 //

   649 	{

   650 	TInt desLen = aMessage.GetDesLength(aParam);

   651 

   652 	if(desLen >= 0)

   653 		{

   654 		TBool alloced=EFalse;

   655 		HBufC8* localBuffer=NULL;

   656 		

   657 		if (aBuffer==NULL)

   658 			{

   659 			localBuffer = HBufC8::NewLC(desLen);

   660 			alloced=ETrue;

   661 			}

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

   663 			{

   664 			// we have to increase the size of iBuffer

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

   666 			localBuffer = aBuffer->ReAlloc(desLen);

   667 			if (localBuffer==NULL)

   668 				{

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

   670 				}

   671 			}

   672 		

   673 		if(localBuffer)

   674 			{

   675 			TPtr8 desPtr = localBuffer->Des();

   676 			aMessage.ReadL(aParam, desPtr);

   677 				

   678 			if (alloced)

   679 				{

   680 				CleanupStack::Pop(); // localBuffer

   681 				}

   682 			

   683 			aBuffer = localBuffer;  

   684 			}

   685 		//use aBuffer

   686 		else

   687 			{

   688 			TPtr8 desPtr = aBuffer->Des();

   689 			aMessage.ReadL(aParam, desPtr); 

   690 			}

   691 		}

   692 	else

   693 		{

   694 		// desLen is negative leave with an error.

   695 		User::Leave(KErrArgument);

   696 		}

   697 	}

   698 

   699 

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

   701 //

   702 // Copies the packed entry buffer from the client

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

   704 //

   705 	{

   706 	TInt desLen = aMessage.GetDesMaxLength(aParam);

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

   708 		User::Leave(KErrOverflow);

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

   710 	}

   711 

   712 

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

   714 //

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

   716 //

   717 	{

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

   719 	if (error)

   720 		{

   721 		User::Leave(error);

   722 		}

   723 	}

   724 

   725 

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

   727 //

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

   729 //

   730 	{

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

   732 	if (error)

   733 		{

   734 		User::Leave(error);

   735 		}

   736 	}

   737 

   738 

   739 

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

   741 //

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

   743 //

   744 	{

   745 	TMsvOp operationId = aMessage.Int0();

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

   747 	CleanupStack::PushL(opData);

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

   749 	iOperationDataArray.AppendL(opData);

   750 	CleanupStack::Pop(); // opData

   751 	aMessage.Complete(KErrNone);

   752 	}

   753 

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

   755 //

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

   757 //

   758 	{

   759 	TMsvOp operationId = aMessage.Int0();

   760 	// operation data

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

   762 	CleanupStack::PushL(opData);

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

   764 

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

   766 	// the operationData array

   767 	TMsvPackedOperation packedOperation(opData->iBuffer);

   768 	CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;

   769 	CleanupStack::PushL(selection);

   770 	TInt command, temp;

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

   772 	CleanupStack::PopAndDestroy(selection);

   773 

   774 	iOperationDataArray.AppendL(opData);

   775 	

   776 	// additional parameter

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

   778 	CleanupStack::PushL(opParam);

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

   780 	iOperationDataArray.AppendL(opParam);

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

   782 	//

   783 	aMessage.Complete(KErrNone);

   784 	}

   785 

   786 

   787 HBufC8* CMsvServerSession::RecoverOperationData(TMsvOp aOpId)

   788 //

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

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

   791 //

   792 	{

   793 	// find the data

   794 	TInt count = 0;

   795 	TInt totalCount=iOperationDataArray.Count();

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

   797 		{

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

   799 			break;

   800 		}

   801 	// Panic during debug if cannot find data

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

   803 	// At runtime, return NULL.

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

   805 		{

   806 		return NULL;

   807 		}

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

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

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

   811 	delete iOperationDataArray.At(count);

   812 	iOperationDataArray.Delete(count);

   813 	return opData;

   814 	}

   815 

   816 

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

   818 //

   819 // Create a entry in the index

   820 //

   821 	{

   822 	// Recover the operation data

   823 	TMsvOp operationId = aMessage.Int0();

   824 	HBufC8* opData = RecoverOperationData(operationId);

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

   826 	if(opData == NULL)

   827 		{

   828 		aMessage.Complete(KErrArgument);

   829 		return;

   830 		}

   831 	

   832 	CleanupStack::PushL(opData);

   833 	// Unpack the data

   834 	TMsvPackedEntry packedEntry(opData);

   835 	TMsvEntry entry;

   836 	packedEntry.UnpackEntry(entry);

   837 

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

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

   840 		{

   841 		PanicClient(aMessage, EMsvIncorrectEntry);

   842 		User::Leave(KErrNotSupported);

   843 		}

   844 

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

   846 	TBool local=ETrue;

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

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

   849 

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

   851 	// is not required to do the work.

   852 	if( entry.iType == KUidMsvServiceEntry )

   853 		local = ETrue;

   854 

   855 	// start the change for local or remote entries

   856 	if (local)

   857 		{

   858 		TSecureId ownerId = aMessage.Int1();

   859 

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

   861 		}

   862 	else

   863 		DoCreateRemoteEntryL(entry, operationId, aMessage);

   864 

   865 	CleanupStack::PopAndDestroy(); // opData

   866 	}

   867 

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

   869 //

   870 // Create a local entry in the index

   871 //

   872 	{

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

   874 	CleanupStack::PushL(operation);

   875 	iOperations.AppendL(operation);

   876 	CleanupStack::Pop(operation);

   877 	operation->Start(aOwnerId);

   878 	}

   879 

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

   881 //

   882 // Create a remote entry in the index

   883 //

   884 	{

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

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

   887 

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

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

   890 	CleanupStack::PushL(operation);

   891 	operation->CreateL(aEntry);

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

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

   894 	CleanupStack::Pop(); // operation

   895 	}

   896 

   897 

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

   899 //

   900 // Changes the entry

   901 //

   902 	{

   903 	// Recover the operation data

   904 	TMsvOp operationId = aMessage.Int0();

   905 	HBufC8* opData = RecoverOperationData(operationId);

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

   907 	if(opData == NULL)

   908 		{

   909 		aMessage.Complete(KErrArgument);

   910 		return;

   911 		}

   912 		

   913 	CleanupStack::PushL(opData);

   914 	// Unpack the data

   915 	TMsvPackedEntry packedEntry(opData);

   916 	TMsvEntry entry;

   917 	packedEntry.UnpackEntry(entry);

   918 

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

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

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

   922 		User::Leave(KErrNotSupported);

   923 

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

   925 	TBool local=ETrue;

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

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

   928 

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

   930 	// is not required to do the work.

   931 	if( entry.iType == KUidMsvServiceEntry )

   932 		local = ETrue;

   933 

   934 	// start the change for local or remote entries

   935 	if (local)

   936 		{

   937 		// Extract the owner ID from the message.

   938 		TSecureId ownerId = aMessage.Int1();

   939 

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

   941 		}

   942 	else

   943 		DoChangeRemoteEntryL(entry, operationId, aMessage);

   944 

   945 	CleanupStack::PopAndDestroy(); // opData

   946 	}

   947 

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

   949 //

   950 // Create a local entry in the index

   951 //

   952 	{

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

   954 	CleanupStack::PushL(operation);

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

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

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

   958 

   959 	operation->StartL(aOwnerId, forcedUpdate);

   960 	iOperations.AppendL(operation);

   961 	CleanupStack::Pop(); //operation

   962 	}

   963 

   964 

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

   966 //

   967 // Change a entry under a remote service

   968 //

   969 	{

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

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

   972 

   973 	// create the operation

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

   975 	CleanupStack::PushL(operation);

   976 	operation->ChangeL(aEntry);

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

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

   979 	CleanupStack::Pop(); // operation

   980 	}

   981 

   982 

   983 void CMsvServerSession::PackEntryAndWriteBufferL(const RMessage2 &aMessage, const TInt aParam, const TMsvEntry& aEntry)

   984 //

   985 //

   986 //

   987 	{

   988 	// package the entry

   989 	TMsvPackedEntry packedEntry(iBuffer);

   990 	TInt error = packedEntry.PackEntry(aEntry);

   991 	while(error!=KErrNone)

   992 		{

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

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

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

   996 		error = packedEntry.PackEntry(aEntry);

   997 		}

   998 	WriteBufferL(aMessage, aParam);

   999 	}

  1000 

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

  1002 //

  1003 // Returns the index entry for the given id

  1004 //

  1005 	{

  1006 	// copy across the entry id to get

  1007 	TMsvId id = aMessage.Int0();

  1008 	TMsvEntry* entryPtr;

  1009 	TSecureId ownerId;

  1010 	TInt error = KErrNone;

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

  1012 	if (error==KErrNone)

  1013 		{

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

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

  1016 

  1017 		// get the owning service and write that back

  1018 		TPckgBuf<TMsvId> service;

  1019 		if (id==KMsvRootIndexEntryId)

  1020 			service()=KMsvRootIndexEntryId;

  1021 		else

  1022 			{

  1023 			iMsvServer.IndexAdapter().OwningService(id, service()); // error ignore as the entry exists

  1024 			}

  1025 

  1026 		WriteL(aMessage, 2, service);

  1027 		// write the entry back

  1028 		PackEntryAndWriteBufferL(aMessage, 1, *entryPtr);

  1029 		}

  1030 	aMessage.Complete(error);

  1031 	}

  1032 

  1033 void CMsvServerSession::OutstandingOperationsL(const RMessage2& aMessage)

  1034 	{

  1035 	TPckgBuf<TInt> outstanding;

  1036 	outstanding() = iMsvServer.OutstandingOperations() > 0;

  1037 	WriteL(aMessage, 0, outstanding);

  1038 	aMessage.Complete(KErrNone);

  1039 	}

  1040 

  1041 void CMsvServerSession::GetNotifySequenceL(const RMessage2& aMessage)

  1042 	{

  1043 	TPckgBuf<TUint32> sequence;

  1044 	sequence() = iChangeBuffer->NotifySequence();

  1045 	WriteL(aMessage, 0, sequence);

  1046 	aMessage.Complete(KErrNone);

  1047 	}

  1048 

  1049 void CMsvServerSession::GetChildrenL(const RMessage2 &aMessage)

  1050 //

  1051 // Gets the children of an entry

  1052 //

  1053 	{

  1054 	// reset

  1055 	iChildrenSelection->Reset();

  1056 	iChildrenSelectionIds->Reset();

  1057 

  1058 	// copy across the children details structure

  1059 	TPckgBuf<TMsvChildrenDetails> children;

  1060 	aMessage.ReadL(0, children);

  1061 

  1062 	// Check that the children details arguments are empty. Panic in debug mode but try to handle it gracefully in

  1063 	// release code.

  1064 	__ASSERT_DEBUG( children().iTotalNumberChildren==0 &&

  1065 					children().iNumberChildrenInArray==0, PanicServer(EMsvChildrenDetailsNotEmpty2));

  1066 

  1067 	if( children().iTotalNumberChildren != 0 || children().iNumberChildrenInArray != 0 )

  1068 		{

  1069 		aMessage.Complete(KErrArgument);

  1070 		return;

  1071 		}

  1072 		

  1073 #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT)

  1074 	// Return error, if the passed parent-id 

  1075 	// is a non-current standard id.

  1076 	if( (IsStandardId(children().iParentId)) &&

  1077 		(KCurrentDriveId != GetDriveId(children().iParentId))

  1078 	  )

  1079 		{

  1080 		aMessage.Complete(KErrArgument);

  1081 		return;

  1082 		}	   

  1083 #endif

  1084 

  1085 	// copy across the sort order

  1086 	TPckgBuf<TMsvSelectionOrdering> order;

  1087 	aMessage.ReadL(1, order);

  1088 

  1089 	// get the children as a selection

  1090 	// Need to filter the list via the client secure ID if the client is not

  1091 	// trusted with Read User Data.

  1092 	TBool filterByOwnerId = !aMessage.HasCapability(ECapabilityReadUserData);

  1093 	iMsvServer.IndexAdapter().GetChildrenL(children().iParentId, *iChildrenSelection, order(), KUidMsvNullEntry, filterByOwnerId, aMessage.SecureId());

  1094 	// return number of children

  1095 	children().iTotalNumberChildren = iChildrenSelection->Count();

  1096 

  1097 	// package up the entries

  1098 	iBuffer->Des().SetMax();

  1099 	TMsvPackedEntryArray packedEntryArray(iBuffer);

  1100 	TInt count=0;

  1101 	TInt error=KErrNone;

  1102 	TInt totalCount=iChildrenSelection->Count();

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

  1104 		{

  1105 		error = packedEntryArray.PackEntry(*iChildrenSelection->At(count));

  1106 		if (error)

  1107 			{

  1108 			children().iLastEntryInArray = count;

  1109 			break;

  1110 			}

  1111 		}

  1112 	// return number of children in the array

  1113 	children().iNumberChildrenInArray = count;

  1114 

  1115 	// Try to write the buffer to the client (if any entries are in the array)

  1116     if (children().iNumberChildrenInArray)

  1117     	{

  1118         TRAPD(bufferError, WriteL(aMessage, 2, iBuffer->Des()));

  1119         if(bufferError!=KErrNone)

  1120         	{

  1121         	// Writing data into client buffer is failed, we should not send incorrect count to client.

  1122 			error = bufferError;

  1123         	children().iNumberChildrenInArray = 0;

  1124         	children().iLastEntryInArray = 0;

  1125         	}

  1126         }

  1127 

  1128 	// write the children to client

  1129 	WriteL(aMessage, 0, children);

  1130 

  1131 	if (error==KErrNone)

  1132 		{

  1133 		// reset the member data

  1134 		iChildrenSelection->Reset();