diff -r 9f5ae1728557 -r db3f5fa34ec7 messagingfw/msgsrvnstore/server/src/MCLIENT.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingfw/msgsrvnstore/server/src/MCLIENT.CPP Wed Nov 03 22:41:46 2010 +0530 @@ -0,0 +1,3157 @@ +// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +#include +#include + + +#include "MSVIPC.H" +#include "MSERVER.H" +#include "MSVREGIP.H" + +#include "MCLIENT.H" +#include "MCLENTRY.H" +#include "MSVPANIC.H" +#include "MSVAPI.H" +#include "MsvSecurityCapabilitySet.h" +#include +#include +#include + +_LIT(KMsvServerExe, "msexe.exe"); + +#if defined _UNICODE +const TUid KMsvMsexExeUid={0x1000484B}; +#else +const TUid KMsvMsexExeUid={0x1000484A}; +#endif + +const TInt KMsvRetryTimeout=100000; +const TInt KMsvRetryCount=10; + +static TInt StartServer() + { + const TUidType serverUid(KNullUid, KNullUid, KMsvMsexExeUid); + RProcess server; + TInt r = server.Create(KMsvServerExe, KNullDesC, serverUid); + + if( r != KErrNone ) + return r; + + TRequestStatus status; + server.Rendezvous(status); + if( status != KRequestPending ) + server.Kill(0); // abort start-up + else + server.Resume(); // wait for server start-up. + User::WaitForRequest(status); + + // If the server panics on start-up, then exit reason may still be zero, + // which is not distinguishable from KErrNone. + r = (server.ExitType() == EExitPanic ) ? KErrGeneral : status.Int(); + server.Close(); + return r; + } + +//******************************** +//RMsvServerSession +//********************************** + +/** +Constructor. + +@capability None +*/ +EXPORT_C RMsvServerSession::RMsvServerSession() +: iBuffer(NULL) + {} + + +/** +Destructor. + +@capability None +*/ +EXPORT_C RMsvServerSession::~RMsvServerSession() + { + delete iBuffer; + } + +#if defined (__EPOC32__) +/** +Connect to the messaging server, and starts it if is not already running. + +The default number of message slots is 14. + +@param aFs File server handle +@return System wide error codes + +@capability None +*/ +EXPORT_C TInt RMsvServerSession::Connect(RFs& aFs) +#else +EXPORT_C TInt RMsvServerSession::Connect(RFs& /*aFs*/) +#endif + { + if (iBuffer==NULL) + { + iBuffer = HBufC8::New(KMsvSessionBufferLength); + if (iBuffer==NULL) + return KErrNoMemory; + } + + + TInt retry = KMsvRetryCount; + FOREVER + { + TInt r = CreateSession(KMsvServerName, Version(), KMsvNumberOfSlots); + if( r != KErrNotFound && r != KErrServerTerminated && r != KErrServerBusy ) + return r; + if( --retry == 0 ) + return r; + if( r == KErrServerBusy ) + User::After(KMsvRetryTimeout); + r = StartServer(); + if( r != KErrNone && r != KErrAlreadyExists ) + return r; + } + + } + + +/** +Gets the version number of the server. + +@return Version number + +@capability None +*/ +EXPORT_C TVersion RMsvServerSession::Version(void) const + { + return(TVersion(KMsvServerMajorVersionNumber,KMsvServerMinorVersionNumber,KMsvServerBuildVersionNumber)); + } + + +/** +Makes a request for session event notifications. + +@param aChange Packaged notification information (a TMsvNotifBuffer object) +@param aSequence notification sequence number (a packaged TUint) +@param aRequestStatus Asynchronous request status + +@capability None +*/ +EXPORT_C void RMsvServerSession::QueueSessionEventRequest(TDes8& aChange, TDes8& aSequence, TRequestStatus& aRequestStatus) + { + SendReceive(EMsvNotifySessionEvent, TIpcArgs(&aChange,&aSequence), aRequestStatus); + } + +/** +Cancels a request for session event notifications. + +@return System wide error codes + +@capability None +*/ +EXPORT_C TInt RMsvServerSession::CancelSessionEventRequest() + { + return SendReceive(EMsvCancelSessionEventNotification); + } + + +/** +Set a session as an observer only. + +@return System wide error codes + +@capability None +*/ +TInt RMsvServerSession::SetSessionAsObserver() + { + return SendReceive(EMsvSetSessionAsObserver); + } + +void RMsvServerSession::SendEntryDataL(TMsvOp aOperationId, const TMsvEntry& aEntry) +// +// Sends the entry data in a synchronous call +// + { + // package up the entry into a packed entry + TMsvPackedEntry packedEntry(iBuffer); + TInt error = packedEntry.PackEntry(aEntry); + while(error!=KErrNone) + { + // increase the size of the buffer and try again + iBuffer->Des().SetLength(0); // to avoid copying contents + iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength); + error = packedEntry.PackEntry(aEntry); + } + + // pass data to the server + User::LeaveIfError(SendReceive(EMsvOperationData, TIpcArgs(aOperationId,iBuffer))); + } + +void RMsvServerSession::SendOperationDataL(TMsvOp aOperationId, const CMsvEntrySelection& aSelection, TInt aParameter1, TInt aParameter2) +// +// Sends the operation data in a synchronous call +// + { + PackOperationDataL(aSelection, aParameter1, aParameter2); + + // package up the entry into a packed entry + User::LeaveIfError(SendReceive(EMsvOperationData, TIpcArgs(aOperationId,iBuffer))); + } + +void RMsvServerSession::PackOperationDataL(const CMsvEntrySelection& aSelection, TInt aParameter1, TInt aParameter2) + { + TMsvPackedOperation packedOperation(iBuffer); + TInt error = packedOperation.Pack(aSelection, aParameter1, aParameter2); + while(error!=KErrNone) + { + // increase the size of the buffer and try again + iBuffer->Des().SetLength(0); // to avoid copying contents + iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength); + error = packedOperation.Pack(aSelection, aParameter1, aParameter2); + } + } + +void RMsvServerSession::SendCommandDataL(TMsvOp aOperationId, const CMsvEntrySelection& aSelection, TInt aCommand, const TDesC8& aParameter) +// +// Sends the operation data in a synchronous call +// + { + TMsvPackedOperation packedOperation(iBuffer); + TInt error = packedOperation.Pack(aSelection, aCommand); + while(error!=KErrNone) + { + // increase the size of the buffer and try again + iBuffer->Des().SetLength(0); // to avoid copying contents + iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength); + error = packedOperation.Pack(aSelection, aCommand); + } + + // package up the entry into a packed entry + User::LeaveIfError(SendReceive(EMsvCommandData, TIpcArgs(aOperationId,iBuffer,&aParameter))); + } + + + +/** +Creates an entry in the message server index (asynchronously) with the supplied owner ID. + +@param aEntry Entry to create +@param aOperationId Operation identifier +@param aOwnerId The ID of the owning process +@param aRequestStatus Asynchronous request status + +@capability None A client with no capabilities can create an entry only if the entry is +under a local service, is in an unprotected folder, is not a service entry, and, if part of +an existing message, if that message is owned by the client. + +@capability WriteDeviceData Required if the entry is a service. + +@capability ReadUserData Required in some circumstances: see the note below. + +@capability WriteUserData Required in some circumstances: see the note below. + +@capability Note The capabilities required to create an entry that is not a service vary depending on the +following conditions: + +-# Entry to be created is part of an existing message: + -# Entry is under the local service: + -# Entry is in the Outbox and the Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities + -# Entry is in the Outbox and the Outbox is unprotected: MTM-specified capabilities + -# Entry is in a protected folder: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the existing entry is not owned by the client: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the existing entry is owned by the client: no capabilities + -# Entry is under a remote service: + -# The Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the existing entry is owned by the client: MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the existing entry is not owned by the client: ReadUserData + WriteUserData + + MTM-specified capabilities (of the MTM for the remote service) +-# Entry to be created is not part of an existing message: + -# Entry is under the local service: + -# Entry is in the Outbox and the Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities + -# Entry is in the Outbox and the Outbox is unprotected: MTM-specified capabilities + -# Entry is in a protected folder: ReadUserData + WriteUserData + -# Entry is in an unprotected folder: no capabilities + -# Entry is under a remote service: + -# The Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected: MTM-specified capabilities (of the MTM for the remote service) + +@internalComponent +*/ +EXPORT_C void RMsvServerSession::CreateEntryL(const TMsvEntry& aEntry, TMsvOp aOperationId, TSecureId aOwnerId, TRequestStatus& aRequestStatus) +// +// Creates an entry in the index for aEntry. +// + { + TestSlotAvailableL(); + SendEntryDataL(aOperationId, aEntry); + aRequestStatus=KRequestPending; + SendReceive(EMsvCreateEntry, TIpcArgs(aOperationId, aOwnerId), aRequestStatus); + } + + + +/** +Creates an entry in the message server index (synchronously). + +@param aEntry Entry to create +@param aOperationId Operation identifier +@param aOwnerId The ID of the owning process + +@capability None A client with no capabilities can create an entry only if the entry is +under a local service, is in an unprotected folder, is not a service entry, and, if part of +an existing message, if that message is owned by the client. + +@capability WriteDeviceData Required if the entry is a service. + +@capability ReadUserData Required in some circumstances: see the note below. + +@capability WriteUserData Required in some circumstances: see the note below. + +@capability Note The capabilities required to create an entry that is not a service vary depending on the +following conditions: + +-# Entry to be created is part of an existing message: + -# Entry is under the local service: + -# Entry is in the Outbox and the Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities + -# Entry is in the Outbox and the Outbox is unprotected: MTM-specified capabilities + -# Entry is in a protected folder: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the existing entry is not owned by the client: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the existing entry is owned by the client: no capabilities + -# Entry is under a remote service: + -# The Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the existing entry is owned by the client: MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the existing entry is not owned by the client: ReadUserData + WriteUserData + + MTM-specified capabilities (of the MTM for the remote service) +-# Entry to be created is not part of an existing message: + -# Entry is under the local service: + -# Entry is in the Outbox and the Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities + -# Entry is in the Outbox and the Outbox is unprotected: MTM-specified capabilities + -# Entry is in a protected folder: ReadUserData + WriteUserData + -# Entry is in an unprotected folder: no capabilities + -# Entry is under a remote service: + -# The Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected: MTM-specified capabilities (of the MTM for the remote service) + +@internalComponent +*/ +EXPORT_C void RMsvServerSession::CreateEntryL(const TMsvEntry& aEntry, TMsvOp aOperationId, TSecureId aOwnerId) +// +// Creates an entry in the index for aEntry. +// + { + TestSlotAvailableL(); + SendEntryDataL(aOperationId, aEntry); + User::LeaveIfError(SendReceive(EMsvCreateEntry,TIpcArgs(aOperationId, aOwnerId))); + } + + + +/** +Changes the contents of a message server entry (asynchronously). + +@param aEntry Entry to change +@param aOperationId Operation identifier +@param aOwnerId The ID of the owning process +@param aRequestStatus Asynchronous request status + +@capability None A client with no capabilities can access an entry only if the entry is +under a local service, is owned by the client, is in an unprotected folder, +and is not a service entry. + +@capability WriteDeviceData Required if the entry is a service. + +@capability ReadUserData Required in some circumstances: see the note below. + +@capability WriteUserData Required in some circumstances: see the note below. + +@capability Note The capabilities required to access an entry that is not a service vary depending on the +following conditions: + +- Entry is under the local service: + -# Entry is in the Outbox and the Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities + -# Entry is in the Outbox and the Outbox is unprotected: MTM-specified capabilities + -# Entry is in a protected folder: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the entry is not owned by the client: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the entry is owned by the client: no capabilities + +- Entry is under a remote service: + -# The Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the entry is owned by the client: MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the entry is not owned by the client: ReadUserData + WriteUserData + + MTM-specified capabilities (of the MTM for the remote service) + +@internalComponent +*/ +EXPORT_C void RMsvServerSession::ChangeEntryL(const TMsvEntry& aEntry, TMsvOp aOperationId, TSecureId aOwnerId, TRequestStatus& aRequestStatus) +// +// Changes the content of an entry +// + { + TestSlotAvailableL(); + SendEntryDataL(aOperationId, aEntry); + aRequestStatus=KRequestPending; + SendReceive(EMsvChangeEntry, TIpcArgs(aOperationId, aOwnerId), aRequestStatus); + } + + + + +/** +Changes the contents of a message server entry (synchronously). + +@param aEntry Entry to create +@param aOwnerId The ID of the owning process +@param aOperationId Operation identifier + +@capability None A client with no capabilities can access an entry only if the entry is +under a local service, is owned by the client, is in an unprotected folder, +and is not a service entry. + +@capability WriteDeviceData Required if the entry is a service. + +@capability ReadUserData Required in some circumstances: see the note below. + +@capability WriteUserData Required in some circumstances: see the note below. + +@capability Note The capabilities required to access an entry that is not a service vary depending on the +following conditions: + +- Entry is under the local service: + -# Entry is in the Outbox and the Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities + -# Entry is in the Outbox and the Outbox is unprotected: MTM-specified capabilities + -# Entry is in a protected folder: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the entry is not owned by the client: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the entry is owned by the client: no capabilities + +- Entry is under a remote service: + -# The Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the entry is owned by the client: MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the entry is not owned by the client: ReadUserData + WriteUserData + + MTM-specified capabilities (of the MTM for the remote service) + +@internalComponent +*/ +EXPORT_C void RMsvServerSession::ChangeEntryL(const TMsvEntry& aEntry, TMsvOp aOperationId, TSecureId aOwnerId) +// +// Changes the content of an entry +// + { + TestSlotAvailableL(); + SendEntryDataL(aOperationId, aEntry); + User::LeaveIfError(SendReceive(EMsvChangeEntry, TIpcArgs(aOperationId, aOwnerId))); + } + +/** +Update the specified Changes to selection of TMsvId (asynchronously). + +@param aSelection The IDs of the entry to Change. +@param aMark The read/Unread value. +@param aOperationId Operation identifier +@param aOwnerId The ID of the owning process +@param aRequestStatus Asynchronous request status + +*/ + +void RMsvServerSession::ChangeEntriesL(const CMsvEntrySelection& aSelection, TBool aMark ,TMsvOp aOperationId, TSecureId aOwnerId, TRequestStatus& aRequestStatus) + { + TestSlotAvailableL(); + TInt markvalue = (TInt)aMark; + SendOperationDataL(aOperationId, aSelection, markvalue); + aRequestStatus=KRequestPending; + SendReceive(EMsvChangeEntries, TIpcArgs(aOperationId, aOwnerId), aRequestStatus); + } + +/** +Gets the index entry with the specified unique id. +@param aId ID of the entry to get +@param aService On return, the ID of the service to which the entry belongs +@param aEntry On return, the index entry with the specified ID +@return System wide error code + +@capability None A client with no capabilities can access an entry only if owns that entry. + +@capability ReadUserData This is required to access any entry where the condition +described for no capabilities does not apply. +*/ +EXPORT_C TInt RMsvServerSession::GetEntry(TMsvId aId, TMsvId& aService, TMsvEntry& aEntry) + { + // pass the buffer and its max length to receive the data through + TPtr8 ptr=iBuffer->Des(); + TInt maxLength = iBuffer->Des().MaxLength(); + + // signal the server + TInt error = SendReceive(EMsvGetEntry,TIpcArgs(aId, &ptr, maxLength)); + while(error == KErrOverflow) + { + // increase the size of the buffer and try again + iBuffer->Des().SetLength(0); + // TRAP here and return if leaving with error + TRAP(error, iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength)); + if( error != KErrNone) + { + break; + } + // pass the buffer to receive the data through + TPtr8 ptr=iBuffer->Des(); + maxLength = iBuffer->Des().MaxLength(); + error = SendReceive(EMsvGetEntry,TIpcArgs(aId,&ptr,maxLength)); + } + + if( error == KErrNone) + { + TMsvPackedEntry packedEntry(iBuffer); + // Unpack the entry and servie id from same buffer + packedEntry.UnpackEntryAndService(aEntry, aService); + } + + return error; + } + +/** +Gets the children of the index entry with the specified unique id. + +@param aId ID of the entry to get +@param aEntries On return, the entry's children. If an error is returned, aEntries is unchanged. +@param aOrdering Sorting and grouping rules for the returned entries +@return System wide error code + +@capability None Only children that the client owns are returned. + +@capability ReadUserData All children of the entry are returned +*/ +EXPORT_C TInt RMsvServerSession::GetChildren(TMsvId aId, CArrayPtrFlat& aEntries, const TMsvSelectionOrdering& aOrdering) + { + TInt origCount=aEntries.Count(); + TRAPD(leave, DoGetChildrenL(aId, aEntries, aOrdering)); + if (leave!=KErrNone) + { + TInt count=aEntries.Count(); + while (count>origCount) + { + delete aEntries.At(--count); + aEntries.Delete(count); + } + } + return leave; + } + + +void RMsvServerSession::DoGetChildrenL(TMsvId aId, CArrayPtrFlat& aEntries, const TMsvSelectionOrdering& aOrdering) +// +// Gets the children of the index entry with the Unique id aId. +// + { + // package up the Id into a children details class + TPckgBuf details; + details().iParentId = aId; + // pass the sort order + TPckgC package2(aOrdering); + // pass the buffer to receive the data through + TPtr8 ptr=iBuffer->Des(); + // signal the server + TInt error = SendReceive(EMsvGetChildren, TIpcArgs(&details,&package2,&ptr)); + + if (error!=KErrNone && error!=KErrOverflow) + User::Leave(error); + + // unpack the entries from the buffer + TMsvPackedEntryArray packedEntryArray(iBuffer); + for (TInt count=0; count& aDetails, CArrayPtrFlat& aEntries) +// +// Gets the remaining children +// + { + TInt error=KErrOverflow; + while (error==KErrOverflow) + { + // package up the Id into a children details class & pass the buffer to receive the data through + TPtr8 ptr=iBuffer->Des(); + // get some more entries + error = SendReceive(EMsvGetRemainingChildren,TIpcArgs(&aDetails,NULL,&ptr)); + if (error!=KErrNone && error!=KErrOverflow) + User::Leave(error); + + if (aDetails().iNumberChildrenInArray == 0) + { + if (error == KErrOverflow) + { + // The buffer isn't big enough for the current entry + // we must resize the buffer or we're in an infinite loop + iBuffer->Des().SetLength(0); + iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength); + } + } + else + { + // unpack the entries from the buffer + TMsvPackedEntryArray packedEntryArray(iBuffer); + for (TInt count=0; countDes(); + // signal the server + TInt error = SendReceive(EMsvFillRegisteredMtmDllArray,TIpcArgs(aMtmDllTypeUid.iUid, &ptr)); + if (error==KErrNone) + { + RDesReadStream readStream(*iBuffer); + TRAP(error, TMsvPackedRegisteredMtmDllArray::UnpackRegisteredMtmDllArrayL(readStream, aRegisteredMtmDllArray, aTimeoutMicroSeconds32, *this)); + } + + return error; + } + +/** +Installs a new MTM group. + +@param aFullName The full path name of the MTM group file +@return System wide error code + +@capability WriteDeviceData +*/ +EXPORT_C TInt RMsvServerSession::InstallMtmGroup(const TDesC& aFullName) + { + return SendReceive(EMsvInstallMtmGroup,TIpcArgs(&aFullName)); + } + +/** +Uninstalls an MTM group. + +@param aFullName The full path name of the MTM group file +@return System wide error code + +@capability WriteDeviceData +*/ +EXPORT_C TInt RMsvServerSession::DeInstallMtmGroup(const TDesC& aFullName) + { + return SendReceive(EMsvDeInstallMtmGroup,TIpcArgs(&aFullName)); + } + +/** +Increments the usage reference count for a specified MTM group. + +@param aMtmTypeUid MTM group UID +@return System wide error code +@see RMsvServerSession::ReleaseMtmGroup + +@capability None +*/ +EXPORT_C TInt RMsvServerSession::UseMtmGroup(TUid aMtmTypeUid) + { + // package up the Id of the entry required + return SendReceive(EMsvUseMtmGroup,TIpcArgs(aMtmTypeUid.iUid)); + } + +/** +Decrements the usage reference count for a specified MTM group. + +@param aMtmTypeUid MTM group UID +@return System wide error code + +@capability None +*/ +EXPORT_C TInt RMsvServerSession::ReleaseMtmGroup(TUid aMtmTypeUid) + { + // package up the Id of the entry required + return SendReceive(EMsvReleaseMtmGroup,TIpcArgs(aMtmTypeUid.iUid)); + } + +/** +Gets the registration data for an MTM group. + +@param aMtmTypeUid MTM group UID +@return Registration data for the specified MTM group +@leave System wide error code + +@capability None +*/ +EXPORT_C CMtmGroupData* RMsvServerSession::GetMtmGroupDataL(TUid aMtmTypeUid) + { + TPtr8 ptr=iBuffer->Des(); + // package up the Id of the entry required and pass the buffer to receive the data through + User::LeaveIfError(SendReceive(EMsvGetMtmGroupData,TIpcArgs(aMtmTypeUid.iUid,&ptr))); + RDesReadStream readStream(*iBuffer); + return CMtmGroupData::NewL(readStream); + } + + +/** +Gets capabilities required to use the specified MTM. + +@param aMtmTypeUid MTM UID +@param aCapSet On return, capabilities required to use the specified MTM. + +@capability None +*/ +void RMsvServerSession::GetMtmRequiredCapabilitiesL(TUid aMtmTypeUid, TCapabilitySet& aCapSet) const + { + TPtr8 ptr=iBuffer->Des(); + User::LeaveIfError(SendReceive(EMsvGetMtmRequiredCapabilities, TIpcArgs(aMtmTypeUid.iUid, &ptr))); + RDesReadStream readStream(*iBuffer); + MsvSecurityCapabilitySetUtils::InternalizeL(readStream,aCapSet); + } + + +/** +Cancels a specified operation. + +@param aId Operation identifier +@param aProgress On return, progress information for the operation +@return System wide error code + +@capability None +*/ +EXPORT_C TInt RMsvServerSession::CancelOperation(TMsvOp aId, TDes8& aProgress) + { + TInt ret = SendReceive(EMsvCancelOperation, TIpcArgs(aId,&aProgress)); + if (ret>0) + { + aProgress.SetLength(ret); + ret=KErrNone; + } + else + { + aProgress.SetLength(0); + if (ret==KErrNotReady) + ret=KErrNone; + } + return ret; + } + + +/** +Gets progress information for an operation. + +@param aId Operation identifier +@param aProgress On return, progress information for the operation +@return System wide error code + +@capability None +*/ +EXPORT_C TInt RMsvServerSession::OperationProgress(TMsvOp aId, TDes8& aProgress) + { + TInt ret = SendReceive(EMsvOperationProgress, TIpcArgs(aId,&aProgress)); + if (ret>0) + { + aProgress.SetLength(ret); + ret=KErrNone; + } + else + aProgress.SetLength(0); + return ret; + } + +/** +Obtains the progress information that is defined by and understood by the system as well as client MTM's + +@param aId Operation identifier +@param aProgress On return, progress information for the operation +@return System wide error code + +@capability None +*/ +EXPORT_C TInt RMsvServerSession::OperationSystemProgress(TMsvOp aId, TMsvSystemProgress& aProgress) + { + TPckg sysProgressPkg(aProgress); + return SendReceive(EMsvOperationSystemProgress, TIpcArgs(aId,&sysProgressPkg)); + } + +/** +Obtains the final progress information for an operation. +The associated server side objects are then deleted. + +@param aId Operation identifier +@param aProgress On return, progress information for the operation +@return System wide error code + +@capability None +*/ +EXPORT_C TInt RMsvServerSession::OperationCompletion(TMsvOp aId, TDes8& aProgress) + { + TInt ret = SendReceive(EMsvOperationCompletion, TIpcArgs(aId,&aProgress)); + if (ret>0) + { + aProgress.SetLength(ret); + ret=KErrNone; + } + else + aProgress.SetLength(0); + return ret; + } + + +/** +Moves the specified message server entries (asynchronously). + +@param aSelection The IDs of the entry to move. On return, contains the children that could not be fully moved. +@param aTarget The ID of the new parent +@param aOperationId Operation identifier +@param aRequestStatus Asynchronous request status + +@capability None A client with no capabilities can move an entry only if both source and target entries +are under a local service, are owned by the client, and are in an unprotected folder. + +@capability ReadUserData Required in some circumstances: see the note below. + +@capability WriteUserData Required in some circumstances: see the note below. + +@capability Note The function tests that the caller has capabilities to modify the +the source entry (see RMsvServerSession::ChangeEntryL) and to create under the target +entry (see RMsvServerSession::CreateEntryL). +*/ +EXPORT_C void RMsvServerSession::MoveEntriesL(const CMsvEntrySelection& aSelection, TMsvId aTarget, TMsvOp aOperationId, TRequestStatus& aRequestStatus) + { + TestSlotAvailableL(); + // send the data to the server + SendOperationDataL(aOperationId, aSelection, aTarget); + // start the operation + aRequestStatus=KRequestPending; + SendReceive(EMsvMoveEntries, TIpcArgs(aOperationId), aRequestStatus); + } + +/** +Moves the specified message server entries (synchronously). + +@param aSelection The IDs of the entry to move. On return, contains the children that could not be fully moved. +@param aTarget The ID of the new parent entry +@param aOperationId Operation identifier + +@capability None A client with no capabilities can move an entry only if both source and target entries +are under a local service, are owned by the client, and are in an unprotected folder. + +@capability ReadUserData Required in some circumstances: see the note below. + +@capability WriteUserData Required in some circumstances: see the note below. + +@capability Note The function tests that the caller has capabilities to modify the +the source entry (see RMsvServerSession::ChangeEntryL) and to create under the target +entry (see RMsvServerSession::CreateEntryL). +*/ +EXPORT_C void RMsvServerSession::MoveEntriesL(const CMsvEntrySelection& aSelection, TMsvId aTarget, TMsvOp aOperationId) + { + TestSlotAvailableL(); + // send the data to the server + SendOperationDataL(aOperationId, aSelection, aTarget); + // start the operation + User::LeaveIfError(SendReceive(EMsvMoveEntries, TIpcArgs(aOperationId))); + } + +/** +Copies the specified message server entries (synchronously). + +@param aSelection The IDs of the source entries to copy. On return, contains the children that could not be fully copied. +@param aTarget The ID of the destination parent entry +@param aOperationId Operation identifier + +@capability None A client with no capabilities can copy an entry only if both source and target entries +are under a local service, are owned by the client, and are in an unprotected folder. + +@capability ReadUserData Required in some circumstances: see the note below. + +@capability WriteUserData Required in some circumstances: see the note below. + +@capability Note The function tests that the caller has capabilities to create under the +target entry (see RMsvServerSession::CreateEntryL). +*/ +EXPORT_C void RMsvServerSession::CopyEntriesL(const CMsvEntrySelection& aSelection, TMsvId aTarget, TMsvOp aOperationId) + { + TestSlotAvailableL(); + // send the data to the server + SendOperationDataL(aOperationId, aSelection, aTarget); + // start the operation + User::LeaveIfError(SendReceive(EMsvCopyEntries, TIpcArgs(aOperationId))); + } + + +/** +Copies the specified message server entries (asynchronously). + +@param aSelection The IDs of the source entries to copy. On return, contains the children that could not be fully copied. +@param aTarget The ID of the destination parent entry +@param aOperationId Operation identifier +@param aRequestStatus Asynchronous request status + +@capability None A client with no capabilities can copy an entry only if both source and target entries +are under a local service, are owned by the client, and are in an unprotected folder. + +@capability ReadUserData Required in some circumstances: see the note below. + +@capability WriteUserData Required in some circumstances: see the note below. + +@capability Note The function tests that the caller has capabilities to create under the +target entry (see RMsvServerSession::CreateEntryL). +*/ +EXPORT_C void RMsvServerSession::CopyEntriesL(const CMsvEntrySelection& aSelection, TMsvId aTarget, TMsvOp aOperationId, TRequestStatus& aRequestStatus) + { + TestSlotAvailableL(); + // send the data to the server + SendOperationDataL(aOperationId, aSelection, aTarget); + // start the operation + aRequestStatus=KRequestPending; + SendReceive(EMsvCopyEntries, TIpcArgs(aOperationId), aRequestStatus); + } + + +/** +Passes an MTM-specific operation to the associated server-side MTM by means of the Message Server (asynchronously). + +@param aSelection A selection of entries that may be relevant to the operation +@param aCommandId The command ID. The interpretation of the command is MTM-specific. +@param aParameter A descriptor containing operation-specific parameters +@param aOperationId Operation identifier +@param aRequestStatus Asynchronous request status + +@capability ReadUserData +@capability WriteUserData +@capability Note A client application needs to have any additional capabilities that are specified by +the MTM for the message type, as well as ReadUserData and WriteUserData. + +@see RMsvServerSession::GetMTMRequiredCapabilitiesL +*/ +EXPORT_C void RMsvServerSession::TransferCommandL(const CMsvEntrySelection& aSelection, TInt aCommandId, const TDesC8& aParameter, TMsvOp aOperationId, TRequestStatus& aRequestStatus) + { + TestSlotAvailableL(); + // send the operation data to the server + SendCommandDataL(aOperationId, aSelection, aCommandId, aParameter); + // start the operation + aRequestStatus=KRequestPending; + SendReceive(EMsvMtmCommand, TIpcArgs(aOperationId), aRequestStatus); + } + +/** +Passes an MTM-specific operation to the associated server-side MTM by means of the Message Server (synchronously). + +@param aSelection A selection of entries that may be relevant to the operation +@param aCommandId The command ID. The interpretation of the command is MTM-specific. +@param aParameter A descriptor containing operation-specific parameters +@param aOperationId Operation identifier + +@capability ReadUserData +@capability WriteUserData +@capability Note A client application needs to have any additional capabilities that are specified by +the MTM for the message type, as well as ReadUserData and WriteUserData. + +@see RMsvServerSession::GetMTMRequiredCapabilitiesL +*/ +EXPORT_C TInt RMsvServerSession::TransferCommandL(const CMsvEntrySelection& aSelection, TInt aCommandId, const TDesC8& aParameter, TMsvOp aOperationId) + { + TestSlotAvailableL(); + // send the operation data to the server + SendCommandDataL(aOperationId, aSelection, aCommandId, aParameter); + // start the operation + return SendReceive(EMsvMtmCommand, TIpcArgs(aOperationId)); + } + + +/** +Gets the MTM that would perform an operation using two specified entries. + +@param aId1 ID of first entry +@param aId2 ID of second entry +@param aMtm On return, the UID of the MTM that would be used +@param aService On return, the ID of the service that would be used +@return System wide error code + +@capability None +*/ +EXPORT_C TInt RMsvServerSession::OperationMtmL(TMsvId aId1, TMsvId aId2, TUid& aMtm, TMsvId& aService) + { + TPckg uid(aMtm); + TPckg service(aService); + return SendReceive(EMsvOperationMtm, TIpcArgs(aId1,aId2,&uid,&service)); + } + + +/** +Stops any operations that a Server-side MTM for the specified service is running, +and then unloads the Server-side MTM. + +The current operation and any queued operations are cancelled. + +@param aServiceId ID of the service +@return System wide error code + +@capability Note A client application needs to have any capabilities that are specified by +the MTM. + +@see RMsvServerSession::GetMTMRequiredCapabilitiesL +*/ +EXPORT_C TInt RMsvServerSession::StopService(TMsvId aServiceId) + { + return SendReceive(EMsvStopService, TIpcArgs(aServiceId)); + } + + +/** +Tests if a Server-side MTM for a particular service is loaded by the Message +Server. + +The Server-side MTM does not have to be executing a command: it may be +waiting for another command. + +@param aServiceId The ID of the relevant service +@return ETrue if the Server-side MTM for the service is loaded, otherwise EFalse + +@capability None +*/ +EXPORT_C TBool RMsvServerSession::ServiceActive(TMsvId aServiceId) + { + return SendReceive(EMsvServiceActive, TIpcArgs(aServiceId)); + } + +/** +Gets the current progress information from the Server-side MTM for the specified +service. + +It is typically used by User Interface MTMs. The format of the progress information +returned in the aProgress buffer is MTM-specific. + +Calling this function results in the Message Server calling CBaseServerMtm::Progress() +on the relevant Server-side MTM. + +Note that the progress information is independent of which message client +application started the current operation. + +@param aServiceId The ID of the service from which to get the progress information +@param aProgress On return, a descriptor holding progress information. It is +the caller's responsibility to ensure the descriptor is large enough for this information. +@return KErrNone: success; KErrNotFound: The service is not active (the relevant Server-side MTM is not loaded +by the Message Server); KErrOverflow: The descriptor was too small for the progress information + +@capability None +*/ +EXPORT_C TInt RMsvServerSession::ServiceProgress(TMsvId aServiceId, TDes8& aProgress) + { + TInt ret = SendReceive(EMsvServiceProgress, TIpcArgs(aServiceId,&aProgress)); + if (ret>0) + { + aProgress.SetLength(ret); + ret=KErrNone; + } + else + aProgress.SetLength(0); + return ret; + } + +/** +Deletes the specified entry from the Message Server. + +The call is guaranteed not to fail. If the entry cannot be deleted immediately, +it will be deleted later. + +@param aId The ID of the entry to remove + +@capability None A client with no capabilities can access an entry only if the entry is +under a local service, is owned by the client, is in an unprotected folder, +and is not a service entry. + +@capability WriteDeviceData Required if the entry is a service. + +@capability ReadUserData Required in some circumstances: see the note below. + +@capability WriteUserData Required in some circumstances: see the note below. + +@capability Note The capabilities required to access an entry that is not a service vary depending on the +following conditions: + +- Entry is under the local service: + -# Entry is in the Outbox and the Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities + -# Entry is in the Outbox and the Outbox is unprotected: MTM-specified capabilities + -# Entry is in a protected folder: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the entry is not owned by the client: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the entry is owned by the client: no capabilities + +- Entry is under a remote service: + -# The Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the entry is owned by the client: MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the entry is not owned by the client: ReadUserData + WriteUserData + + MTM-specified capabilities (of the MTM for the remote service) +*/ +EXPORT_C void RMsvServerSession::RemoveEntry(TMsvId aId) + { + SendReceive(EMsvRemoveEntry, TIpcArgs(aId)); + } + +/** +Gets the path of the folder in which the Message Server data is stored. + +@param aDirectory Descriptor to hold returned path +@return System wide error code +*/ +EXPORT_C TInt RMsvServerSession::GetMessageDirectory(TDes& aDirectory) + { + return SendReceive(EMsvGetMessageDirectory, TIpcArgs(&aDirectory)); + } + +/** +Gets the drive on which the Message Server data is stored. + +@return Drive, as a TDriveNumber value + +@capability None +*/ +TInt RMsvServerSession::GetMessageDrive() + { + return SendReceive(EMsvGetMessageDrive); + } + + +void RMsvServerSession::TestSlotAvailableL() +// +// +// + { + User::LeaveIfError(SendReceive(EMsvSlotAvailable)); + } + + +/** +Set failure condition to simulate (for test purposes). +@param aType +@param aArg1 +@param aArg2 +@param aArg3 + +@capability Note When the __REMOVE_MESSAGING_API_V1__ macro is defined, the +function is policed against the capabilities of the message server (Read/Write Device Data, +Protected Server, Network Control, Network Services, Local Services and Read +User Data). When the macro is not defined, the function is not policed. +*/ +EXPORT_C void RMsvServerSession::SetFailure(TInt aType, TInt aArg1, TInt aArg2, TInt aArg3) + { + SendReceive(EMsvSetFailure,TIpcArgs(aType,aArg1,aArg2,aArg3)); + } + +/** Sets or clears multiple fields in a selection of entries. + +Fields to change are specified using a bitmask of TMsvAttribute values. +@param aSelection The entries to change +@param aSetAttributes A bitmask of the fields to set +@param aClearAttributes A bitmask of the fields to clear +@see TMsvAttribute + +@capability WriteUserData + +@capability Note Clients with no capabilities that own entries in an unprotected folder cannot use this IPC call. +Instead, they must change attributes by using ChangeEntryL on each entry. +*/ +EXPORT_C void RMsvServerSession::ChangeAttributesL(const CMsvEntrySelection& aSelection, TUint aSetAttributes, TUint aClearAttributes) + { + PackOperationDataL(aSelection, aSetAttributes, aClearAttributes); + User::LeaveIfError(SendReceive(EMsvChangeAttributes,TIpcArgs(iBuffer))); + } + +/** +Gets a filtered list of children of a specified message entry. +@param aId Message entry of which to get children +@param aFilter Filter by which various message entries can be excluded +@param aSelection On return, a list of message entry IDs + +@capability None Only children that the client owns are returned. + +@capability ReadUserData All children of the entry are returned +*/ +EXPORT_C void RMsvServerSession::GetChildIdsL(TMsvId aId, const CMsvEntryFilter& aFilter, CMsvEntrySelection& aSelection) + { + TMsvPackedEntryFilter package(iBuffer); + User::LeaveIfError(package.PackFilter(aFilter)); + + TPtr8 ptr=iBuffer->Des(); + + TInt error = SendReceive(EMsvGetChildIds,TIpcArgs(&ptr,aId)); + + while(error == KErrOverflow) + { + // increase the size of the buffer and try again + iBuffer->Des().SetLength(0); // to avoid copying contents + iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength); + TMsvPackedEntryFilter package1(iBuffer); + User::LeaveIfError(package1.PackFilter(aFilter)); + TPtr8 ptr2=iBuffer->Des(); + error = SendReceive(EMsvGetChildIds,TIpcArgs(&ptr2,aId)); + } + User::LeaveIfError(error); + TInt temp1(0); + TInt temp2(0); + TMsvPackedOperation op(iBuffer); + op.UnpackL(aSelection, temp1, temp2); + } + + + + +/** +Load the Message Server index from the specified drive. + +Progress information is provided by a TMsvIndexLoadProgress object. + +If an error occurs, the index is unchanged. + +@param aDrive The drive holding the Message Server index, specified +by a TDriveNumber value +@param aOperationId Operation identifier +@param aRequestStatus Asynchronous completion status +@leave KErrServerBusy Cannot change drive because there are outstanding Message +Server operations. + +@capability WriteDeviceData +*/ +void RMsvServerSession::ChangeDriveL(TInt aDrive, TMsvOp aOperationId, TRequestStatus& aRequestStatus) + { + __ASSERT_ALWAYS(RFs::IsValidDrive(aDrive), PanicServer(EMsvInvalidDrive)); + TestSlotAvailableL(); + + // start the operation + aRequestStatus = KRequestPending; + SendReceive(EMsvChangeDrive, TIpcArgs(aOperationId,TInt(aDrive)), aRequestStatus); + } + + +/** +Copy the Message Store to the specified drive. + +Progress information is provided by a TMsvCopyProgress object. + +If an error occurs, copying is stopped. + +@param aDrive The drive holding the Message Server index, specified +by a TDriveUnit value +@param aOperationId Operation identifier +@param aStatus Asynchronous completion status +@leave KErrServerBusy Cannot copy store because there are outstanding Message +Server operations. + +@capability WriteDeviceData*/ + +void RMsvServerSession::CopyStoreL(const TDriveUnit& aDrive, TMsvOp aOperationId, TRequestStatus& aStatus) + { + __ASSERT_ALWAYS(RFs::IsValidDrive(aDrive), PanicServer(EMsvInvalidDrive)); + TestSlotAvailableL(); + + // start the operation + SendReceive(EMsvCopyStore, TIpcArgs(aOperationId,TInt(aDrive)), aStatus); + } + + +/** +Delete the Message Store to the specified drive. + +Progress information is provided by a TMsvDeleteProgress object. + +If an error occurs, deleting is stopped. + +@param aDrive The drive holding the Message Server index, specified +by a TDriveUnit value +@param aOperationId Operation identifier +@param aStatus Asynchronous completion status +@leave KErrServerBusy Cannot delete store because there are outstanding Message +Server operations. + +@capability WriteDeviceData +*/ +void RMsvServerSession::DeleteStoreL(const TDriveUnit& aDrive, TMsvOp aOperationId, TRequestStatus& aStatus) + { + __ASSERT_ALWAYS(RFs::IsValidDrive(aDrive), PanicServer(EMsvInvalidDrive)); + TestSlotAvailableL(); + + // start the operation + SendReceive(EMsvDeleteStore, TIpcArgs(aOperationId,TInt(aDrive)), aStatus); + } + + + +/** +Gets the number of outstanding operations. + +@return The number of outstanding operations + +@capability None +*/ +TInt RMsvServerSession::OutstandingOperationsL() + { + TInt count; + TPckg package(count); + + User::LeaveIfError(SendReceive(EMsvOutstandingOperations, TIpcArgs(&package))); + return count; + } + +/** +Get the notification sequence number. + +@return Notification sequence number + +@capability None +*/ +TUint32 RMsvServerSession::NotifySequenceL() + { + TUint32 sequence; + TPckg package(sequence); + + User::LeaveIfError(SendReceive(EMsvGetNotifySequence, TIpcArgs(&package))); + return sequence; + } + + +/** +Sets whether the session's observer should be notified of events related to +changes in message server entries. + +If the flag is set to true, the session observer will be notified of all events types. +If it is set to false, the observer will not be notified of events of types EMsvEntriesCreated, +EMsvEntriesChanged, EMsvEntriesDeleted, or EMsvEntriesMoved. (Event types are enumerated in +MMsvSessionObserver::TMsvSessionEvent.) + +@param aReceive Event request flag +@return System wide error code +@see MMsvSessionObserver::TMsvSessionEvent + +@capability None +*/ +EXPORT_C TInt RMsvServerSession::SetReceiveEntryEvents(TBool aReceive) + { + // Send the uid type in message and Make request + return SendReceive(EMsvSetReceiveEntyEvents, TIpcArgs(aReceive)); + } + +// from MMsvStoreManager +/** +Creates a new attachment file in the message store for the message entry specified. +This function allows clients to create a new empty file and stream data to it. +The empty attachment file is passed back to the client using an opened file handle +to the file in the message store. + +@param aEntryId Entry to create the attachment for +@param aFileName The attachment filename +@param aFile On return, open file handle to the new attachment file . Ownership is transferred. The caller must close the file handle . +@return True if the file created was named as specified, otherwise false + +@capability None A client with no capabilities can access an entry only if the entry is +under a local service, is owned by the client, is in an unprotected folder, +and is not a service entry. + +@capability WriteDeviceData Required if the entry is a service. + +@capability ReadUserData Required in some circumstances: see the note below. + +@capability WriteUserData Required in some circumstances: see the note below. + +@capability Note The capabilities required to access an entry that is not a service vary depending on the +following conditions: + +- Entry is under the local service: + -# Entry is in the Outbox and the Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities + -# Entry is in the Outbox and the Outbox is unprotected: MTM-specified capabilities + -# Entry is in a protected folder: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the entry is not owned by the client: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the entry is owned by the client: no capabilities + +- Entry is under a remote service: + -# The Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the entry is owned by the client: MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the entry is not owned by the client: ReadUserData + WriteUserData + + MTM-specified capabilities (of the MTM for the remote service) +*/ +EXPORT_C TBool RMsvServerSession::CreateAttachmentForWriteL(TMsvId aEntryId, TDes& aFileName, RFile& aFile) + { + TPckg pckgSubSessionHandle(0); // intitialise + TPckg pckgFileNameChanged(EFalse); // intitialise + // session handle (RFs)received from TransferToClient() in server + TInt sessionHandle = User::LeaveIfError(SendReceive(EMsvCreateAttachmentForWrite,TIpcArgs(aEntryId,&aFileName,&pckgSubSessionHandle,&pckgFileNameChanged))); + + // Adopt the file handle from server + User::LeaveIfError(aFile.AdoptFromServer(sessionHandle,pckgSubSessionHandle())); + + return pckgFileNameChanged(); + } + +/** +Allows clients to replace an existing attachment file and allows clients to stream data to it. + +Replaces an existing attachment file in the message store for the message entry specified by the aEntryId +parameter. The attachment filename is set to the filename indicated by the aFilename parameter. +If an attachment with the supplied name does not exist, a new file is created. The empty attachment +file is passed back to the client using an opened file handle to the file in the message store. + +@param aEntryId The entry for which an attachment needs to be created in the message store +@param aFilename The name of the attachment file to be created +@param aFile On return, The created file handle for the attachment file.Ownership is transferred . The caller must close the file handle . + +@capability None A client with no capabilities can access an entry only if the entry is +under a local service, is owned by the client, is in an unprotected folder, +and is not a service entry. + +@capability WriteDeviceData Required if the entry is a service. + +@capability ReadUserData Required in some circumstances: see the note below. + +@capability WriteUserData Required in some circumstances: see the note below. + +@capability Note The capabilities required to access an entry that is not a service vary depending on the +following conditions: + +- Entry is under the local service: + -# Entry is in the Outbox and the Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities + -# Entry is in the Outbox and the Outbox is unprotected: MTM-specified capabilities + -# Entry is in a protected folder: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the entry is not owned by the client: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the entry is owned by the client: no capabilities + +- Entry is under a remote service: + -# The Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the entry is owned by the client: MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the entry is not owned by the client: ReadUserData + WriteUserData + + MTM-specified capabilities (of the MTM for the remote service) +*/ +EXPORT_C void RMsvServerSession::ReplaceAttachmentForWriteL(TMsvId aEntryId, TDes& aFileName, RFile& aFile) + { + TPckg pckgSubSessionHandle(0); // intitialise + + // session handle (RFs)received from TransferToClient() in server + TInt sessionHandle = User::LeaveIfError(SendReceive(EMsvReplaceAttachmentForWrite,TIpcArgs(aEntryId,&aFileName,&pckgSubSessionHandle))); + + // Adopt the file handle from server + User::LeaveIfError(aFile.AdoptFromServer(sessionHandle,pckgSubSessionHandle())); + } + +/** +Opens an existing attachment file in the message store for the message entry specified. +This function allows clients to view attachment files. + +@param aEntryId Entry that has the attachment +@param aFilePath The attachment filename +@param aFile On return, open file handle to the attachment file. Ownership is transferred . The caller must close the file handle . + +@capability None A client with no capabilities can access an entry only if owns that entry. + +@capability ReadUserData This is required to access any entry where the condition +described for no capabilities does not apply. +*/ +EXPORT_C void RMsvServerSession::OpenAttachmentL(TMsvId aEntryId, const TDesC& aFilePath, RFile& aFile) + { + TPckg pckgSubSessionHandle(0); // initialise + // session handle (RFs)received from TransferToClient() in server + TInt sessionHandle = SendReceive(EMsvOpenAttachment,TIpcArgs(aEntryId,&aFilePath,&pckgSubSessionHandle)); + + // Adopt the file handle from server + User::LeaveIfError(aFile.AdoptFromServer(sessionHandle,pckgSubSessionHandle())); + } + + +/** +Opens an existing attachment file in the message store for the message entry specified. +This function allows clients to edit attachment files. + +@param aEntryId Entry that has the attachment +@param aFilePath The attachment filename +@param aFile On return, open file handle to the attachment file .Ownership is transferred . The caller must close the file handle . + +@capability None A client with no capabilities can access an entry only if the entry is +under a local service, is owned by the client, is in an unprotected folder, +and is not a service entry. + +@capability ReadUserData Required in some circumstances: see the note below. + +@capability WriteUserData Required in some circumstances: see the note below. + +@capability Note The capabilities required to access an entry that is not a service vary depending on the +following conditions: + +- Entry is under the local service: + -# Entry is in the Outbox and the Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities + -# Entry is in the Outbox and the Outbox is unprotected: MTM-specified capabilities + -# Entry is in a protected folder: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the entry is not owned by the client: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the entry is owned by the client: no capabilities + +- Entry is under a remote service: + -# The Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the entry is owned by the client: MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the entry is not owned by the client: ReadUserData + WriteUserData + + MTM-specified capabilities (of the MTM for the remote service) +*/ +EXPORT_C void RMsvServerSession::OpenAttachmentForWriteL(TMsvId aEntryId, const TDesC& aFilePath, RFile& aFile) + { + TPckg pckgSubSessionHandle(0); // initialise + // session handle (RFs)received from TransferToClient() in server + TInt sessionHandle = SendReceive(EMsvOpenAttachmentForWrite,TIpcArgs(aEntryId,&aFilePath,&pckgSubSessionHandle)); + + // Adopt the file handle from server + User::LeaveIfError(aFile.AdoptFromServer(sessionHandle,pckgSubSessionHandle())); + } + +/** +Deletes an existing attachment file in the message store. + +@param aEntryId Entry that has the attachment +@param aFilePath The attachment filename + +@return System wide error code + +@capability None A client with no capabilities can access an entry only if the entry is +under a local service, is owned by the client, is in an unprotected folder, +and is not a service entry. + +@capability WriteDeviceData Required if the entry is a service. + +@capability ReadUserData Required in some circumstances: see the note below. + +@capability WriteUserData Required in some circumstances: see the note below. + +@capability Note The capabilities required to access an entry that is not a service vary depending on the +following conditions: + +- Entry is under the local service: + -# Entry is in the Outbox and the Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities + -# Entry is in the Outbox and the Outbox is unprotected: MTM-specified capabilities + -# Entry is in a protected folder: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the entry is not owned by the client: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the entry is owned by the client: no capabilities + +- Entry is under a remote service: + -# The Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the entry is owned by the client: MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the entry is not owned by the client: ReadUserData + WriteUserData + + MTM-specified capabilities (of the MTM for the remote service) +*/ +EXPORT_C TInt RMsvServerSession::DeleteAttachment(TMsvId aEntryId, const TDesC& aFilePath) + { + return SendReceive(EMsvDeleteAttachment,TIpcArgs(aEntryId,&aFilePath)); + } + +/** +Renames an existing attachment file. + +Renames an existing attachment file in the message store associated with the +message entry specified by the aEntryId parameter. The attachment is +identified by the file path specified by the aOldFilePath parameter and renamed to +the name supplied in the aNewName paramter. + +@param aEntryId The entry whose attachment needs to be renamed from the message store +@param aOldFilePath The name and path of the attachment file to be renamed. +@param aNewName The new name of the attachment file. +@return KErrNone if successful, otherwise any of the system wide error codes. + +@capability None A client with no capabilities can access an entry only if the entry is +under a local service, is owned by the client, is in an unprotected folder, +and is not a service entry. + +@capability WriteDeviceData Required if the entry is a service. + +@capability ReadUserData Required in some circumstances: see the note below. + +@capability WriteUserData Required in some circumstances: see the note below. + +@capability Note The capabilities required to access an entry that is not a service vary depending on the +following conditions: + +- Entry is under the local service: + -# Entry is in the Outbox and the Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities + -# Entry is in the Outbox and the Outbox is unprotected: MTM-specified capabilities + -# Entry is in a protected folder: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the entry is not owned by the client: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the entry is owned by the client: no capabilities + +- Entry is under a remote service: + -# The Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the entry is owned by the client: MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the entry is not owned by the client: ReadUserData + WriteUserData + + MTM-specified capabilities (of the MTM for the remote service) +*/ +EXPORT_C TInt RMsvServerSession::RenameAttachment(TMsvId aEntryId, const TDesC& aOldFilePath, const TDesC& aNewName) + { + return SendReceive(EMsvRenameAttachment,TIpcArgs(aEntryId, &aOldFilePath, &aNewName)); + } + +/** +Checks if the attachment filename specified exists in the store. + +@param aFilePath The complete attachment file path specification + +@capability None + +@return ETrue if the attachment exists, otherwise EFalse +*/ +EXPORT_C TBool RMsvServerSession::FileExistsL(const TDesC& aFilePath) + { + TInt err = SendReceive(EMsvFileExists, TIpcArgs(&aFilePath)); + if( err == KErrNotFound ) + { + return EFalse; + } + + User::LeaveIfError(err); + return ETrue; + } + +/** +Get the file path where the attachments for a particular entry are stored. + +@param aEntryId The message entry Id. +@param aFilePath On return this will contain the filepath for the attachments. + +@capability None +*/ +EXPORT_C void RMsvServerSession::AttachmentFilePathL(TMsvId aEntryId, TDes& aFilePath) + { + User::LeaveIfError(SendReceive(EMsvGetAttachmentFilePath, TIpcArgs(aEntryId, &aFilePath))); + } + +/** +Opens for reading a message store file for the message entry specified. + +@param aEntryId Entry that has the store +@param aFile On return, open file handle to the store.Ownership is transferred . The caller must close the file handle . + +@capability None A client with no capabilities can access an entry only if owns that entry. + +@capability ReadUserData This is required to access any entry where the condition +described for no capabilities does not apply. +*/ +EXPORT_C TInt RMsvServerSession::OpenFileStoreForRead(TMsvId aEntryId, RFile& aFile) + { + TPckg pckgSubSessionHandle(0); // initialise + + // session handle (RFs) received from TransferToClient() in server + TInt sessionHandle = SendReceive(EMsvOpenFileStoreForRead,TIpcArgs(aEntryId,&pckgSubSessionHandle)); + if( sessionHandle < KErrNone ) + return sessionHandle; + + // Adopt the file handle from server + return aFile.AdoptFromServer(sessionHandle ,pckgSubSessionHandle()); + } + +/** +Opens a temporary store file for the message entry specified. + +The function returns an open read-write file handle with an exclusive share to the temporary store file. +This method, along with ReplaceFileStoreL, allows the message store classes to write data to the store +file for a particular message entry. + +@param aEntryId Entry with which to associate the store +@param aFile On return, open file handle to the store. Ownership is transferred . The caller must close the file handle . + +@capability None A client with no capabilities can access an entry only if the entry is +under a local service, is owned by the client, is in an unprotected folder, +and is not a service entry. + +@capability WriteDeviceData Required if the entry is a service. + +@capability ReadUserData Required in some circumstances: see the note below. + +@capability WriteUserData Required in some circumstances: see the note below. + +@capability Note The capabilities required to access an entry that is not a service vary depending on the +following conditions: + +- Entry is under the local service: + -# Entry is in the Outbox and the Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities + -# Entry is in the Outbox and the Outbox is unprotected: MTM-specified capabilities + -# Entry is in a protected folder: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the entry is not owned by the client: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the entry is owned by the client: no capabilities + +- Entry is under a remote service: + -# The Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the entry is owned by the client: MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the entry is not owned by the client: ReadUserData + WriteUserData + + MTM-specified capabilities (of the MTM for the remote service) +*/ +EXPORT_C void RMsvServerSession::OpenTempStoreFileL(TMsvId aEntryId, RFile& aFile) + { + TPckg pckgSubSessionHandle(0); // intitialise + + // session handle (RFs) received from TransferToClient() in server + TInt sessionHandle = SendReceive(EMsvOpenTempStoreFile,TIpcArgs(aEntryId,&pckgSubSessionHandle)); + + // Adopt the file handle from server + User::LeaveIfError(aFile.AdoptFromServer(sessionHandle ,pckgSubSessionHandle())); + } + +/** +Replaces the current store file with the temporary store file, created from OpenTempStoreFileL, for the specified message entry. + +@param aEntryId Entry associated with the store + +@capability None A client with no capabilities can access an entry only if the entry is +under a local service, is owned by the client, is in an unprotected folder, +and is not a service entry. + +@capability WriteDeviceData Required if the entry is a service. + +@capability ReadUserData Required in some circumstances: see the note below. + +@capability WriteUserData Required in some circumstances: see the note below. + +@capability Note The capabilities required to access an entry that is not a service vary depending on the +following conditions: + +- Entry is under the local service: + -# Entry is in the Outbox and the Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities + -# Entry is in the Outbox and the Outbox is unprotected: MTM-specified capabilities + -# Entry is in a protected folder: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the entry is not owned by the client: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the entry is owned by the client: no capabilities + +- Entry is under a remote service: + -# The Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the entry is owned by the client: MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the entry is not owned by the client: ReadUserData + WriteUserData + + MTM-specified capabilities (of the MTM for the remote service) +*/ +EXPORT_C void RMsvServerSession::ReplaceFileStoreL(TMsvId aEntryId) + { + User::LeaveIfError(SendReceive(EMsvReplaceFileStore,TIpcArgs(aEntryId))); + } + +/** +Deletes the store file associated with the specified message entry. + +@capability None A client with no capabilities can access an entry only if the entry is +under a local service, is owned by the client, is in an unprotected folder, +and is not a service entry. + +@capability WriteDeviceData Required if the entry is a service. + +@capability ReadUserData Required in some circumstances: see the note below. + +@capability WriteUserData Required in some circumstances: see the note below. + +@capability Note The capabilities required to access an entry that is not a service vary depending on the +following conditions: + +- Entry is under the local service: + -# Entry is in the Outbox and the Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities + -# Entry is in the Outbox and the Outbox is unprotected: MTM-specified capabilities + -# Entry is in a protected folder: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the entry is not owned by the client: ReadUserData + WriteUserData + -# Entry is in an unprotected folder and the entry is owned by the client: no capabilities + +- Entry is under a remote service: + -# The Outbox is protected: ReadUserData + WriteUserData + MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the entry is owned by the client: MTM-specified capabilities (of the MTM for the remote service) + -# The Outbox is unprotected and the entry is not owned by the client: ReadUserData + WriteUserData + + MTM-specified capabilities (of the MTM for the remote service) +*/ +EXPORT_C void RMsvServerSession::DeleteFileStoreL(TMsvId aEntryId) + { + User::LeaveIfError(SendReceive(EMsvDeleteFileStore,TIpcArgs(aEntryId))); + } + +/** +Tests if a store file exists for the specified message entry. + +@param aEntryId Entry associated with the store + +@return ETrue if the store file exists, otherwise EFalse. + +@capability None +*/ +EXPORT_C TBool RMsvServerSession::FileStoreExistsL(TMsvId aEntryId) const + { + return SendReceive(EMsvFileStoreExists,TIpcArgs(aEntryId)); + } + +/** +Checks a flag in the message server that is set when the server +deletes a corrupt index file. Then clears the flag. + +It is intended to allow the message centre UI to check whether +a corrupt index has been deleted on startup. If it has the UI +may inform the user about the loss of their messages. + +@return ETrue if a corrupt index flag was present indicating that +a corrupt index file has been deleted since the last time this +function was called. + +@capability None +*/ +TBool RMsvServerSession::GetAndClearIndexCorruptFlagL() + { + TInt result=User::LeaveIfError(SendReceive(EMsvGetAndClearIndexCorruptFlag)); + return result==0 ? EFalse : ETrue; + } + +/** Checks if the specified drive has a Message Server index on it. + +@param aDrive Drive to check +@return True if aDrive has a Message Server index, otherwise false +@capability None +*/ +TBool RMsvServerSession::DriveContainsStoreL(TDriveUnit aDrive) + { + TInt result=User::LeaveIfError(SendReceive(EMsvDriveContainsStore,TIpcArgs(aDrive))); + return result==0 ? EFalse : ETrue; + } + +/** Checks to see if the currently selected drive contains the correct mail store. + +If the message store is present on an external drive, we have to check if the same drive is +mounted or not before storing the mail. + +@return ETrue if the same drive is mounted. otherwise returns EFalse +@capability None +*/ +EXPORT_C TBool RMsvServerSession::MessageStoreDrivePresentL() + { + TInt result = User::LeaveIfError(SendReceive(EMsvMessageStoreDrivePresent)); + return result== 0 ? EFalse : ETrue; + } + +EXPORT_C TBool RMsvServerSession::CreateShareProtectedAttachmentForWriteL(TMsvId /*aEntryId*/, TDes& /*aFilename*/, RFile& /*aFile*/) + { + User::Leave(KErrNotSupported); + //Avoid complier errors and warnings... + return EFalse; + } + +/** +Get the file path where the plain body text for a particular entry will be stored. +@param aBodyTextId The TMsvId of the body text entry. +@param aFilePath On return this will contain the filepath for the plainbody text. +@capability None +*/ +EXPORT_C void RMsvServerSession::BodyTextFilePathL(TMsvId aBodyTextId, TDes& aFilePath) + { + User::LeaveIfError(SendReceive(EMsvGetBodyTextFilePath, TIpcArgs(aBodyTextId, &aFilePath))); + } + +/** +Open the bodytext file whose path is given in aFileName. +@param aFile The RFile reference that is to be opened. +@param aBodyTextId The TMsvId of the body text entry. +@capability ReadUserData +*/ +EXPORT_C void RMsvServerSession::OpenBodyTextFileForReadL(RFile& aFile, TMsvId aBodyTextId, const TDesC& aFilePath) + { + TPckg pckgSubSessionHandle(0); + TInt sessionHandle = User::LeaveIfError(SendReceive(EMsvOpenTextFileForRead, TIpcArgs(aBodyTextId, &aFilePath, &pckgSubSessionHandle))); + User::LeaveIfError(aFile.AdoptFromServer(sessionHandle,pckgSubSessionHandle())); + } + +/** +Create a plainbody text file whose path is given in aFilePath. +@param aFile The RFile reference that is to be opened. +@param aBodyTextId The TMsvId of the body text entry. +@capability WriteUserData +*/ +EXPORT_C void RMsvServerSession::CreatePlainTextFileL(RFile& aFile, TMsvId aBodyTextId) + { + TPckg pckgSubSessionHandle(0); + TInt sessionHandle = User::LeaveIfError(SendReceive(EMsvCreatePlainTextFile, TIpcArgs(aBodyTextId, &pckgSubSessionHandle))); + User::LeaveIfError(aFile.AdoptFromServer(sessionHandle,pckgSubSessionHandle())); + } + +/** +Deletes a plainbody text file whose path is given in aFilePath. +@param aBodyTextId The TMsvId of the body text entry. +@capability WriteUserData +*/ +EXPORT_C void RMsvServerSession::DeletePlainTextFileL(TMsvId aBodyTextId) + { + User::LeaveIfError(SendReceive(EMsvDeletePlainTextFile, TIpcArgs(aBodyTextId))); + } + +/** +Replaces a plainbody text file whose Id is given in aBodyTextId. +@param aBodyTextId The TMsvId of the body text entry. +@capability WriteUserData +*/ +EXPORT_C void RMsvServerSession::ReplacePlainTextFileL(TMsvId aBodyTextId) + { + User::LeaveIfError(SendReceive(EMsvReplacePlainTextFile,TIpcArgs(aBodyTextId))); + } + + + +#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT) +/** + * GetChildrenAll() + * + * @param TMsvId: ID of the parent entry. + * @param TMsvSelectionOrdering: Sorting and grouping rules for the returned entries. + * @param CArrayPtrFlat: On return, the entry's children. If an error is returned, aEntries is unchanged. + * @return TInt: System wide error code + * + * @capability None Only children that the client owns are returned. + * @capability ReadUserData All children of the entry are returned + * + * Gets the children of a parent entry specified as first argument. + * If the passed parent is a standard folder the function will fetch + * entries from all drives currently present in the preferred drive list. + */ +EXPORT_C TInt RMsvServerSession::GetChildrenAll(TMsvId aId, CArrayPtrFlat& aEntries, const TMsvSelectionOrdering& aOrdering) + { + TInt origCount = aEntries.Count(); + TInt leave = KErrNone; + + TRAP(leave, DoGetChildrenAllL(aId, aEntries, aOrdering)); + if(KErrNone != leave) + { + TInt count=aEntries.Count(); + while(count > origCount) + { + delete aEntries.At(--count); + aEntries.Delete(count); + } + } + return leave; + } + + +void RMsvServerSession::DoGetChildrenAllL(TMsvId aId, CArrayPtrFlat& aEntries, const TMsvSelectionOrdering& aOrdering) +// +// Gets the children of the index entry with the Unique id aId. +// + { + // package up the Id into a children details class + TPckgBuf details; + details().iParentId = aId; + // pass the sort order + TPckgC package2(aOrdering); + // pass the buffer to receive the data through + TPtr8 ptr=iBuffer->Des(); + + // signal the server + TInt error = SendReceive(EMsvGetChildrenALL, TIpcArgs(&details,&package2,&ptr)); + + if (error!=KErrNone && error!=KErrOverflow) + User::Leave(error); + + // unpack the entries from the buffer + TMsvPackedEntryArray packedEntryArray(iBuffer); + for (TInt count=0; countDes(); + + TInt error = SendReceive(EMsvGetChildIdsALL, TIpcArgs(&ptr, aId)); + while(error == KErrOverflow) + { + // increase the size of the buffer and try again + iBuffer->Des().SetLength(0); // to avoid copying contents + iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength); + TMsvPackedEntryFilter package1(iBuffer); + User::LeaveIfError(package1.PackFilter(aFilter)); + TPtr8 ptr2=iBuffer->Des(); + error = SendReceive(EMsvGetChildIdsALL,TIpcArgs(&ptr2,aId)); + } + + User::LeaveIfError(error); + TInt temp1(0); + TInt temp2(0); + TMsvPackedOperation op(iBuffer); + op.UnpackL(aSelection, temp1, temp2); + } + + + + +/** + * CurrentDriveInfo() + * + * @return TDriveNumber: Drive number of the current drive + * in the preferred drive list. + * @return TUint : Priority of the drive. + * + * Code changes for PREQ 557. + * The function returns the current drive of message server. + */ +EXPORT_C void RMsvServerSession::CurrentDriveInfoL(TDriveNumber& aDriveNumber, TUint& aPriority) + { + TPckg driveNum(aDriveNumber); + TPckg priority(aPriority); + + User::LeaveIfError(SendReceive(EMsvGetCurrentDriveInfo, TIpcArgs(&driveNum, &priority))); + } + + + +/** + * DriveList() + * + * @return RArray: List of drive number present in + * the preferred drive list arranged in decrementing order + * of their priority. + * + * Code changes for PREQ 557. + */ +EXPORT_C void RMsvServerSession::DriveListL(RArray& aDriveList) + { + TPtr8 ptr = iBuffer->Des(); + User::LeaveIfError(SendReceive(EMsvGetDriveList, TIpcArgs(&ptr))); + + // Unpack the entries from the buffer. + TMsvPackedDriveIdOperation packedDriveIdOperation(iBuffer); + packedDriveIdOperation.UnpackL(aDriveList); + } + + + + +/** + * AvailableDriveListL() + * + * @return RArray: List of drive number of available + * drives present in the preferred drive list arranged in + * decrementing order of their priority. + * + * Code changes for PREQ 557. + * NOTE: A drive number is available only if it has a valid + * (readable and of correct version) message store in it. + */ +EXPORT_C void RMsvServerSession::AvailableDriveListL(RArray& aDriveList) + { + TPtr8 ptr = iBuffer->Des(); + User::LeaveIfError(SendReceive(EMsvGetAvailableDriveList, TIpcArgs(&ptr))); + + // Unpack the entries from the buffer. + TMsvPackedDriveIdOperation packedDriveIdOperation(iBuffer); + packedDriveIdOperation.UnpackL(aDriveList); + } + + + + +/** + * AddDriveL() + * + * @param TDriveNumber: Drive number of the drive + * to be added. + * @param TUint : Priority of the drive. + * @return TUint : New priority of the added drive. + * + * Code changes for PREQ 557. + * The function adds the passed drive in the preferred drive list. + * The location of the drive in the list is specified by the priority + * of the drive as specified in the second argument. + * + * - If the priority value of the drive is more than the number of + * elements in the preferred drive list, the function appends the drive + * at the end of the list. The new priority of the drive is returned as + * the second argument. + * - If the priority of the new drive is higher than the current drive + * of message server, and if the new drive has a media in it, the message + * server will perform implicit changeDrive and sends a notification to + * all registered client processes about the change. + * - If the drive does not contain a valid version of message store the + * function updates the drive status to EMsvMessageStoreNotSupported and + * sends appropriate notification to the client process. The drive's content + * will not be visible to any of the client processes. + * - If the message store/message index database in the media is corrupt, + * the server will delete the message store and create a fresh message store + * and related files in the media. + * - If the number of drive already present in the preferred list is eight, + * the function will return appropriate error message. + * - In all cases mentioned above, if the drive is successfully added to the + * preferred drive list the function will also update the central repository + * with the new preferred drive list. + */ +EXPORT_C void RMsvServerSession::AddDriveL(TDriveNumber aDriveNumber, TUint& aPriority) + { + TUint newPriority = aPriority; + TPckg priorityPkg(newPriority); + if(!RFs::IsValidDrive(aDriveNumber)) + { + User::Leave(KErrArgument); + } + User::LeaveIfError(SendReceive(EMsvAddDriveToDriveList, TIpcArgs(aDriveNumber, aPriority, &priorityPkg))); + aPriority = newPriority; + } + + + +/** + * RemoveDriveL() + * + * @param TDriveNumber: Drive number of the drive + * to be removed. + * + * Code changes for PREQ 557. + * The function removes the drive from the preferred + * drive list. If the current drive is being removed, + * the next available drive in the preferred drive list + * becomes the current drive. The device internal drive + * cannot be removed from the preferred drive list. + * Appropriate notification will be sent to the client + * process if there is a change in the current drive. + * The function will also update the central repository + * accordingly. + */ + EXPORT_C void RMsvServerSession::RemoveDriveL(TDriveNumber aDriveNumber) + { + if(!RFs::IsValidDrive(aDriveNumber)) + { + User::Leave(KErrArgument); + } + User::LeaveIfError(SendReceive(EMsvRemoveDriveFromDriveList, TIpcArgs(aDriveNumber))); + } + + + + /** + * UpdateDrivePriorityL() + * + * @param TDriveNumber: Drive number of the drive + * to be updated. + * @param TUint : Priority of the drive. + * @return TUint : New priority of the drive. + * + * Code changes for PREQ 557. + * The function updates the priority of the drive + * already present in the preferred drive list. If + * the priority being mentioned is greater than the + * number of drive present in the list, the drive + * will be added at the end of the preferred drive list. + * The function will then return the new priority of + * the drive. If updating a priority makes a non-current + * drive the current drive or vice-versa, the function + * will implicitly perform changeDrive() and send the + * notification to all registered client. It will return + * error if the said drive is not already present in the + * preferred drive list. + */ +EXPORT_C void RMsvServerSession::UpdateDrivePriorityL(TDriveNumber aDriveNumber, TUint& aPriority) + { + TUint newPriority = aPriority; + TPckg priorityPkg(newPriority); + if(!RFs::IsValidDrive(aDriveNumber)) + { + User::Leave(KErrArgument); + } + User::LeaveIfError(SendReceive(EMsvUpdateDrivePriority, TIpcArgs(aDriveNumber, aPriority, &priorityPkg))); + aPriority = newPriority; + } + + +#if (defined SYMBIAN_MESSAGESTORE_UNIT_TESTCODE) +void RMsvServerSession::ResetRepositoryL() + { + User::LeaveIfError(SendReceive(EMsvResetRepository)); + } +#endif // #if (defined SYMBIAN_MESSAGESTORE_UNIT_TESTCODE) +#endif // #if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT) + + + +/** +Gets data from a server MTM that is not related to any operation being performed on +that MTM. + +@param aServiceId The ID of the service from which to get the data +@param aType The type of MTM data to get. +@param aMtmData A packaged buffer to store the data + +@return KErrNone if successful or one of the system wide error codes +*/ +TInt RMsvServerSession::GetNonOperationMtmData(TMsvId aServiceId, const TNonOperationMtmDataType& aMtmDataType, TDes8& aMtmData) + { + return SendReceive(EMsvGetNonOperationMtmData, TIpcArgs(aServiceId, aMtmDataType, &aMtmData)); + } + + +/** +SearchSort Request on Header and/or Body part +@param aQuery SearchSortQuery object +@param aOperationId Opertion Id +@param aMarkQuery TBool for QueryId, whether needs to mark at server side or not +@param aRequestStatus TRequestStatus status +@capability WriteUserData +*/ +void RMsvServerSession::SearchSortRequestOnHeaderBodyL(const CMsvSearchSortQuery* aQuery, TMsvOp aOperationId, TBool aMarkQuery, TRequestStatus& aRequestStatus) + { + TestSlotAvailableL(); + TMsvPackQuery packedQuery(iBuffer); + TInt error = packedQuery.PackQuery(aQuery); + while(error!=KErrNone) + { + // increase the size of the buffer and try again + iBuffer->Des().SetLength(0); // to avoid copying contents + iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength); + error = packedQuery.PackQuery(aQuery); + } + // pass data to the server + SendReceive(EMsvSearchSortOperation, TIpcArgs(aOperationId, iBuffer, aMarkQuery), aRequestStatus); + } + + +/** +Get results for given QueryId +@param aQueryId queryId from client +@param aOperationId Opertion Id +@param aIterator Whether results should be send in iterator +@param aRequestStatus TRequestStatus status +@capability ReadUserData +*/ +void RMsvServerSession::GetResultsForQueryId(TInt& aQueryId, TMsvOp aOperationId, TInt aIterator, TRequestStatus& aRequestStatus) + { + SendReceive(EMsvSearchSortQueryId, TIpcArgs(aOperationId, aQueryId, aIterator), aRequestStatus); + } + + +/** +Search Sort Request on TMsvEntry +@param aQuery SearchSortQuery object +@param aOperationId Opertion Id +@param aMarkQuery TBool for QueryId, whether needs to mark at server side or not +@param aIterator Whether results should be send in iterator +@param aRequestStatus TRequestStatus status +@capability ReadUserData +*/ +void RMsvServerSession::SearchSortRequestOnEntryL(const CMsvSearchSortQuery* aQuery, TMsvOp aOperationId, TBool aMarkQuery, TInt aIterator, TRequestStatus& aRequestStatus) + { + TestSlotAvailableL(); + // package up the query into a query entry + TMsvPackQuery packedQuery(iBuffer); + TInt error = packedQuery.PackQuery(aQuery); + while(error!=KErrNone) + { + // increase the size of the buffer and try again + iBuffer->Des().SetLength(0); // to avoid copying contents + iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength); + error = packedQuery.PackQuery(aQuery); + } + SendReceive(EMsvSearchSortOnIndexEntry, TIpcArgs(aOperationId, iBuffer, aMarkQuery, aIterator), aRequestStatus); + } + +/** +Get search sort results as TMsvId +@param aId RArray of TMsvId's sent by server +@capability ReadUserData +*/ +void RMsvServerSession::GetResultAsIdL(RArray& aId) + { + TBool resultType=ETrue; // result as TMsvId + + // pass the buffer to receive the data through + TPtr8 ptr=iBuffer->Des(); + // signal the server + TInt error = SendReceive(EMsvGetResult,TIpcArgs(&resultType, &ptr)); + while(error == KErrOverflow) + { + // increase the size of the buffer and try again + iBuffer->Des().SetLength(0); + iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength); + // pass the buffer to receive the data through + TPtr8 ptr=iBuffer->Des(); + error = SendReceive(EMsvGetResult,TIpcArgs(&resultType, &ptr)); + } + User::LeaveIfError(error); + + // unpack the entries from the buffer + TMsvPackedIdOperation packedIdOperation(iBuffer); + packedIdOperation.UnpackL(aId); + } + + +/** +Get search sort Request QueryId +@param aQueryId get aQueryId from server +@capability ReadUserData +*/ +void RMsvServerSession::GetSearchSortRequestQueryIdL(TInt& aQueryId) + { + TPckg queryId(aQueryId); + User::LeaveIfError(SendReceive(EMsvGetQueryId,TIpcArgs(&queryId))); + } + + +/** +Unmark the QueryId it was marked at server side +@param aQueryId Unmark the aQueryId at server +@capability WriteUserData +*/ +void RMsvServerSession::UnmarkSearchSortRequestQueryIdL(TInt aQueryId) + { + User::LeaveIfError(SendReceive(EMsvUnmarQueryId,TIpcArgs(&aQueryId))); + } + + +/** +Sending TMsvId along with Sort filed to server, so that it will update the data in search-sort cache. +@param aOperationId Opertion Id +@param aTMsvIdWithSortField RArray of TMsvId along with Sort filed. +@param aRequestStatus TRequestStatus status +@capability WriteUserData +*/ +void RMsvServerSession::SendResultantListL(TMsvOp aOperationId, RArray aTMsvIdWithSortField, TRequestStatus& aRequestStatus) + { + TestSlotAvailableL(); + + // need to pack TMsvId and TMessagePart (i.e TMsvId and Sort field) + TMsvPackedIdAndMessagePart packIdAndMessagePart; + + // calculate size of the TTMsvIdWithMessagePart + TInt bufferSize = packIdAndMessagePart.Size(aTMsvIdWithSortField); + + // if size lessthan KMsvSessionBufferLength, allocate KMsvSessionBufferLength to sync with iBuffer initial allocation. + if(bufferSize < KMsvSessionBufferLength) + { + bufferSize = KMsvSessionBufferLength; + } + + // allocate the buffer + CBufFlat* flat = CBufFlat::NewL(bufferSize); + CleanupStack::PushL(flat); + flat->ExpandL(0, bufferSize); + + RBufWriteStream writeStream(*flat); + CleanupClosePushL (writeStream); + + // Externalize the data availbe in TTMsvIdWithMessagePart + packIdAndMessagePart.ExternalizeL(writeStream, aTMsvIdWithSortField); + TPtr8 ptr8 = flat->Ptr(0); + + // delete memory allocated for iBuffer + if(iBuffer != NULL) + { + delete iBuffer; + iBuffer = NULL; + } + + //Convert CBufFlat into a HBufC8 + iBuffer = ptr8.AllocL(); + + // send to server + SendReceive(EMsvIdWithSortFiled, TIpcArgs(aOperationId, iBuffer), aRequestStatus); + CleanupStack::PopAndDestroy(2, flat); + } + +/** +Sending result to server, this needs be sorted along with existing partial query. +@param aOperationId Opertion Id +@param aIdArray RArray of TMsvId +@param aRequestStatus TRequestStatus status +@capability WriteUserData +*/ +void RMsvServerSession::SendNewResultsToServerForSortL(TMsvOp aOperationId, RArray& aIdArray, TRequestStatus& aRequestStatus) + { + TestSlotAvailableL(); + TMsvPackedIdOperation op(iBuffer); + TInt error = op.Pack(aIdArray); + while (error != KErrNone) + { + // increase the size of the buffer and try again + iBuffer->Des().SetLength(0); // to avoid copying contents + iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength); + error = op.Pack(aIdArray); + } + SendReceive(EMsvUpdateAndSort, TIpcArgs(aOperationId, iBuffer), aRequestStatus); + } + +/** +Get list TMsvId from the server. +The list of TMsvId's may be + case i) Final Result + case ii) Partial Result + case iii) New Query, needs search on Header and/or Body +@param aId RArray of TMsvId's (for case i & ii) +@param aResultStatus Result status, it will tell what kind of result it is.. +@capability ReadUserData +*/ +void RMsvServerSession::GetResultAsIdL(RArray& aId, TInt &aResultStatus) + { + // pass the buffer to receive the data through + + TPtr8 ptr=iBuffer->Des(); + TPckg resultStatus(aResultStatus); + + // signal the server + TInt error = SendReceive(EMsvGetIdsOrResult,TIpcArgs(&ptr, &resultStatus)); + while(error == KErrOverflow) + { + // increase the size of the buffer and try again + iBuffer->Des().SetLength(0); + iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength); + + // pass the buffer to receive the data through + TPtr8 ptr=iBuffer->Des(); + error = SendReceive(EMsvGetIdsOrResult,TIpcArgs(&ptr, &resultStatus)); + } + User::LeaveIfError(error); + + // unpack aId from the buffer + TMsvPackedIdOperation packedIdOperation(iBuffer); + packedIdOperation.UnpackL(aId); + } + +/** +Get next TMsvEntry from server +@param aEntry next result as TMsvEntry +@capability ReadUserData +*/ +void RMsvServerSession::GetNextEntryL(TMsvEntry& aEntry, TInt& aCount) + { + TPckg count(aCount); + // pass the buffer to receive the data through + TPtr8 ptr=iBuffer->Des(); + // signal the server + TInt error = SendReceive(EMsvGetNextEntry,TIpcArgs(&ptr, &count)); + while(error == KErrOverflow) + { + // increase the size of the buffer and try again + iBuffer->Des().SetLength(0); + iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength); + // pass the buffer to receive the data through + TPtr8 ptr=iBuffer->Des(); + error = SendReceive(EMsvGetNextEntry,TIpcArgs(&ptr, &count)); + } + User::LeaveIfError(error); + TMsvPackedEntry packedEntry(iBuffer); + packedEntry.UnpackEntry(aEntry); + } + + +/** +Get next TMsvId from server +@param aId next result as TMsvId +@capability ReadUserData +*/ +void RMsvServerSession::GetNextIdL(TMsvId& aId, TInt& aCount) + { + TPckg tmsvId(aId); + TPckg count(aCount); + + TInt error = SendReceive(EMsvGetNextId,TIpcArgs(&tmsvId, &count)); + User::LeaveIfError(error); + } + +/** +Get Result count from server +@param aCount Result count +@capability ReadUserData +*/ +void RMsvServerSession::GetResultCountL(TInt& aCount) + { + TPckg count(aCount); + // get result count from server + User::LeaveIfError(SendReceive(EMsvGetResultCount,TIpcArgs(&count))); + } + +/** +Get Search sort request from server +This Query is requied in case partial result for the QueryId +@param aQuery Search Sort Query object +@param aOpId Opertion Id +@capability ReadUserData +*/ +void RMsvServerSession::GetQueryFromServerL(TMsvOp aOperationId, TInt aQueryId, CMsvSearchSortQuery* aQuery) + { + // pass the buffer to receive the query data + TPtr8 ptr=iBuffer->Des(); + // signal the server + TInt error = SendReceive(EMsvQueryData,TIpcArgs(aOperationId, aQueryId, &ptr)); + while(error == KErrOverflow) + { + // increase the size of the buffer and try again + iBuffer->Des().SetLength(0); + iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength); + // pass the buffer to receive the data through + TPtr8 ptr=iBuffer->Des(); + error = SendReceive(EMsvQueryData,TIpcArgs(aOperationId, aQueryId, &ptr)); + } + User::LeaveIfError(error); + + TMsvPackQuery packedQuery(iBuffer); + packedQuery.UnpackQuery(aQuery); + } + +/** +Get Progress information from the server for a given Request. +@param aOperationProgress Operation progress +@param aOpId Opertion Id +@capability ReadUserData +*/ +void RMsvServerSession::SearchSortOperationProgressL(TMsvOp aOperationId, TInt aOperationProgress) + { + TPckg progressInfo(aOperationProgress); + User::LeaveIfError(SendReceive(EMsvGetSearchSortProgress,TIpcArgs(aOperationId, &progressInfo))); + } + +/** +Cancel current saerch sort Request. +@param aOpId Opertion Id +@capability ReadUserData +*/ +int RMsvServerSession::CancelSearchSortOperation(TMsvOp aOperationId) + { + TInt error = SendReceive(EMsvCancelSearchSortOp,TIpcArgs(aOperationId)); + return error; + } + + +#if (defined SYMBIAN_MSGS_ENHANCED_REMOVABLE_MEDIA_SUPPORT) +#if (defined SYMBIAN_MESSAGESTORE_UNIT_TESTCODE) +/** +Print cache structure in a log file. +*/ +EXPORT_C void RMsvServerSession::PrintCache() + { + SendReceive(EMsvPrintCache); + } +#endif +#endif + + + + +#if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB) + +/** + * CreateStoreL() + * + * A headerStore is associated with a mtm type and stores message header + * data. Message server creates a separate store for each MTM type. A + * header-entry in the headerStore is essentially a list of UID-Data entries. + * For example an email header-entry can have CImHeader, MIME header and + * encoded header stored as a separate UID-Data entry in the header store. + * By default a UID-Data entry will have a "Default" field which store the + * content of 'Data'. Moreover one such UID-Data pair can also specify mutiple + * fields such that it can store individual portion of data in such fields + * separately. + * + * @param TUid: MtmId of the header store. + * @param RPointerArray: Structure of the Data fields in a UID-Data pair. + * The store by default add a 'Details' field to store the content of data. + * @return None. + * + * @leave: All System wide error code. + * + * @capability WriteDeviceData + */ +void RMsvServerSession::CreateStoreL(const TUid& aMtmId, const RPointerArray& aFieldDetails) + { + TMsvPackedHeaderStructure packedHeaderStruct(iBuffer); + TInt error = packedHeaderStruct.Pack(aFieldDetails); + while(error!=KErrNone) + { + // increase the size of the buffer and try again + iBuffer->Des().SetLength(0); // to avoid copying contents + iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength); + error = packedHeaderStruct.Pack(aFieldDetails); + } + + // package up the entry into a packed entry + User::LeaveIfError(SendReceive(EMsvCreateStore, TIpcArgs(aMtmId.iUid, iBuffer))); + } + + + + + +/** + * DoesStoreExistsL() + * + * The function checks the existence of a header store + * for a given MTM Id. The function can be called to + * check if the header store already exist before creating + * the store. + * + * @param TUid: Mtm UID of the store. + * @return TBool: ETrue, if the store exists, else EFalse. + * + * @capability ReadDeviceData + */ +TBool RMsvServerSession::DoesStoreExistsL(const TUid& aMtmId) + { + TPckg isStoreExists = EFalse; + User::LeaveIfError(SendReceive(EMsvCheckStoreExists, TIpcArgs(aMtmId.iUid, &isStoreExists))); + return isStoreExists(); + } + + + + + + +/** + * LastErrorMessageL() + * + * The function returns the detail error message + * received while creating the header store. + * + * @param HBufC*: Error message text. + * @return None. + * @leave: All system wide error code. + */ +void RMsvServerSession::LastErrorMessageL(HBufC*& aErrorMsg) + { + TPtr8 ptr8 = iBuffer->Des(); + User::LeaveIfError(SendReceive(EMsvLastErrorMessage, TIpcArgs(&ptr8))); + + TInt* ptr = (TInt*) CONST_CAST(TUint8*, iBuffer->Ptr()); + TInt textSize = *ptr++; + + TPtrC16 ptrBuf; + const TText* textPtr = (TText*)ptr; + ptrBuf.Set(textPtr, (textSize/2)); + + aErrorMsg = ptrBuf.AllocL(); + } + + + + + + + +/** + * CreateHeaderEntryL() + * + * This function creates a new message header in the header-store. A message header is + * essentially a list of UID-Data entry. At most one entry in the list must have + * values for all the fields created in the header store. Rest all entries should have + * values for only default field 'Details'. + * + * @param TUid: MtmId to identify the header table. + * @param TMsvId: Metadata Entry Id. + * @param RPointerArray: Header details. + * @return None. + * @leave KErrAlreadyExists, if entry already exists. + * @leave KErrArgument, if incorrect arguments and system wide leave code. + * + * @capability WriteUserData + */ +EXPORT_C void RMsvServerSession::CreateHeaderEntryL(const TUid& aMtmId, TMsvId aEntryId, const RPointerArray& aFieldPairList) + { + TMsvPackedHeaderData packedHeaderData(iBuffer); + TInt error = packedHeaderData.Pack(aFieldPairList); + while(error!=KErrNone) + { + // increase the size of the buffer and try again + iBuffer->Des().SetLength(0); // to avoid copying contents + iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength); + error = packedHeaderData.Pack(aFieldPairList); + } + + User::LeaveIfError(SendReceive(EMsvCreateHeaderEntry, TIpcArgs(aMtmId.iUid, aEntryId, iBuffer))); + } + + + + + +/** + * LoadHeaderEntryL() + * + * This function loads the header entry from the header-store + * and returns to the client. + * + * @param TUid: MtmId to identify the header table. + * @param TMsvId: Metadata Entry Id. + * @param RPointerArray: Header entry details. + * @return None. + * @leave KErrNotFound: If entry not found. + * + * @capability ReadUserData + */ + EXPORT_C void RMsvServerSession::LoadHeaderEntryL(const TUid& aMtmId, TMsvId aEntryId, RPointerArray& aFieldPairList) + { + TPtr8 ptr = iBuffer->Des(); + User::LeaveIfError(SendReceive(EMsvLoadHeaderEntry, TIpcArgs(aMtmId.iUid, aEntryId, &ptr))); + + TMsvPackedHeaderData packedHeaderData(iBuffer); + TRAPD(error, packedHeaderData.UnpackL(aFieldPairList)); + while(error!=KErrNone) + { + // increase the size of the buffer and try again + iBuffer->Des().SetLength(0); // to avoid copying contents + iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength); + TRAP(error, packedHeaderData.UnpackL(aFieldPairList)); + } + } + + + + + + +/** + * DeleteHeaderEntryL() + * + * This function deletes the header entry from the header-store. + * + * @param aMtmId: MtmId to identify the header table. + * @param aEntryId: Entry Id. + * @return None. + * @leave KErrNotFound: If entry not found. + * + * @capability WriteUserData + */ +EXPORT_C void RMsvServerSession::DeleteHeaderEntryL(const TUid& aMtmId, TMsvId aEntryId) + { + User::LeaveIfError(SendReceive(EMsvDeleteHeaderEntry, TIpcArgs(aMtmId.iUid, aEntryId))); + } + + + + + +/** + * UpdateHeaderEntryL() + * + * This function udpates the header entry in the header-store. A header entry is + * essentially a list of UID-String combination which is stored as a separate + * element in the passed header structure. + * + * If the number of UID-String element in the passed header structure is more + * than what is present in the DB, the function inserts the new UID-String entry + * in the header store. And if the few entries are missing from the passed header + * structure the function deletes the extra entry from the header store. + * + * @param TUid: MtmId to identify the header table. + * @param TMsvId: Entry Id. + * @param RPointerArray: Header entry details. + * @return None. + * @leave KErrNotFound, if entry to be updated not found and all system wide leave code. + * + * @capability WriteUserData + */ +EXPORT_C void RMsvServerSession::UpdateHeaderEntryL(const TUid& aMtmId, TMsvId aEntryId, const RPointerArray& aFieldPairList) + { + TMsvPackedHeaderData packedHeaderData(iBuffer); + TInt error = packedHeaderData.Pack(aFieldPairList); + while(error!=KErrNone) + { + // increase the size of the buffer and try again + iBuffer->Des().SetLength(0); // to avoid copying contents + iBuffer = iBuffer->ReAllocL(iBuffer->Des().MaxSize() + KMsvSessionBufferLength); + error = packedHeaderData.Pack(aFieldPairList); + } + + User::LeaveIfError(SendReceive(EMsvUpdateHeaderEntry, TIpcArgs(aMtmId.iUid, aEntryId, iBuffer))); + } + + + + + + +/** + * DoesAnyStoreExists() + * + * This function checks if the store (header/body) exists + * for a given metadata entry. + */ +EXPORT_C TBool RMsvServerSession::DoesAnyStoreExists(TMsvId aId, TUid aMtmId) + { + return SendReceive(EMsvCheckAnyStoreExists, TIpcArgs(aId, aMtmId.iUid)); + } + + + + +/** + * DoesHeaderTableExist() + * + * This function checks if the header table exists + * for a given MTM type. + */ +EXPORT_C TBool RMsvServerSession::DoesHeaderTableExist(const TUid& aMtmId) + { + return SendReceive(EMsvCheckHeaderTableExist, TIpcArgs(aMtmId.iUid)); + } + + +/********************************Converter API's***************************/ +/* + GetConvertibleDriveListL() + Fetches a list of unsupported drives. Any drive is rendered unsupported + if the message store version is less than current message store version. + + @param aDriveList: RArray containing unsupported drive numbers. + @return None + */ +void RMsvServerSession::GetConvertibleDriveListL(RArray& aDriveList) + { + TPtr8 ptr = iBuffer->Des(); + User::LeaveIfError(SendReceive(EMsvGetConvertibleDriveList, TIpcArgs(&ptr))); + // Unpack the entries from the buffer. + TMsvPackedDriveIdOperation packedDriveIdOperation(iBuffer); + packedDriveIdOperation.UnpackL(aDriveList); + } + +/* + ConvertMessageStore() + Starts message store conversion on a drive asynchronously. + The message store to be converted is identified by the drive number + Message store conversion is an asynchronous operation and the client gets + notified by TRequestStatus variable.Message store conversion starts only when + the drive meets different validation criteria. + + + @param aDrive: Drive number. + @param aRequestStatus: Indicates the completion status of a request made to a service provider.. + @return None + */ +void RMsvServerSession::ConvertMessageStore(TDriveNumber aDrive,TRequestStatus& aRequestStatus) + { + aRequestStatus=KRequestPending; + SendReceive(EMsvConvertMessageStore, TIpcArgs(aDrive), aRequestStatus); + } + +/* + GetConversionStatusL() + Gets the conversion status for the specified drive + + @param aDrive: Drive number. + @return None + */ +void RMsvServerSession::GetConversionStatusL(TDriveNumber aDrive) + { + User::LeaveIfError(SendReceive(EMsvGetConversionStatus, TIpcArgs(aDrive))); + } + +/* + CancelConversion() + Cancels conversion for the specified drive. + + @param aDrive: Drive number. + @return TInt: System wide error codes + */ +TInt RMsvServerSession::CancelConversion(TDriveNumber aDrive) + { + return SendReceive(EMsvCancelConversionRequest, TIpcArgs(aDrive)); + } +#endif // #if (defined SYMBIAN_MESSAGESTORE_HEADER_BODY_USING_SQLDB)