1 // Copyright (c) 1997-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 #include "agssess.h"

    17 

    18 #include "agmattachment.h"

    19 #include "agscategoryindex.h"

    20 #include "agscategorylist.h"

    21 #include "agmentry.h"

    22 #include "agsiterator.h"

    23 #include "agsentrymodel.h"

    24 #include "agmpanic.h"

    25 #include "agmcategory.h"

    26 #include "agmcontent.h"

    27 #include "agmserv.h"

    28 #include "agsfilemanager.h"

    29 #include "agsmain.h"

    30 #include "calcommonimpl.h"

    31 #include "agmdebug.h"

    32 #include "agmtzrules.h"

    33 #include "agssortinstance.h"

    34 #include "agsinstanceiterator.h"

    35 #include "agmsortcriteria.h"

    36 #include "agmdate.h"

    37 #include "agssort.h"

    38 #include "agmcalendarinfo.h"

    39 #include "calsessionimpl.h"

    40 #include "agmfilechangenotification.h"

    41 #ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

    42 #include "agssystemstateobserver.h"

    43 #endif

    44 

    45 #include <apparc.h>

    46 #include <s32file.h>

    47 

    48 //

    49 // CAgnServerSession

    50 //

    51 

    52 const TInt KGranFilteredEntries = 20;

    53 const TInt KMaxNumberOfBufferedNotifications = 50;

    54 const TInt KGranNotificationBuffer = 64;

    55 

    56 const TInt KSlot0 = 0;

    57 const TInt KSlot1 = 1;

    58 const TInt KSlot2 = 2;

    59 const TInt KSlot3 = 3;

    60 

    61 void CleanupCloseAgendaImmediately(TAny* aRef)

    62     {

    63     if (aRef)

    64         {

    65         static_cast<CAgnServFile*>(aRef)->CloseAgenda(ETrue);

    66         }

    67     }

    68 

    69 TAgnChangeFilter::TAgnChangeFilter(CAgnServerSession& aSession) :

    70 	iChangeBroadcastEnabled(ETrue),

    71 	iSession(aSession),

    72 	iStartTimeUtc(Time::NullTTime()),

    73 	iEndTimeUtc(Time::NullTTime()),

    74 	iPubSubChangeMadeDuringDisable(ENoChange),

    75 	iPubSubEnabled(ETrue)

    76 	{

    77 	}

    78 

    79 TBool TAgnChangeFilter::ChangeBroadcastEnabled() const

    80 	{

    81 	return iChangeBroadcastEnabled;

    82 	}

    83 	

    84 const CAgnServerSession& TAgnChangeFilter::Session() const

    85 	{

    86 	return iSession;

    87 	}

    88 

    89 void TAgnChangeFilter::SetEnableChangeBroadcast(TBool aBool)

    90 	{

    91 	iChangeBroadcastEnabled = aBool;

    92 	}

    93 

    94 TBool TAgnChangeFilter::ChangeMadeWhileDisabled() const

    95 	{

    96 	return iChangeMadeWhileDisabled;

    97 	}

    98 	

    99 void TAgnChangeFilter::SetChangeMadeWhileDisabled(TBool aBool)

   100 	{

   101 	iChangeMadeWhileDisabled = aBool;	

   102 	}

   103 

   104 void TAgnChangeFilter::SetChangeParameter(const TTime& aStartTime, const TTime& aEndTime, MCalChangeCallBack2::TChangeEntryType aChangeType)

   105 	{

   106 	iStartTimeUtc = aStartTime;

   107 	iEndTimeUtc = aEndTime;

   108 	iEntryType = aChangeType;

   109 	}

   110 

   111 TBool TAgnChangeFilter::CheckChangeWithinRangeL(const CAgnRptDef* aRptDef, const TTime& aStartTime, const TTime& aEndTime) const

   112 	{

   113 	TBool entryInTimeRange = ETrue;

   114 	if (aRptDef)

   115 		{

   116 		TTime nudgedNextTimeUtc;

   117 		TBool nextDateExists = aRptDef->NudgeNextInstanceUtcL(iStartTimeUtc, nudgedNextTimeUtc);

   118 		if ( ! nextDateExists || nudgedNextTimeUtc > iEndTimeUtc)

   119 			{

   120 			entryInTimeRange = EFalse;

   121 			}

   122 		}

   123 	else

   124 		{

   125 		if (iStartTimeUtc > aEndTime || iEndTimeUtc < aStartTime)

   126 			{

   127 			entryInTimeRange = EFalse;

   128 			}

   129 		}

   130 	return entryInTimeRange;

   131 	}

   132 			

   133 TBool TAgnChangeFilter::IsValidChangeL(const TAgnChange& aChange) const

   134 	{

   135 	if (aChange.iOperationType != MCalChangeCallBack2::EChangeUndefined)

   136 		{

   137 		if (iEntryType == MCalChangeCallBack2::EChangeEntryTodo && aChange.iEntryType != CCalEntry::ETodo)

   138 			{

   139 			return EFalse;

   140 			}

   141 		if (iEntryType == MCalChangeCallBack2::EChangeEntryEvent && aChange.iEntryType == CCalEntry::ETodo)

   142 			{

   143 			return EFalse;

   144 			}

   145 		

   146 		// Check the entry is within the time range specified by the filter

   147 		// aChange.iRepeatRule gives the repeat data for the newly stored entry. If this operation is an update,

   148 		// then aChange.iOriginalRepeatRule gives the repeat data for the old entry.

   149 		TBool entryInTimeRange = CheckChangeWithinRangeL(aChange.iRepeatRule, aChange.iStartTimeOfEntryUtc, aChange.iEndTimeOfEntryUtc);

   150 		TBool originalEntryInTimeRange = CheckChangeWithinRangeL(aChange.iOriginalRepeatRule, aChange.iOriginalStartTimeUtc, aChange.iOriginalEndTimeUtc);

   151 			

   152 		if (iEntryType != MCalChangeCallBack2::EChangeEntryEvent)

   153 			{

   154 			if (aChange.iEntryType == CCalEntry::ETodo && aChange.iStartTimeOfEntryUtc == Time::NullTTime() &&  aChange.iEndTimeOfEntryUtc == Time::NullTTime())

   155 				{

   156 				return ETrue;

   157 				}

   158 			}

   159 		

   160 		if ( ! entryInTimeRange && ! originalEntryInTimeRange)

   161 			{

   162 			return EFalse;

   163 			}

   164 		}

   165 	return ETrue;

   166 	}

   167 	

   168 TBool TAgnChangeFilter::PubSubEnabled() const

   169 	{

   170 	return iPubSubEnabled;

   171 	}

   172 

   173 void TAgnChangeFilter::SetPubSubChange(TPubSubChange aChange)

   174 	{

   175 	if(aChange==ENoChange)

   176 		{//clear all bits

   177 		iPubSubChangeMadeDuringDisable = ENoChange; // = 0

   178 		}

   179 	else

   180 		{

   181 		iPubSubChangeMadeDuringDisable = iPubSubChangeMadeDuringDisable | aChange;

   182 		}

   183 	}

   184 	

   185 TBool TAgnChangeFilter::TodoChanged() const

   186 	{

   187 	return iPubSubChangeMadeDuringDisable & ETodoChanged;

   188 	}

   189 

   190 void TAgnChangeFilter::SetEnablePubSubNotification(TBool aEnablePubSubNotification)

   191 	{

   192 	iPubSubEnabled = aEnablePubSubNotification;

   193 	}

   194 	

   195 CAgnServerSession::CAgnServerSession(CAgnServer& aServer)

   196     :iAgnServer(aServer), iSessionReady(ETrue)

   197 	{

   198 	iAgnServer.SessionAdded();

   199 	}

   200 

   201 CAgnServerSession* CAgnServerSession::NewL(CAgnServer& aServer)

   202     {

   203     CAgnServerSession* self = new (ELeave) CAgnServerSession(aServer);

   204     CleanupStack::PushL(self);

   205     self->ConstrucL();

   206     CleanupStack::Pop(self);

   207     return self;

   208     }

   209 

   210 void CAgnServerSession::ConstrucL()

   211     {

   212     iAgnSessionFileManager = CAgnSessionFileManager::NewL(*this, *(iAgnServer.FileMgr()));

   213     }

   214 

   215 void CAgnServerSession::ServiceL(const RMessage2 &aMessage)

   216 	{

   217 	TBool complete = ETrue;

   218 	TInt err = KErrNone;

   219 	iMessage = aMessage;

   220 	

   221 #ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

   222 	if (iAgnServer.SystemStateObserver().IsShutdownInProgress())

   223 		{

   224 		//Shutdown in progress

   225 		err = IsReadOnlyOperation();

   226 		complete = ETrue;

   227 		}

   228 #endif

   229 	if (err == KErrNone)

   230 		{

   231 	    TRAP(err,complete = DispatchMessageL());

   232 	    _DBGLOG_IPC(AgmDebug::DebugLogIPCL(aMessage.Function(), TInt(this), err);)

   233 

   234 	    if ( err != KErrNone )

   235 	    	{

   236 	    	if (err == KErrNotReady && 

   237 	    			aMessage.Function() != ETransferAttachmentFileToServer &&

   238 	    			aMessage.Function() != ETransferFileToClientToWrite &&

   239 	    			aMessage.Function() != ETransferAttachmentFileToClient&&

   240 	    			aMessage.Function() != EMoveFileToServer)

   241 	    		{

   242 	    		// If a function has failed with Not ready, then a drive must not be ready

   243 	    		// If it is not an attachment failure, then it must have happened on the drive containing

   244 	    		// the Calendar file. In this case, ensure the session always leaves with KErrNotReady

   245 	    		// until the session is closed and re-opened.

   246 	    		iSessionReady = EFalse;

   247 	    		}

   248 	    	delete iBuffer;

   249 	    	iBuffer = NULL;

   250 	    	}

   251 		}

   252 		

   253 	if (complete && err != KClientHasBeenPanicked)

   254 		{

   255 		aMessage.Complete(err);

   256 		}

   257 	}

   258 

   259 CAgnServerSession::~CAgnServerSession()

   260 	{

   261 	//This is required for robustness. Clients which are incorrectly

   262 	//written can make requests with MCalProgressCallBack callbacks could

   263 	//subsequently panic and cause the session to be destructed. 

   264 	//The task which the client had initiated will be cancelled so it does not

   265 	//attempt to use the session again with further progress information.

   266 	

   267 	CancelAllTask();

   268  

   269 	// Cleanup any resources that have been allocated

   270 	delete iBuffer;

   271 	// Close the calendar file after a delay

   272 	CloseAgendas();

   273 	iAgnServer.SessionClosed();

   274 	delete iAgnSessionFileManager;

   275 	delete iInstanceIteratorMgr;

   276 	}

   277 

   278 /** 

   279 * Check to see if an operation can be performed due to backup\restore process

   280 * @return ETrue, if the operation can not be performed, EFalse otherwise. 

   281 */

   282 TBool CAgnServerSession::CheckBackupRestore()

   283     {

   284     if(iBackupRestoreLock  

   285     //All opeerations apart from the following ones are not allowed when Backup\Restore is in progress. 

   286     && iMessage.Function() != ECloseAgenda

   287     && iMessage.Function() != ECancelChangeNotification

   288     && iMessage.Function() != EDisableChangeBroadcast

   289     && iMessage.Function() != ETransmitBuffer

   290     && iMessage.Function() != ERequestChangeNotificationParameters

   291     && iMessage.Function() != ERequestChangeNotification

   292     && iMessage.Function() != EEnableChangeBroadcast

   293     && iMessage.Function() != EGetChangesSinceLastNotification

   294     && iMessage.Function() != ERequestProgress)

   295         {

   296         return ETrue;

   297         }

   298         

   299   // Return false, if iBackupRestoreLock is false or operations are those above, CAgnServFile::IsLocked()

   300   // will determine whether or not an operation can be performed.

   301     return EFalse;

   302     }

   303 

   304 TBool CAgnServerSession::DispatchMessageL()

   305 	{

   306     TBool operationRequiresFileLock = EFalse;

   307     TBool callIsAsynchronous = ETrue;

   308  	if(CheckBackupRestore())

   309 	    {

   310 	    User::Leave(KErrLocked);

   311 	    }

   312 

   313 	switch (iMessage.Function())

   314 		{

   315 		case EOpenAgenda:

   316 			{

   317 			OpenAgendaL();

   318 			iSessionReady = ETrue;

   319 			}

   320 			break;

   321 			

   322 		case ECloseAgenda:

   323 			{

   324 			// Close the calendar file after a delay

   325 			CloseAgendaL();

   326 			iSessionReady = ETrue;

   327 			}

   328 			break;

   329 	

   330 		case ERequestChangeNotificationParameters:

   331 			{

   332 			RequestChangeNotificationParametersL();

   333 			}			

   334 			break;

   335 			

   336 		case ERequestChangeNotification:

   337 			{

   338 			RequestChangeNotification();

   339 			callIsAsynchronous = EFalse;

   340 			}

   341 			break;

   342 

   343 		case ECancelChangeNotification:

   344 			{

   345 			CancelChangeNotification();

   346 			}

   347 			break;

   348 

   349 		case EDisableChangeBroadcast:

   350 			{

   351 			DisableChangeBroadcastL();

   352 			}

   353 			break;

   354 

   355 		case EEnableChangeBroadcast:

   356 			{

   357 			EnableChangeBroadcastL();

   358 			}

   359 			break;

   360 

   361 		case EAgnHeapSizeCount:

   362 			{

   363 			TInt allocSize;

   364 			User::Heap().AllocSize(allocSize);

   365 			TPckg<TInt> HeapSize(allocSize);

   366 			iMessage.WriteL(KSlot0, HeapSize);			

   367 			}

   368 			break;

   369 

   370 		case EAgnResourceCount:

   371 			{

   372 			TPckg<TInt> HeapCells(User::Heap().Count());

   373 			iMessage.WriteL(KSlot0, HeapCells);			

   374 			}

   375 			break;

   376 			

   377 		case EAgnSetHeapFailure:

   378 			{

   379 			User::__DbgSetAllocFail(RHeap::EUser,(RHeap::TAllocFail)iMessage.Int0(),iMessage.Int1());		

   380 			}

   381 			break;

   382 

   383 		case ECreateAgendaFile:

   384 			{

   385 			CreateAgendaFileL();			

   386 			}

   387   			break;

   388  

   389 		case EGetListFileNames:

   390 			{

   391 			ListAgendaFilesL();

   392 			}

   393 			break;

   394 

   395 		case EDeleteAgendaFile:

   396 			{

   397 	  		DeleteAgendaFileL();

   398 			}

   399 	  		break;

   400 

   401 		case ECancelTask:

   402 			{

   403 			CancelTaskL();

   404 			}

   405 			break;

   406 

   407 		case EAgendaFileExists:

   408 			{

   409 			AgendaFileExistsL();

   410 			}

   411 			break;

   412 

   413 		case ETransmitBuffer:

   414 			{

   415 			TransmitBufferL();

   416 			}

   417 			break;

   418 

   419 		case ESetUpdateAlarm:

   420 			{

   421 			SetUpdateAlarmL();

   422 			}

   423 			break;

   424 

   425 		case ESetEnablePubSubNotification:

   426 			{

   427 			SetEnablePubSubNotificationL();

   428 			}

   429 			break;

   430 

   431 		case ERequestProgress:

   432 			{

   433 			RequestProgressL();

   434 			callIsAsynchronous = EFalse; 

   435 			}

   436 			break;

   437 			

   438 		case EGetChangesSinceLastNotification:

   439 			{

   440 			GetChangesSinceLastNotificationL();

   441 			}

   442 			break;

   443 			

   444 		case EStartBuildIndex:

   445 			{

   446 			//Asynchronous call

   447 			StartBuildIndex();

   448 			callIsAsynchronous = EFalse; 

   449 			}

   450 			break;

   451 		case ETzDbChangedTime:

   452 			{

   453 			TzRulesLastModifiedDateTimeL();

   454 			}

   455 			break;

   456 		case ERollback:

   457 			{

   458 			RollbackL();

   459 			}

   460 			break;

   461 		case EGetFileChangesSinceLastNotification:

   462 		    {

   463 		    GetFileChangesSinceLastNotificationL();

   464 		    }

   465 		    break;

   466 		default:

   467 			{

   468 			operationRequiresFileLock = ETrue;

   469 			}

   470 			break;

   471 		}

   472 		

   473 	// Most commands are not permitted while the file is locked

   474     

   475     if ( operationRequiresFileLock )

   476 	    {

   477     	if ( ! iSessionReady)

   478 			{

   479 			User::Leave(KErrNotReady);

   480 			}

   481 		else

   482 			{

   483 			switch ( iMessage.Function() )

   484 				{

   485 				case EFetchEntry:

   486 					{

   487 					FetchEntryL();

   488 					}

   489 					break;

   490 				case EFetchEntryByUID:

   491 					{

   492 					FetchEntryByUIDL();

   493 					}

   494 					break;

   495 				case EFetchSimpleEntry:

   496 					{

   497 					FetchSimpleEntryL();

   498 					}

   499 					break;

   500 				case EFetchSimpleEntries:

   501 					{

   502 					FetchSimpleEntriesL();

   503 					}

   504 					break;

   505 				case EUpdateEntry:

   506 					{

   507 					UpdateEntryL();

   508 					}

   509 					break;

   510 				case EAddEntry:

   511 					{

   512 					AddEntryL();

   513 					}

   514 					break;

   515 				case EDeleteEntry:

   516 					{

   517 					DeleteEntryL();

   518 					}

   519 					break;

   520 				case EPreviousInstances:

   521 					{

   522 					PreviousInstancesL();

   523 					}

   524 					break;

   525 				case ENextInstances:

   526 					{

   527 					NextInstancesL();

   528 					}

   529 					break;

   530 				case ECreateEntryIterator:

   531 					{

   532 					CreateEntryIteratorL();

   533 					}

   534 					break;

   535 				case EEntryIteratorNext:

   536 					{

   537 					EntryIteratorNextL();

   538 					}

   539 					break;

   540 				case EEntryIteratorPosition:

   541 					{

   542 					EntryIteratorPositionL();

   543 					}

   544 					break;

   545 				case ECommit:

   546 					{

   547 					CommitL();

   548 					}

   549 					break;

   550 				case EGetEntryUidsSinceDate:

   551 					{

   552 					GetEntryUidsSinceDateL();

   553 					}

   554 					break;

   555 				case ERestoreText:

   556 					{

   557 					RestoreTextL();

   558 					}

   559 					break;

   560 				case ERestoreAlarmAction:

   561 					{

   562 					RestoreAlarmActionL();

   563 					}

   564 					break;

   565 				case EGetCategoryListCount:

   566 					{

   567 					GetCategoryListCountL();

   568 					}

   569 					break;

   570 				case EGetCategoryListItem:

   571 					{

   572 					GetCategoryListItemL();

   573 					}

   574 					break;

   575 				case EAddCategoryToList:

   576 					{

   577 					AddCategoryToListL();

   578 					}

   579 					break;

   580 				case ECategoryFilter:

   581 					{

   582 					FilterCategoryL();

   583 					}

   584 					break;

   585 				case ETidyByDateReadParams:

   586 					{

   587 					TidyByDateReadParamsL();

   588 					}

   589 					break;

   590 				case ETidyByDateStart:

   591 					{

   592 					TidyByDateStartL();

   593 					callIsAsynchronous = EFalse; 

   594 					}

   595 					break;

   596 				case ECategoryStart:

   597 					{

   598 					CategoryTaskStartL();

   599 					}

   600 					break;

   601 				case ECategoryStartAsyn:

   602 					{

   603 					AsynchCategoryTaskStartL();

   604 					callIsAsynchronous = EFalse;

   605 					}

   606 					break;

   607 				case EInstanceIteratorCreate:

   608 					{

   609 					CreateInstanceIteratorL();

   610 					}

   611 					break;

   612 				case EInstanceIteratorDestroy:

   613 					{

   614 					DestroyInstanceIteratorL();

   615 					}

   616 					break;

   617 				case EInstanceIteratorNext:

   618 					{

   619 					InstanceIteratorNextL();

   620 					}

   621 					break;

   622 				case EInstanceIteratorPrevious:

   623 					{

   624 					InstanceIteratorPreviousL();

   625 					}

   626 					break;

   627 				case EInstanceIteratorCount:

   628 					{

   629 					InstanceIteratorCountL();

   630 					}

   631 					break;

   632 				case EInstanceIteratorLocateIndex:

   633 					{

   634 					InstanceIteratorLocateIndexL();

   635 					}

   636 					break;

   637 				

   638 			// Group Scheduling

   639 				case EGetChangesSinceLastNotification:

   640 					{

   641 					GetChangesSinceLastNotificationL();

   642 					}

   643 					break;

   644 				case EFetchEntryByGuid:

   645 					{

   646 					FetchEntryByGuidL();

   647 					}

   648 					break;

   649 				case EFetchSimpleEntriesByGuid:

   650 					{

   651 					FetchSimpleEntriesByGuidL();

   652 					}

   653 					break;

   654 				case EDeleteEntriesByLocalUid:

   655 					{

   656 					DeleteEntriesByLocalUidL();

   657 					}

   658 					break;

   659 				case EDeleteEntryByGuid:

   660 					{

   661 					DeleteEntryByGuidL();

   662 					}

   663 					break;

   664 				case EFindInstances:

   665 					{

   666 					FindInstancesL();

   667 					}

   668 					break;

   669 				case ETransferAttachmentFileToServer:

   670 					{

   671 					TransferAttachmentFileToServerL();

   672 					}

   673 					break;

   674 				case ETransferAttachmentFileToClient:

   675 					{

   676 					TransferAttachmentFileToClientL();

   677 					callIsAsynchronous = EFalse;

   678 					}

   679 					break;

   680 				case ETransferFileToClientToWrite:

   681 					{

   682 					TransferFileToClientToWriteL();

   683 					callIsAsynchronous = EFalse;

   684 					}

   685 					break;

   686 				case EFetchSortedAttachments:

   687 					{

   688 					FetchSortedAttachmentsL();

   689 					}

   690 					break;

   691 				case EEntriesWithAttachment:

   692 					{

   693 					EntriesWithAttachmentL();

   694 					}

   695 					break;

   696 				case EFetchAttachmentById:

   697 					{

   698 					FetchAttachmentByIdL();

   699 					}

   700 					break;

   701 				case EMoveFileToServer:

   702 					{

   703 					MoveFileToServerL();

   704 					}

   705 					break;

   706 				case EFetchSimpleEntryByUID:

   707 					{

   708 					FetchSimpleEntryByUIDL();

   709 					}

   710 					break;

   711                case ESetCalendarInfo:

   712                     {

   713                     SetCalendarInfoL();

   714                     }

   715                     break;

   716                case EGetCalendarInfo:

   717                     {

   718                     GetCalendarInfoL();

   719                     }

   720                     break;

   721                case EGetPropertyValue:

   722                     {

   723                     GetPropertyValueL();

   724                     }

   725                     break;

   726 				default:

   727 					PanicClientL(EBadRequest);

   728 					return ETrue;

   729 				}

   730 			}

   731 		}

   732 	

   733 	// If the buffer size is greater than KInitialBufferSize, then the buffer cannot be 

   734 	// transmitted now. A large enough buffer must first be created on the client side to 

   735 	// hold this.

   736 	if ( iBuffer && iBuffer->Size() <= KInitialBufferSize && 

   737 		 iBuffer->Size() > 0 )

   738 		{

   739 		TransmitBufferL();

   740 		}

   741 

   742 	return callIsAsynchronous;	// complete normally

   743 	}

   744 

   745 void CAgnServerSession::SetUpdateAlarmL()

   746 	{

   747 	TBool updateAlarm = iMessage.Int0();

   748 	CAgnServFile* file = GetFileL(KSlot1);

   749 	file->Model()->SetUpdateAlarmL(updateAlarm);

   750 	}

   751 

   752 void CAgnServerSession::SetEnablePubSubNotificationL()

   753 	{

   754 	TBool enablePubsub = iMessage.Int0();

   755 	TPckgBuf<TInt64> fileId;

   756 	iMessage.ReadL(KSlot1, fileId);

   757 	

   758 	if(iAgnSessionFileManager)

   759 		{

   760 		CAgnSessionFile* client = NULL;

   761 		TRAPD(err, client = &(iAgnSessionFileManager->GetSessionFileL(fileId())));

   762 		if(err == KErrNone && client)

   763 		    {

   764 		    client->SetEnablePubSubNotificationL(enablePubsub);

   765 		    }

   766 		else if (err != KErrNotFound)

   767 		    {

   768 		    User::Leave(err);

   769 		    }		    

   770 		}

   771 	}

   772 

   773 void CAgnServerSession::PanicClientL(TInt aPanic) const

   774 	{

   775 	_LIT(KAgendaServerPanic,"AgnServer");

   776   	iMessage.Panic(KAgendaServerPanic,aPanic);

   777 	User::Leave(KClientHasBeenPanicked);

   778 	}

   779 

   780 //

   781 // Utility Functions:

   782 

   783 HBufC* CAgnServerSession::ReadClientDesLC(TInt aDesNum)

   784 	{

   785 	const TInt KDesLength = iMessage.GetDesLength(aDesNum);

   786 	if (KDesLength == KErrArgument)

   787 		{

   788         PanicClientL(EIndexError);

   789 		}

   790 	else if (KDesLength == KErrBadDescriptor)

   791 		{

   792         PanicClientL(EBadDescriptor);

   793 		}

   794 	User::LeaveIfError(KDesLength);

   795 

   796 	HBufC* readBuffer = HBufC::NewLC(KDesLength);

   797 	TPtr readPtr(readBuffer->Des());

   798 

   799 	TRAPD(ret, iMessage.ReadL(aDesNum, readPtr));

   800 	if (ret != KErrNone)

   801 		{

   802 		PanicClientL(EBadDescriptor);

   803 		}

   804 

   805 	return readBuffer;

   806 	}

   807 

   808 

   809 HBufC8* CAgnServerSession::ReadClientDes8LC(TInt aDesNum)

   810 	{

   811 	const TInt KDesLength = iMessage.GetDesLength(aDesNum);

   812 	if (KDesLength == KErrArgument)

   813 		{

   814         PanicClientL(EIndexError);

   815 		}

   816 	else if (KDesLength == KErrBadDescriptor)

   817 		{

   818         PanicClientL(EBadDescriptor);

   819 		}

   820 	User::LeaveIfError(KDesLength);

   821 	

   822 	HBufC8* readBuffer = HBufC8::NewLC(KDesLength);

   823 	TPtr8 readPtr(readBuffer->Des());

   824 

   825 	TRAPD(ret, iMessage.ReadL(aDesNum, readPtr));

   826 	if (ret != KErrNone)

   827 		{

   828 		PanicClientL(EBadDescriptor);

   829 		}

   830 

   831 	return readBuffer;

   832 	}	

   833 

   834 //

   835 //Server Functions:

   836 void CAgnServerSession::OpenAgendaL()

   837 	{

   838 	// Open a new file for this session

   839 	// Arguments:   0: Input - buffer contains name of file and session ID

   840 	//              1: Output - status

   841 	//              2: Output - file ID

   842 	//              3: Output - collection ID

   843 	//

   844 

   845 	// Get descriptor for filename to open

   846 	const TInt KBufferSize = iMessage.GetDesLengthL(KSlot0);

   847 	CBufFlat* buffer = CBufFlat::NewL(KBufferSize);

   848 	CleanupStack::PushL(buffer);

   849 	buffer->ExpandL(0, KBufferSize);

   850 	TPtr8 des(buffer->Ptr(0));

   851 	iMessage.ReadL(KSlot0, des);

   852 	RDesReadStream readStream(des);

   853 	HBufC* fileName = HBufC::NewLC(readStream, KMaxTInt);

   854 	TInt sessionId = readStream.ReadInt32L();	

   855 	CalCommon::TCalFileVersionSupport status;

   856 

   857 	HBufC* nameWithPath = iAgnServer.FileMgr()->ParseFilenameLC(*fileName);

   858 	CAgnServFile* file = iAgnServer.FileMgr()->GetFile(*nameWithPath);

   859 	TInt err = KErrNone;

   860 	if(file)

   861 		{

   862 		if(IsOwnFileL(sessionId, *file))

   863 			{//If this file has been opened by same CCalSession object

   864 			User::Leave(KErrAlreadyExists);

   865 			}

   866 		else if (FileHasBeenOpenedL(*file))

   867 			{//If this file has been opened by a different CCalSession object

   868 			User::Leave(KErrArgument);

   869 			} 

   870 		}

   871 	CleanupStack::PopAndDestroy(nameWithPath);

   872 	CloseAgendaL(sessionId);//Check if this CCalSession object has had opened a different file, if so, close it.      

   873 	TRAP(err, file = &iAgnServer.FileMgr()->OpenAgendaL(*fileName, iAgnServer, status));

   874 	CleanupStack::PopAndDestroy(fileName);

   875 	CleanupStack::PopAndDestroy(buffer);

   876 	User::LeaveIfError(err);

   877 	CleanupStack::PushL(TCleanupItem(CleanupCloseAgendaImmediately, file));

   878 	TPckg<TInt> theStatus(status);

   879 	iMessage.WriteL(KSlot1, theStatus);

   880 

   881 	__ASSERT_ALWAYS(file, User::Leave(KErrCorrupt));

   882 	TInt64 fileId = file->Model()->GetFileIdL();

   883 	TCalCollectionId shortFileId = file->CollectionId();

   884 	TPckg<TInt64> fileIdPackage(fileId);

   885 	iMessage.WriteL(KSlot2, fileIdPackage);

   886 	TPckg<TUint8> shortFileIdPackage(shortFileId);

   887 	iMessage.WriteL(KSlot3, shortFileIdPackage);

   888 	file->Model()->CategoryIndex().SetCategoryList(&(file->CategoryList()));

   889 	if(iAgnSessionFileManager->AddClientL(fileId, sessionId))

   890 		{

   891 		file->Model()->CheckTzDbModificationL();

   892 		}

   893 

   894 	// This is the cleanup item to close agenda if anything fails

   895 	CleanupStack::Pop(); 

   896 	}

   897 

   898 void CAgnServerSession::BackupReStoreChangedL(TInt64 aOldFileId, const CAgnServFile& aServFile, MCalChangeCallBack2::TChangeType aChangeType)

   899 	{

   900 	if(iAgnSessionFileManager)

   901 		{

   902 		TAgnChange change;

   903 		change.iOperationType = aChangeType;

   904 		

   905 		//reset model and file id if restore ends

   906 		if(aChangeType == MCalChangeCallBack2::ERestoreEnd)

   907 			{

   908 			iAgnSessionFileManager->ReSetModel(aOldFileId, aServFile);

   909 			change.iFileId = aServFile.Model()->GetFileIdL();

   910 			}

   911 		else

   912 			{

   913 			change.iFileId = aOldFileId;        

   914 			}

   915 		

   916 		iAgnSessionFileManager->AddChangeL(change);

   917 		}

   918 

   919 	if(aChangeType == MCalChangeCallBack2::EBackupStart || aChangeType == MCalChangeCallBack2::ERestoreStart)

   920 	   {

   921 	   LockClient(ETrue);

   922 	   }

   923 	else

   924 	   {

   925 	   LockClient(EFalse);

   926 	   }

   927 	}

   928 

   929 void CAgnServerSession::LockClient(TBool aLock)

   930 	{

   931 	iBackupRestoreLock = aLock;

   932 	}

   933 

   934 /** 

   935 * Closes the calendar file in the current agenda server session immediately or after a delay.

   936 * The delay is triggered using a timer owned by the calendar file. If a session then tries to access the same calendar file, the delay is cancelled and the file is not closed

   937 * @param aCloseImmediately EFalse if a delay is required before the closure of the calendar file, ETrue if the calendar file is to be closed immediately

   938 */

   939 void CAgnServerSession::CloseAgendaL()

   940 	{

   941 	TInt sessionId = iMessage.Int0();

   942 	CloseAgendaL(sessionId);

   943 	}

   944 

   945 void CAgnServerSession::CloseAgendaL(TInt aSessionId)

   946 	{

   947 	if(iAgnSessionFileManager)

   948 		{

   949 		TInt index = iAgnSessionFileManager->GetSessionFile(aSessionId);

   950 		CAgnServFile* file = NULL;

   951 		if(index >= 0)

   952 			{

   953 			TRAPD(err, file = iAgnServer.FileMgr()->GetFileL(iAgnSessionFileManager->GetSessionFileByIndex(index).FileId()));           

   954 			if(file && err == KErrNone)

   955 				{

   956 				User::LeaveIfError(iAgnServer.FileMgr()->CloseAgenda(*file, EFalse));

   957 				}       

   958 			iAgnSessionFileManager->DeleteSessionFile(aSessionId);           

   959 			}

   960 		}

   961 	}

   962 void CAgnServerSession::FetchEntryL()

   963 	{

   964 	// Fetch an entry from the agenda file

   965 	// Arguments: 0 : Output - Data Buffer

   966 	//			  1 : Input  - Entry Id to fetch

   967 	//			  2 : Output - Size of buffer

   968 	//			  3 : Input  - File Id

   969 	TPckgBuf<TAgnEntryId> entryId;

   970 	iMessage.ReadL(KSlot1, entryId);

   971 	

   972 	CAgnServFile* file = GetFileL(KSlot3);

   973 	if(file->IsLocked())

   974 		{

   975 		User::Leave(KErrLocked);

   976 		}

   977 	CAgnEntry* entry = file->Model()->FetchEntryL(entryId());

   978 	

   979 	if ( entry )

   980 		{

   981 		CleanupStack::PushL(entry);

   982 	

   983 		ExternalizeEntryToClientL(*entry, KSlot2);

   984 	

   985 		CleanupStack::PopAndDestroy(entry);

   986 		}

   987 	else

   988 		{

   989 		TPckg<TInt> size(0);

   990 		iMessage.WriteL(KSlot2, size);

   991 		}	

   992 	}

   993 

   994 

   995 void CAgnServerSession::FetchEntryByUIDL()

   996 	{

   997 	// Fetch an entry from the agenda file

   998 	// Arguments: 0 : Output - Data Buffer

   999 	//			  1 : Input  - Unique Id to fetch

  1000 	//			  2 : Output - Size of buffer

  1001 	//			  3 : Input  - File ID

  1002 

  1003 	TPckgBuf<TCalLocalUid> uniqueId;

  1004 	iMessage.ReadL(KSlot1, uniqueId);

  1005 	

  1006 	CAgnServFile* file = GetFileL(KSlot3);

  1007 	if(file->IsLocked())

  1008 		{

  1009 		User::Leave(KErrLocked);

  1010 		}

  1011 	CAgnEntry* entry = file->Model()->FetchEntryL(uniqueId());

  1012 	

  1013 	if ( entry )

  1014 		{

  1015 		CleanupStack::PushL(entry);

  1016 	

  1017 		ExternalizeEntryToClientL(*entry, KSlot2);

  1018 	

  1019 		CleanupStack::PopAndDestroy(entry);

  1020 		}

  1021 	else

  1022 		{

  1023 		TPckg<TInt> size(0);

  1024 		iMessage.WriteL(KSlot2, size);

  1025 		}	

  1026 	}

  1027 

  1028 

  1029 void CAgnServerSession::ExternalizeEntryToClientL(const CAgnEntry& aEntry, TInt aSlot)

  1030 	{

  1031 	delete iBuffer;

  1032 	iBuffer = NULL;

  1033 		

  1034 	iBuffer = CBufFlat::NewL(KInitialBufferSize);

  1035 

  1036 	// Create a write stream for this buffer

  1037 	RBufWriteStream bufStream;

  1038 	bufStream.Open(*iBuffer);

  1039 	CleanupClosePushL(bufStream);	

  1040 

  1041 	bufStream.WriteUint32L( aEntry.Type() );

  1042 	aEntry.ExternalizeToBufferL(bufStream);

  1043 

  1044 	bufStream.CommitL();

  1045 

  1046 	CleanupStack::PopAndDestroy(&bufStream); // bufStream.Close();

  1047 

  1048 	// Send it back to the client

  1049 	TPckg<TInt> size(iBuffer->Size());

  1050 	iMessage.WriteL(aSlot, size);	

  1051 	}

  1052 

  1053 

  1054 void CAgnServerSession::TransmitBufferL()

  1055 	{

  1056 	// Transmit the contents of the buffer stream to the client,

  1057 	// then delete it

  1058 	// Arguments: 0 : Output - Data Buffer

  1059 

  1060 	if (!iBuffer)

  1061 		{

  1062 		PanicClientL(EBadRequest);	

  1063 		}

  1064 	iMessage.WriteL(KSlot0, iBuffer->Ptr(0));

  1065 

  1066 	delete iBuffer;

  1067 	iBuffer = NULL;

  1068 	}

  1069 

  1070 

  1071 void CAgnServerSession::FetchSimpleEntryL()

  1072 	{

  1073 	// Fetch a lite-entry from the server

  1074 	// (A lite entry consists of time information without any text)

  1075 	// Arguments: 0 : Output - Data buffer

  1076 	//			  1 : Input  - TAgnInstace

  1077 	//			  2 : Output - Size of buffer

  1078 	const TInt KBufferSize = iMessage.GetDesLengthL(KSlot1);

  1079 	CBufFlat* buffer = CBufFlat::NewL(KBufferSize);

  1080 	CleanupStack::PushL(buffer);

  1081 	buffer->ExpandL(0, KBufferSize);

  1082 	TPtr8 des(buffer->Ptr(0));

  1083 	iMessage.ReadL(KSlot1, des);

  1084 	RDesReadStream readStream(des);

  1085 	TAgnEntryId entryId;

  1086 	readStream >> entryId;

  1087 	CleanupStack::PopAndDestroy(buffer);

  1088 

  1089 	// Make sure this entry hasn't been deleted or updated		TAgnInstanceId entryId = (*entryIds)[ii].iId;

  1090 	TCalCollectionId collectionId = iMessage.Int3();

  1091 	CAgnServFile* file = iAgnServer.FileMgr()->GetFileL(collectionId);

  1092 	if(file->IsLocked())

  1093 		{

  1094 		User::Leave(KErrLocked);

  1095 		}

  1096 

  1097 	const CAgnSimpleEntry* KEntry = file->Model()->GetSimpleEntryFromIndexes(entryId);

  1098 

  1099 	if ( KEntry )

  1100 		{

  1101 		delete iBuffer;

  1102 		iBuffer = NULL;

  1103 

  1104 		iBuffer = CBufFlat::NewL(KInitialBufferSize);

  1105 

  1106 		// Create a write stream for this buffer

  1107 		RBufWriteStream bufStream;

  1108 		bufStream.Open(*iBuffer);

  1109 		CleanupClosePushL(bufStream);	

  1110 

  1111 		// Write a bool to indicate if entry is available

  1112 		bufStream.WriteUint8L(KEntry != NULL);

  1113 

  1114 		bufStream.WriteUint32L(KEntry->Type());

  1115 		KEntry->ExternalizeL(bufStream, ETrue);

  1116 

  1117 		bufStream.CommitL();

  1118 

  1119 		CleanupStack::PopAndDestroy(&bufStream); // bufStream.Close();

  1120 

  1121 		// Send it back to the client

  1122 		TPckg<TInt> size(iBuffer->Size());

  1123 		iMessage.WriteL(KSlot2, size);

  1124 		}

  1125 	else

  1126 		{

  1127 		TPckg<TInt> emptyBuffer(0);

  1128 		iMessage.WriteL(KSlot2, emptyBuffer);

  1129 		}

  1130 	}

  1131 

  1132 void CAgnServerSession::FetchSimpleEntryByUIDL()

  1133 	{

  1134 	// Fetch a lite-entry from the server