--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmsengine/mmsserver/src/mmsreceivemessage.cpp Fri Jun 04 10:25:39 2010 +0100
@@ -0,0 +1,3028 @@
+/*
+* Copyright (c) 2002-2007 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:
+* State machine for message receiving
+*
+*/
+
+
+
+// INCLUDE FILES
+#include <apparc.h>
+#include <msventry.h>
+#include <msvids.h>
+#include <charconv.h>
+#include <badesca.h>
+#include <cmsvmimeheaders.h>
+#include <mmsvattachmentmanager.h>
+#include <mmsvattachmentmanagersync.h>
+
+#include <centralrepository.h>
+
+// mms private headers
+#include "mmsconst.h"
+#include "mmsreceivemessage.h"
+#include "mmssession.h"
+#include "mmssettings.h"
+#include "mmsservercommon.h"
+#include "mmsheaders.h"
+#include "mmsdecode.h"
+#include "mmsencode.h"
+#include "mmsscheduledentry.h"
+#include "mmserrors.h"
+#include "mmsserverentry.h"
+#include "mmsconninit.h"
+#include "MmsEnginePrivateCRKeys.h"
+#include "MmsPhoneClient.H"
+
+// EXTERNAL DATA STRUCTURES
+
+// EXTERNAL FUNCTION PROTOTYPES
+extern void gPanic(TMmsPanic aPanic);
+
+// CONSTANTS
+// return codes for handling of messages addressed to an application
+const TInt KMmsMessageForUnregisteredApplication = 1;
+const TInt KMmsMessageMovedToApplicationFolder = 2;
+
+// MACROS
+
+// LOCAL CONSTANTS AND MACROS
+
+// MODULE DATA STRUCTURES
+
+// LOCAL FUNCTION PROTOTYPES
+
+// ==================== LOCAL FUNCTIONS ====================
+
+
+// ================= MEMBER FUNCTIONS =======================
+
+// C++ default constructor can NOT contain any code, that
+// might leave.
+//
+CMmsReceiveMessage::CMmsReceiveMessage( RFs& aFs )
+ :CMmsBaseOperation( aFs )
+ {
+ }
+
+// Symbian OS default constructor can leave.
+void CMmsReceiveMessage::ConstructL( CMmsSettings* aMmsSettings )
+ {
+ iFileOpen = EFalse;
+ CMmsBaseOperation::ConstructL( aMmsSettings );
+ iMmsHeaders = CMmsHeaders::NewL( iMmsSettings->MmsVersion() );
+ iNotification = CMmsHeaders::NewL( iMmsSettings->MmsVersion() );
+ iBad = new( ELeave ) CMsvEntrySelection;
+ TRAPD ( error, {iMessageDrive = MessageServer::CurrentDriveL( iFs );});
+ if ( error != KErrNone )
+ {
+ // if cannot ask, use default
+ iMessageDrive = EDriveC;
+ }
+
+ CActiveScheduler::Add( this );
+ }
+
+// Two-phased constructor.
+CMmsReceiveMessage* CMmsReceiveMessage::NewL( RFs& aFs, CMmsSettings* aMmsSettings )
+ {
+ CMmsReceiveMessage* self = new ( ELeave ) CMmsReceiveMessage( aFs );
+
+ CleanupStack::PushL( self );
+ self->ConstructL( aMmsSettings );
+ CleanupStack::Pop( self );
+
+ return self;
+ }
+
+
+// Destructor
+CMmsReceiveMessage::~CMmsReceiveMessage()
+ {
+
+ Cancel();
+
+ delete iMmsHeaders;
+ delete iNotification;
+ delete iBad;
+ // This is the message for local mode testing
+ // It is closed here only to make sure that it is
+ // always closed even if we encounter a serious error.
+ // otherwise it should already be closed by now.
+ if ( iFileOpen )
+ {
+ iFile.Close();
+ }
+ }
+
+
+// ---------------------------------------------------------
+// CMmsReceiveMessage::StartL
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::StartL(
+ CMsvEntrySelection& aSelection,
+ CMsvServerEntry& aServerEntry,
+ TMsvId aService,
+ TRequestStatus& aStatus )
+ {
+ __ASSERT_DEBUG( iState == EMmsOperationIdle, gPanic( EMmsAlreadyBusy ) );
+
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("ReceiveMsg StartL") );
+#endif
+ // just initialize common member variables
+ CMmsBaseOperation::InitializeL( aSelection, aServerEntry, aService );
+
+ iReceivingMode = iMmsSettings->ReceivingModeHome();
+
+ iNotificationParent = KMsvNullIndexEntryId;
+ iBad->Reset();
+ iNotification->Reset();
+ iResponse->Reset(); // This sets the correct version
+ iMmsHeaders->Reset();
+ iEntryUnderConstruction = KMsvNullIndexEntryId;
+ iAlreadyDeferred = EFalse;
+ iFileOpen = EFalse;
+
+ // selection is supposed to point to a bunch of notifications
+ // containing the URIs the messages are to be fetched from
+ TInt count = iCurrentMessageNo;
+ iError = KErrNone;
+
+ while ( count > 0 && ( iNotificationParent == KMsvNullIndexEntryId ) )
+ {
+ // Load the notification
+ // iCurrentMessageNo (and therefore also count) has originally been
+ // set to iSelection->Count() so the index is always valid.
+ count--; // indexes are zero based
+ if ( count < iSelection->Count() )
+ {
+ iError = iServerEntry->SetEntry( iSelection->At( count ) );
+ }
+ else
+ {
+ iError = KErrNotFound;
+ }
+ if ( iError == KErrNone )
+ {
+ TMsvEntry entry = iServerEntry->Entry();
+ iNotificationParent = entry.Parent();
+ }
+ }
+
+ // release the last notification
+ iServerEntry->SetEntry( KMsvNullIndexEntryId );
+
+ if ( iNotificationParent == KMsvNullIndexEntryId )
+ {
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("- could not access any entry to get parent") );
+#endif
+ // nothing to receive. Give up immediately
+ aStatus = KRequestPending;
+ TRequestStatus* status = &aStatus;
+ User::RequestComplete( status, iError );
+ return;
+ }
+
+ // Initialize everything into the failed list.
+ // Very pessimistic indeed.
+
+ iBad->SetReserveL( iCurrentMessageNo );
+
+ Queue( aStatus );
+
+ // We complete ourselves to get into the state machine loop.
+ // The first thing to do is to check the roaming state.
+ FallThrough();
+
+ }
+
+// ---------------------------------------------------------
+// CMmsReceiveMessage::DoComplete
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::DoComplete(TInt& aError )
+ {
+
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("Receivemsg DoComplete"));
+#endif
+ // We should get here if we are cancelled, or if
+ // the cycle has completed (with or without error)
+ // Make sure the store is released
+ iDecoder->RelaseDataSink();
+
+ // If we have an error, we must delete the entry
+ // under construction.
+ // If we have successfully created the entry, we have set
+ // iEntryUnderConstruction to KMsvNullIndexEntryId.
+ // If iEntryUnderConstruction still points to an entry, it means
+ // that the cycle has been aborted, and the incomplete entry
+ // must be deleted.
+ if ( iEntryUnderConstruction != KMsvNullIndexEntryId )
+ {
+ if ( iServerEntry->SetEntry( KMsvGlobalInBoxIndexEntryId ) == KErrNone )
+ {
+ iServerEntry->DeleteEntry ( iEntryUnderConstruction );
+ }
+ iEntryUnderConstruction = KMsvNullIndexEntryId;
+ }
+
+ // Set error to entries that are still left
+ // If some of the entries already have an error set,
+ // it is not overridden.
+ UnSetSendMask( *iFailed, aError );
+
+ // If we are supporting MMBox, we must also clear the duplicates
+ // if we have notifications in bad list
+
+ if ( iMmsSettings->MMBoxFolder() != KMsvNullIndexEntryId )
+ {
+ TInt i = 0;
+#ifndef _NO_MMSS_LOGGING_
+ if ( iBad->Count() > 0 )
+ {
+ TMmsLogger::Log( _L("- %d notifications on bad list "), iBad->Count() );
+ }
+#endif
+
+ for ( i = 0; i < iBad->Count(); i++ )
+ {
+ if ( iServerEntry->SetEntry( iBad->At( i )) == KErrNone )
+ {
+ // we don't want to leave here, we do our best
+ TRAP_IGNORE( ClearDuplicateEntryOperationL() );
+ }
+ }
+ }
+ }
+
+// start of ROAMING CHECK handling
+// ---------------------------------------------------------
+// CMmsReceiveMessage::RoamingCheck
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::RoamingCheck()
+ {
+
+ TInt error = KErrNone;
+
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("Receivemsg roaming check start"));
+#endif
+
+ if ( !iMmsSettings->LocalMode() && !iMmsSettings->FetchOverride() &&
+ ( ( iMmsSettings->ReceivingModeHome() != iMmsSettings->ReceivingModeForeign() ) ||
+ ( iMmsSettings->ReceivingModeForeign() == EMmsReceivingManual ) ||
+ ( iMmsSettings->ReceivingModeForeign() == EMmsReceivingPostpone ) ) )
+ {
+ // In offline mode we cannot ask if we are roaming - just give up
+ if ( !NetworkOperationsAllowed() )
+ {
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("- Offline mode - cannot check network status"));
+#endif
+ error = KMmsErrorOfflineMode;
+ iError = error;
+ }
+ else
+ {
+ // if we get an error we have not been able to connect to phone module
+ // and we cannot ask if we are roaming
+ TRAP( error, iPhone = CMmsPhoneClient::NewL() )
+ }
+
+ if ( error == KErrNone )
+ {
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("- Receivemsg getting network status"));
+#endif
+ iPhone->Roaming( iStatus );
+ }
+ }
+ else
+ {
+ // no roaming check needed
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("- Roaming check not needed"));
+#endif
+ TRequestStatus* status = &iStatus;
+ iStatus = KRequestPending;
+ // 0 = home network. If we don't care, we behave as at home
+ User::RequestComplete( status, 0 );
+ }
+
+ if ( error != KErrNone )
+ {
+ // we got an error - iPhone is not going to complete us
+ TRequestStatus* status = &iStatus;
+ iStatus = KRequestPending;
+ User::RequestComplete( status, error );
+ }
+ SetActive();
+
+ }
+
+// ---------------------------------------------------------
+// CMmsReceiveMessage::GetRoamingState
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::GetRoamingState()
+ {
+
+ // if current receiving modes are valid, we have to set the message fetch state
+ // according to the receiving mode of the current (home or foreign ) network
+
+ // Set the message fetch state according to current network value
+ if( iRegistrationStatus != 0 )
+ {
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("roaming") );
+#endif
+ iReceivingMode = iMmsSettings->ReceivingModeForeign();
+ }
+ else
+ {
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("in home network") );
+#endif
+ iReceivingMode = iMmsSettings->ReceivingModeHome();
+ }
+
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("- message receiving mode is %d"), iReceivingMode );
+#endif
+
+ // if something is wrong, entries are marked failed.
+ if ( iError != KErrNone )
+ {
+ // Set error to all entries
+ // If some of the entries already have an error set,
+ // it is not overridden.
+ UnSetSendMask( *iFailed, iError );
+
+ }
+ // if we have something in iError, we shall not continue
+ // to open IAP, and RunL will complete.
+ // All entries will be rescheduled
+
+ }
+// end of ROAMING CHECK handling
+
+// ---------------------------------------------------------
+// CMmsReceiveMessage::DecodeResponseL
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::DecodeResponseL()
+ {
+ FallThrough();
+ return;
+ }
+
+// ---------------------------------------------------------
+// CMmsReceiveMessage::ConnectToIapL
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::ConnectToIAPL()
+ {
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("Receivemsg open IAP") );
+#endif
+ if ( !iMmsSettings->LocalMode() )
+ {
+ iError = iMmsSettings->ValidateSettings();
+ }
+ CMmsBaseOperation::ConnectToIAPL();
+ }
+
+// ---------------------------------------------------------
+// CMmsReceiveMessage::InitializeSessionL
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::InitializeSessionL()
+ {
+
+ // Here we should connect to MMSC
+
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("Receivemsg Connecting") );
+#endif
+
+ // for testing purposes our messages are in files in the folder
+ // defined in iMmsSettings->iRootFolder.
+ if ( iMmsSettings->LocalMode() )
+ {
+ HBufC* filename = HBufC::NewL( iMmsSettings->LocalModeIn().Length() );
+ CleanupStack::PushL( filename );
+ TPtr fileNamePtr = filename->Des();
+ fileNamePtr.Copy( iMmsSettings->LocalModeIn() );
+ iFs.SetSessionPath( fileNamePtr );
+ CleanupStack::PopAndDestroy( filename );
+ }
+
+ CMmsBaseOperation::InitializeSessionL();
+
+ }
+
+// ---------------------------------------------------------
+// CMmsReceiveMessage::SubmitTransactionL
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::SubmitTransactionL()
+ {
+
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("Receivemsg Receiving") );
+#endif
+ iEntryUnderConstruction = KMsvNullIndexEntryId;
+ iResponse->Reset(); // Reset sets the correct version
+ iAlreadyDeferred = EFalse;
+ iMmsHeaders->Reset();
+ iEncodeBuffer->Reset();
+
+ // We don't totally give up in case of an error.
+ // We may have a long list of entries to handle.
+ // One entry may be garbage while others will be ok.
+
+ // Call to IsConnected() clears error for a new entry or
+ // sets the error if we are not connected. If we are not
+ // connected, we must terminate the state machine loop
+ if ( !IsConnected() )
+ {
+ return;
+ }
+
+ TMsvEntry entry;
+
+ // Load the notification. If an error occurs, we cannot continue
+ // with this notification.
+ if ( !LoadNotificationL( entry ) )
+ {
+ // LoadNotificationL sets the state machine active if we can continue
+ // to next entry.
+ // If the situation is hopeless, the state machine is not active, and
+ // the loop terminates
+ return;
+ }
+
+
+ TInt size = iNotification->MessageSize();
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("- message size %d"), size);
+#endif
+ // If the size in notification is bigger than the maximum size we can receive
+ // use the maximum size instead for the memory checks (we are not receiving
+ // more than that anyway)
+ if ( size > iMmsSettings->MaximumReceiveSize() )
+ {
+ // reduce the size to maximum allowed
+ size = iMmsSettings->MaximumReceiveSize();
+ }
+
+ // Now we must check if the message should be rejected or deferred
+ // The function IsNotificationInsaneL() checks if the notification
+ // has incorrect message type or incorrect major version number.
+ // If the message is unrecognized, the response will be "unrecognized"
+ // The function sets the status, and later the response will be sent
+ // but there is no need to check for expiration or disk space in
+ // case the message will be rejected anyway.
+
+ if ( !IsNotificationInsaneL() )
+ {
+ // Check if message has expired.
+ // If it has, and we are in automatic mode, there is no need
+ // to send a response.
+ if ( !CheckExpirationL() )
+ {
+ return;
+ }
+
+ // Check disk space.
+ // we must add the safety margin here...
+ size += KMmsDiskSafetyMargin;
+
+ // Query about disk space.
+ if ( TMmsGenUtils::DiskSpaceBelowCriticalLevelL(
+ &iFs, size, iMessageDrive ) )
+ {
+ iNotification->SetStatus( KMmsMessageStatusDeferred );
+ iError = KErrDiskFull;
+ }
+ }
+
+ // if we have got an error for this message (KErrNoMemory or
+ // KErrDiskFull) we must store the information in the notification
+ // entry to discern these situations from cases where there
+ // is something wrong with the actual transaction.
+ if ( iError != KErrNone )
+ {
+ TInt error = iServerEntry->SetEntry( iSelection->At( iCurrentMessageNo - 1 ) );
+ // If we cannot update our entry - that's too bad
+ if ( error == KErrNone )
+ {
+ TMsvEntry tEntry;
+ tEntry = iServerEntry->Entry();
+ tEntry.iError = iError;
+ iServerEntry->ChangeEntry( tEntry );
+ }
+ // we clear the error now. The rest of the branching
+ // is not based on iError but on the notification status
+ iError = KErrNone;
+ // Release the entry
+ iServerEntry->SetEntry( KMsvNullIndexEntryId );
+ }
+
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("- notification status %d"), iNotification->Status() );
+ switch ( iNotification->Status() )
+ {
+ case KMmsMessageStatusRejected:
+ TMmsLogger::Log( _L("- rejected") );
+ break;
+ case KMmsMessageStatusDeferred:
+ TMmsLogger::Log( _L("- deferred") );
+ break;
+ case KMmsMessageStatusRetrieved:
+ TMmsLogger::Log( _L("- retrieved") );
+ break;
+ case KMmsMessageStatusUnrecognized:
+ TMmsLogger::Log( _L("- unrecognized") );
+ break;
+ default :
+ TMmsLogger::Log( _L("- whatever") );
+ break;
+ }
+#endif
+
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("- receiving mode: %d"), iReceivingMode );
+#endif
+
+ // Sending the response tells the MMSC that the
+ // notification has been received and understood.
+ // If we do not want to fetch the message the
+ // WantToFetchThisL() subroutine will change the state
+ // so that after return the response will be sent to MMSC
+
+ if ( !WantToFetchThisL( entry ) )
+ {
+ return;
+ }
+
+ // Now it seems that we are supposed to fetch something
+ // The notification has cleared all our tests and fetching is on
+
+ // Now we should start a GET transaction with the
+ // URI we obtain from the headers
+
+ // If we fail to get anything because the message has expired,
+ // we set iEntryUnderConstruction to KMsvNullIndexEntryId
+ // Otherwise we must reschedule the receive
+
+ // At this point we will invoke the transaction that sends
+ // our get request to MMSC and when the transaction completes,
+ // the data has been stored in our encode buffer, if the status
+ // is KErrNone. Otherwise the completion status will contain the
+ // error code.
+
+ if ( iMmsSettings->LocalMode() )
+ {
+ LocalModeFetchL();
+ // if only local mode, we complete ourselves
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("- local mode, completing fetch with status %d"), iError );
+#endif
+ if ( !IsActive() )
+ {
+ // If Local mode fetch fails it already calls ChangeStateL() and becomes active
+ // we cannot set us active a second time
+ FallThrough();
+ }
+ }
+ else // global mode
+ {
+ // Chunked mode in global mode, too
+ // chunked mode is turned on here - other changes are generic
+ DoCreateEntryL();
+ iDecoder->InitializeChunkedMode( *iEntryWrapper, *iMmsHeaders, *iEncodeBuffer );
+ // end of chunked preparation
+
+ // we get this far only if we are connected
+ HBufC* uri = HBufC::NewL( iNotification->ContentLocation().Length() + KMMSBufferExtra );
+ CleanupStack::PushL( uri );
+ uri->Des().Copy( iNotification->ContentLocation() );
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("...Fetching from URI: %S"), uri );
+#endif
+ iMmsSession->FetchMessageL(
+ *uri,
+ *iEncodeBuffer,
+// Use this buffer size when in chunked mode
+ KMmsChunkedBufferSize, // tell that only this buffer size is needed
+ *iEncoder,
+ *iDecoder,
+ iStatus );
+ CleanupStack::PopAndDestroy( uri );
+ SetActive();
+ }
+
+ }
+
+// ---------------------------------------------------------
+//
+// ---------------------------------------------------------
+TBool CMmsReceiveMessage::IsConnected()
+ {
+ if ( iConnected )
+ {
+ // We clear the error at this point to tell that this message
+ // is all right so far. Notifications for failed messages
+ // remain in the selection, and they are rescheduled later
+ // The error is saved in the schedule data for the notification.
+ iError = KErrNone;
+ }
+ else
+ {
+ // We are in a totally hopeless mess.
+ // We don't have a connection. iError should contain the reason
+ // all we can do is give up
+ // If we return from RunL without becoming active again
+ // RunL completes.
+ // That's all we can do here...
+ // The selection arrays have information about
+ // which messages have succeeded and which not.
+
+ // DoComplete sets an error code to those entries in the
+ // failed list that do not already have their error set.
+ // If we don't know what went wrong, we just say "disconnected"
+ if ( iError == KErrNone )
+ {
+ iError = KErrDisconnected;
+ }
+ }
+ return iConnected;
+ }
+
+// ---------------------------------------------------------
+//
+// ---------------------------------------------------------
+//
+TBool CMmsReceiveMessage::LoadNotificationL( TMsvEntry& aEntry )
+ {
+ // set entry to next notification in list
+ iError = iServerEntry->SetEntry( iSelection->At( iCurrentMessageNo - 1 ) );
+ if ( iError != KErrNone )
+ {
+ // The code called by SkipEntryL will make us active again
+ // We may now try the next entry.
+ SkipEntryL();
+ return EFalse;
+ }
+
+ aEntry = iServerEntry->Entry();
+ if ( aEntry.iMtmData2 & KMmsNotifyResponseSent )
+ {
+ iAlreadyDeferred = ETrue;
+ }
+
+ CMsvStore* store = NULL;
+
+ TRAP (iError, {store = iServerEntry->ReadStoreL();});
+ // We have managed to generate some mysterious notifications
+ // where the ReadStoreL fails.
+ // These must be deleted, as they are garbage.
+ // I assume they are used by someone else.
+ // This means we just delete them from our list and forget them
+ // If we cannot get a read store, we cannot do anything with the
+ // schedule either.
+ if ( iError == KErrNoMemory )
+ {
+ // Out of memory - hopeless.
+ // We return without becoming active again and the
+ // whole loop completes.
+ // We should try to disconnect, but if there is a serious
+ // memory problem I doubt that anything will work.
+
+ // Release the entry
+ iServerEntry->SetEntry( KMsvNullIndexEntryId );
+ return EFalse;
+ }
+
+ if ( iError != KErrNone )
+ {
+ // don't discard the entry completely now
+ delete store;
+ store = NULL;
+ // The code called by SkipEntryL will make us active again
+ SkipEntryL();
+ return EFalse;
+ }
+
+ // We have access to the notification
+ CleanupStack::PushL( store );
+ iNotification->RestoreL( *store );
+ CleanupStack::PopAndDestroy( store );
+
+ // We must clear deferred status always:
+ // If we did not have enough memory the first time,
+ // the message was deferred. If we now have enough
+ // memory the old status must be cleared
+
+ iNotification->SetResponseStatus( 0 ); // clear possible old status
+ iNotification->SetResponseTextL( TPtrC() ); // clear possible old text
+
+ if ( iNotification->Status() == KMmsMessageStatusDeferred )
+ {
+ iNotification->SetStatus( 0 );
+ }
+
+ // We must check if message fetching is deferred or totally off.
+ // if iReceivingMode == EMmsReceivingReject, notification has been deleted already.
+ if ( !iMmsSettings->FetchOverride() &&
+ iNotification->Status() == 0 &&
+ ( iReceivingMode == EMmsReceivingManual || iReceivingMode == EMmsReceivingPostpone ) )
+ {
+ iNotification->SetStatus( KMmsMessageStatusDeferred );
+ }
+
+ // We get this far only if we are connected
+ aEntry.SetConnected( ETrue );
+ aEntry.SetSendingState( KMsvSendStateSending );
+ aEntry.iError = KErrNone; // optimistic...
+ iServerEntry->ChangeEntry( aEntry );
+
+ // Release the entry
+ iServerEntry->SetEntry( KMsvNullIndexEntryId );
+
+ // Continue with this notification
+ return ETrue;
+ }
+
+// ---------------------------------------------------------
+//
+// ---------------------------------------------------------
+//
+TBool CMmsReceiveMessage::CheckExpirationL()
+ {
+
+ // If the message has expired, it can be rejected without further ado
+ // We allow a little slack here, if it expired just a few seconds ago,
+ // we still have hope...
+ // use universal time in case user changes location
+ TTime now;
+ TMsvEntry entry;
+ TBool canContinue = ETrue; // optimistic
+
+ now.UniversalTime();
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("MMS terminal universal datetime: ") );
+ CMmsBaseOperation::LogDateL( now );
+ TMmsLogger::Log( _L("MMS message expiry datetime:") );
+ CMmsBaseOperation::LogNetworkFormatDateL( iNotification->ExpiryDate() );
+#endif
+ if ( ( ( iNotification->ExpiryDate() + iMmsSettings->ExpiryOvershoot() ) * KMmsMillion ) <
+ now.MicroSecondsFrom( TTime( KMmsYear1970String ) ).Int64() )
+ {
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("message has expired by %d seconds"),
+ ( now.MicroSecondsFrom( TTime( KMmsYear1970String ) ).Int64())/KMmsMillion -
+ iNotification->ExpiryDate() - iMmsSettings->ExpiryOvershoot() );
+#endif
+ // If the notification is in inbox or in MMBox folder, fetch will continue.
+ if( entry.Parent() == KMsvGlobalInBoxIndexEntryId ||
+ entry.Parent() == iMmsSettings->MMBoxFolder() )
+ {
+ // Mark the notification expired
+ iError = iServerEntry->SetEntry( iSelection->At( iCurrentMessageNo - 1 ) );
+ if ( iError == KErrNone )
+ {
+ entry = iServerEntry->Entry();
+ entry.iMtmData2 |= KMmsMessageExpired;
+ iServerEntry->ChangeEntry( entry );
+ }
+ // Release the entry
+ iServerEntry->SetEntry( KMsvNullIndexEntryId );
+
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("Expired notification. Fetch continues") );
+#endif
+ }
+ else
+ {
+ // iError == KErrNone, the last stage will just remove our entry from the list
+ // There is no need to send any reply to an expired message.
+ // The MMSC will not be interested in getting a "reject"
+ // response to an expired message.
+ iResponse->SetStatus( KMmsMessageStatusRejected );
+ iBad->AppendL( iSelection->At( iCurrentMessageNo - 1 ) );
+ // return to the beginning of the state machine loop
+ iState = EMmsOperationUpdatingEntryStatus;
+ // The code called by ChangeStateL will make us active again
+ ChangeStateL();
+ canContinue = EFalse; // loop to next state
+ }
+ }
+ return canContinue; // can continue
+ }
+
+// ---------------------------------------------------------
+//
+// ---------------------------------------------------------
+//
+TBool CMmsReceiveMessage::IsNotificationInsaneL()
+ {
+ TBool isInsane = EFalse; // optimistic
+ // If the message is unrecognized, the response will be "unrecognized"
+ // Either the message type is unknown, or the major version number differs
+ if ( ( iNotification->MmsVersion() & KMmsMajorVersionMask ) !=
+ ( iMmsSettings->MmsVersion() & KMmsMajorVersionMask ) )
+ {
+ // major versions differ, send back 1.0 version response
+ iResponse->SetMmsVersion( KMmsVersion1 );
+ iNotification->SetStatus( KMmsMessageStatusUnrecognized );
+ iBad->AppendL( iSelection->At( iCurrentMessageNo - 1 ) );
+ isInsane = ETrue;
+ }
+ else if ( iNotification->MessageType() != KMmsMessageTypeMNotificationInd &&
+ iNotification->MessageType() != KMmsMessageTypeMBoxDescr )
+ {
+ // We have been pushed something we cannot handle.
+ // delivery reports have been picked out earlier, so they cause
+ // no problems here.
+ iNotification->SetStatus( KMmsMessageStatusUnrecognized );
+ iBad->AppendL( iSelection->At( iCurrentMessageNo - 1 ) );
+ isInsane = ETrue;
+ }
+ return isInsane;
+ }
+
+// ---------------------------------------------------------
+//
+// ---------------------------------------------------------
+//
+TBool CMmsReceiveMessage::WantToFetchThisL( TMsvEntry& aEntry )
+ {
+ if ( ( iReceivingMode != EMmsReceivingAutomatic && !iMmsSettings->FetchOverride() ) ||
+ iNotification->Status() == KMmsMessageStatusRejected ||
+ iNotification->Status() == KMmsMessageStatusDeferred ||
+ iNotification->Status() == KMmsMessageStatusRetrieved ||
+ iNotification->Status() == KMmsMessageStatusUnrecognized )
+ {
+ // We don't want this message for one reason or another
+ // We shall send reject message or deferred message and
+ // remove this notification from the scheduling.
+ // If the fetching is deferred, the notification should remain
+ // in the machine waiting for better times.
+ // If the message is rejected, the notification is deleted.
+ // In both cases the schedule must be removed. A deferred
+ // notification is not rescheduled before the message fetching
+ // is turned on again.
+
+ // If the whole message is in the extended notification,
+ // the status is "retrieved"
+
+ // However, if the "deferred" response has already been sent,
+ // we should not send it again
+
+ iResponse->SetStatus( iNotification->Status() );
+
+ if ( iResponse->Status() != KMmsMessageStatusRejected &&
+ iResponse->Status() != KMmsMessageStatusDeferred &&
+ iResponse->Status() != KMmsMessageStatusRetrieved &&
+ iResponse->Status() != KMmsMessageStatusUnrecognized )
+ {
+ // We have an unlucky message. The notification arrived
+ // while we were supposed to fetch it, but before it was
+ // actually fetched, receiving was turned off.
+ // We try to defer it hoping it can be fetched before it
+ // expires.
+ // A message should be scheduled for fetching only a few
+ // seconds after the notification arrives, so that if the
+ // user manages to turn the fetching off before we fetch
+ // the message we can assume that he does not want this one either
+ // (at least not now). We are a bit conservative, though,
+ // we don't reject this one as it was supposed to be fetched
+ // before it fell into the time trap.
+ iResponse->SetStatus( KMmsMessageStatusDeferred );
+ }
+
+ if ( aEntry.iMtmData2 & KMmsNotifyResponseSent )
+ {
+ // if the notify response has already been sent for this message,
+ // we don't send it again.
+ // When the message fetch state is switched back on,
+ // server Mtm must check the pending notifications and
+ // reschedule them for fetching.
+ // An already deferred notification should not be in our
+ // list, but I'm paranoid and check in case some notification
+ // has fallen into a time trap.
+ iAlreadyDeferred = ETrue;
+ iState = EMmsOperationStoringResponseData;
+ }
+ else
+ {
+ // The function called by ChangeStateL will make us active again
+ iState = EMmsOperationStoringResponseData;
+ }
+ // We are not fetching this message.
+ // Either we send a response to MMSC or we just move to next notification.
+ ChangeStateL();
+ return EFalse;
+ }
+ return ETrue;
+ }
+
+// ---------------------------------------------------------
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::DoCreateEntryL()
+ {
+
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("Receivemsg DoCreateEntryL") );
+#endif
+
+ // We create a message entry into the inbox
+ // it is invisible and in preparation until
+ // we decide that we have successfully fetched the message
+ // The entry must exist before the message is fetched, because
+ // decode puts data into an existing entry, and
+ // creates children to the entry for attachments.
+
+ // If we have failed in storing data to the entry, it may be non-zero
+ // We try to delete it before creating a new one
+
+ if ( iEntryUnderConstruction != KMsvNullIndexEntryId )
+ {
+ if ( iServerEntry->SetEntry( KMsvGlobalInBoxIndexEntryId ) == KErrNone )
+ {
+ iServerEntry->DeleteEntry ( iEntryUnderConstruction );
+ }
+ iEntryUnderConstruction = KMsvNullIndexEntryId;
+ }
+
+ // If the creation of the entry is successful, we
+ // set our entry to point to the newly created entry
+ // to get data content to it.
+ if ( iError == KErrNone )
+ {
+ TMsvId targetId = KMsvGlobalInBoxIndexEntryId;
+
+ TMsvEntry tEntry;
+
+ // set all relevant flags in tMsvEntry
+ tEntry.iType = KUidMsvMessageEntry;
+ tEntry.iMtm = KUidMsgTypeMultimedia;
+ tEntry.iServiceId = iService;
+ tEntry.SetUnread( ETrue );
+ tEntry.SetNew( ETrue );
+ tEntry.SetVisible( EFalse );
+ tEntry.SetComplete( EFalse );
+ tEntry.SetInPreparation( ETrue );
+ tEntry.SetReadOnly( EFalse );
+
+ // Query about disk space.
+ if ( TMmsGenUtils::DiskSpaceBelowCriticalLevelL(
+ &iFs, KMmsIndexEntryExtra, iMessageDrive ) )
+ {
+ // we use standard error code here
+ iError = KErrDiskFull;
+ }
+ if ( iError == KErrNone )
+ {
+ iError = iServerEntry->SetEntry( targetId );
+ }
+
+ if ( iError == KErrNone )
+ {
+ iError = iServerEntry->CreateEntry( tEntry );
+ }
+ iEntryUnderConstruction = tEntry.Id();
+ if ( iError == KErrNone )
+ {
+ iError = iEntryWrapper->SetCurrentEntry( iEntryUnderConstruction );
+ }
+ }
+ }
+
+// ---------------------------------------------------------
+// CMmsReceiveMessage::StoreResponseL
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::StoreResponseL()
+ {
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("Receivemsg Store Response") );
+#endif
+ TInt error;
+ TInt fatal = EFalse; // fatal error, no use to retry
+
+ // If we have got this far, we don't return to CreateEntry anymore
+ // even if we encounter backup/restore problems later.
+
+ if ( iError == KErrNone )
+ {
+ // if we have no error, me must retry to make the entry visible
+ iCriticalState = EMmsOperationStoringResponseData;
+ }
+ else
+ {
+ iCriticalState = EMmsOperationSendingAck;
+ }
+
+ // At the moment we should not receive any extra message types,
+ // so that the only error of this type would
+ // be wrong type of message either from WAP stack or from MMSC.
+ // Send request is all right in local mode, as we get back
+ // the messages we send ourselves.
+ // We accept the send requests as retrieve confirmations,
+ // as they are importand during testing phase:
+ // We can put any message someone has sent into the folder
+ // representing the simulated MMSC and try to fetch it as
+ // if it were a real message.
+ // We can't check the message type if we have encountered an error.
+ // In that case the headers may not have been correctly decoded
+ if ( iError == KErrNone &&
+ iResponse->Status() != KMmsMessageStatusRejected &&
+ iResponse->Status() != KMmsMessageStatusDeferred &&
+ iResponse->Status() != KMmsMessageStatusRetrieved &&
+ iMmsHeaders->MessageType() != KMmsMessageTypeMRetrieveConf &&
+ iMmsHeaders->MessageType() != KMmsMessageTypeMSendReq )
+ {
+ iResponse->SetStatus( KMmsMessageStatusUnrecognized );
+ iError = KMmsErrorStatusUnsupportedMessage;
+ }
+
+ // If we have managed to decode the response, it may contain a status
+ // that must be mapped to an error. The error may be permanent or temporary
+
+ if ( iError == KErrNone )
+ {
+ // we have got a response from MMSC, and decoded it, but in version 1.1
+ // or later the response may still contain an error code.
+ // if response text length was 0, it was deleted
+
+ // - if error is permanent, notification will be deleted.
+ // - if error is transient, response text is copied to notification
+ // and UI components may show it to the user if needed.
+
+ // iError is set to the correct value depending on response status
+ // "fatal" indicates if the error is permanent or temporary
+ fatal = MapErrorStatus( iMmsHeaders->ResponseStatus() );
+ }
+
+ // If we get a transient failure from MMSC, we store the possible text and status code
+ // into our notification. UI may show the text to the user in case there is something
+ // the user might do about the failure. Permament failures are stored in the message
+ // entry.
+ // The application id is also copied to the notification in case application id is present
+ // in the message but not in the notification.
+ // If the application has not been registered or memory runs out, the user may be
+ // informed that the notification refers to a message that belongs to an application.
+
+ CopyDataFromMessageToNotificationL();
+
+ // If there has been an error and logging is allowed, dump the buffer into a file
+ // to support error analysis later
+ DumpIfNeededL();
+
+ // We must try to finalize even if we have encountered an error.
+ // If the decode has failed, iError contains something like "KErrCorrupt".
+ // If the operation has been successful, we make the entry visible
+ // and remove the in preparation flag. The user should then be able
+ // to see the new message entry.
+
+ // free the memory we don't need anymore
+ if ( iEncodeBuffer )
+ {
+ iEncodeBuffer->Reset();
+ }
+ TMsvEntry tEntry;
+
+ // Check if the message is going to an unregistered application.
+ // If it is, it's going to be rejected
+ iRegistered = EFalse;
+
+ if ( iMmsHeaders->ApplicId().Length() > 0 )
+ {
+ iRegistered = RegisteredL( iMmsHeaders->ApplicId() );
+ if ( !iRegistered )
+ {
+ // not registered - reject it
+ iResponse->SetStatus( KMmsMessageStatusRejected );
+ // we clear whatever error we may have because we are
+ // going to reject the message anyway.
+ iError = KErrNone;
+ }
+ }
+
+ // If the message is going to an application we must check if we can free disk
+ // space by deleting older messages addressed to the same application.
+
+ if ( iError == KErrDiskFull && iRegistered )
+ {
+ // Check if we can free disk space and reschedule the fetch.
+ // In manual mode the fetch will not be rescheduled.
+ // If we can free memory we will change the error code to KMmsErrorApplicationDiskFull
+ // If we cannot free memory, the error code is left as is and the user must
+ // delete something else in order to be able to receive the message.
+ DeleteApplicationMessagesL();
+ }
+
+ // If we have tried to fetch a message, and got
+ // EMRUExceeded, we'll reject the message. If it
+ // was already deferred, no new response is sent.
+ // The notification will be deleted, it is hopeless.
+
+ if ( iError == KMmsErrorEMRUExceeded )
+ {
+ iResponse->SetStatus( KMmsMessageStatusRejected );
+ iFailed->Delete( iCurrentMessageNo - 1 );
+ iBad->AppendL( iSelection->At( iCurrentMessageNo - 1 ) );
+ }
+
+ if ( iError != KErrNone ||
+ iResponse->Status() == KMmsMessageStatusRejected ||
+ iResponse->Status() == KMmsMessageStatusDeferred ||
+ iResponse->Status() == KMmsMessageStatusRetrieved ||
+ iResponse->Status() == KMmsMessageStatusUnrecognized )
+ {
+ // If the failure was fatal (permanent error from MMSC)
+ // we don't send any response back. If the failure was
+ // not fatal, we send "deferred" hoping we can retry later
+ if ( fatal )
+ {
+ // The notification is deleted, as we have got an MMS message.
+ iFailed->Delete( iCurrentMessageNo - 1 );
+ iBad->AppendL( iSelection->At( iCurrentMessageNo - 1 ) );
+ // we don't send back a response if failing was fatal.
+ iResponse->Reset();
+ }
+ else if ( iError == KMmsErrorHTTPConfiguration ||
+ iError == KMmsErrorHTTPNotFound ||
+ iError == KMmsErrorHTTPServerDown ||
+ iError == KMmsErrorHTTPClientError )
+ {
+ // if we have got a HTTP error, there is no sense to send ack back
+ iResponse->Reset();
+ }
+ else if ( !iAlreadyDeferred &&
+ iResponse->Status() != KMmsMessageStatusRejected &&
+ iResponse->Status() != KMmsMessageStatusRetrieved &&
+ iResponse->Status() != KMmsMessageStatusUnrecognized)
+ {
+ iResponse->SetStatus( KMmsMessageStatusDeferred );
+ EncodeNotifyResponseL();
+ }
+ else if ( iResponse->Status() == KMmsMessageStatusUnrecognized ||
+ iResponse->Status() == KMmsMessageStatusRejected)
+ {
+ EncodeNotifyResponseL();
+ }
+ else if ( iResponse->Status() == KMmsMessageStatusRetrieved )
+ {
+ EncodeNotifyResponseL();
+ iFailed->Delete( iCurrentMessageNo - 1 );
+ iSuccessful->AppendL( iSelection->At( iCurrentMessageNo - 1 ) );
+ }
+ else
+ {
+ // We have nothing to send, we hope we can try
+ // again later.
+ iResponse->Reset();
+ }
+ }
+
+#ifndef _NO_MMSS_LOGGING_
+ // log the response status we are about to send
+ TMmsLogger::Log( _L("- Response status to be: %d"), iResponse->Status() );
+#endif
+
+ // If we have no entry, the fetching has failed. If the failing was fatal,
+ // the notification has been appended to the iBad list.
+ // It will be deleted from the iFailed list later.
+ // Those entries that end in the iBad list are just
+ // deleted, not rescheduled.
+
+ TInt applicationMessageStatus = 0;
+
+ // If we got an error, we delete the entry under construction.
+ // But if the error is "fatal" it means MMSC returned some error message,
+ // and the error message entry must be kept and shown to the user
+ // The corresponding notification remains in the failed list
+ // in order to be rescheduled.
+ // If the notification was bad, the corresponding notification
+ // has already been appended to bad list to be removed from
+ // task scheduler.
+ if ( iEntryUnderConstruction != KMsvNullIndexEntryId && iError != KErrNone && !fatal )
+ {
+ if ( iMmsSettings->LocalMode() )
+ {
+ CloseLocalFileL( EFalse );
+ }
+ // if setting server entry to inbox fails, deletion of entry will fail,
+ // but there is nothing we can do about it.
+ iServerEntry->SetEntry( KMsvGlobalInBoxIndexEntryId );
+ iServerEntry->DeleteEntry ( iEntryUnderConstruction );
+ iEntryUnderConstruction = KMsvNullIndexEntryId;
+ }
+
+ if ( iEntryUnderConstruction != KMsvNullIndexEntryId )
+ {
+ // We don't care if this leaves. We just do our best.
+ // If this function fails, our message will have some extra parts
+ TRAP( error, HandleMultipartAlternativeL() );
+ }
+
+ // If we have an entry we have either successfully fetched a message
+ // or received an error message about a fatal (permanent) error from MMSC
+ // The entry must now be made visible to the user.
+ if ( iEntryUnderConstruction != KMsvNullIndexEntryId )
+ {
+ error = iServerEntry->SetEntry( iEntryUnderConstruction );
+
+ if ( error == KErrNone )
+ {
+ // we don't check disk space here, as this
+ // is local mode only: We just save the message id
+ // for testing purposes. The message id is about 5 bytes
+ // And we clear possible TID, that makes message shorter than before.
+ CMsvStore* store = NULL;
+ TRAP ( error, store = iServerEntry->EditStoreL() )
+ if ( store )
+ {
+ CleanupStack::PushL( store );
+ }
+ if ( iMmsSettings->LocalMode() &&
+ iMmsHeaders->MessageId().Length() == 0 )
+ {
+ iMmsHeaders->SetMessageIdL(
+ iNotification->ContentLocation().Mid(
+ iMmsSettings->LocalModeIn().Length() ) );
+ }
+ if ( iAlreadyDeferred )
+ {
+ // we need to save the TID from the message to the response
+ iResponse->SetTidL( iMmsHeaders->Tid() );
+ }
+ // clear TID from the message to prevent the same TID from being used later
+ // in case the message is copied around.
+ iMmsHeaders->SetTidL( TPtrC8() );
+ // Data is copied in case the message does not contain sender or subject
+ // Data is copied only if disk space is not below critical level
+ CopyDataFromNotificationToMessageL();
+ if ( store )
+ {
+ TRAP ( error,
+ {
+ iMmsHeaders->StoreL(*store);
+ store->CommitL();
+ });
+ // If we managed to create the store without leaving, it is on cleanup stack
+ CleanupStack::PopAndDestroy( store );
+ store = NULL;
+ }
+ if ( iAlreadyDeferred )
+ {
+ // restore the TID
+ iMmsHeaders->SetTidL( iResponse->Tid() );
+ }
+
+ tEntry = iServerEntry->Entry();
+
+ // If message contains application id, check,
+ // if a folder, the name of which is application id is found
+ // and move the message to this folder.
+ // If the application is not registered, the message is deleted
+ applicationMessageStatus = MoveToApplicationFolderIfNeededL( tEntry );
+
+ if ( applicationMessageStatus != KMmsMessageForUnregisteredApplication )
+ {
+ // reload the entry in case the message was moved
+ tEntry = iServerEntry->Entry();
+
+ SetIndexEntryBitsForReceivedMessage( tEntry );
+
+ // if we cannot make our entry visible because of backup/restore, we must retry.
+ error = iServerEntry->ChangeEntry( tEntry );
+
+ // This is the critical point.
+ // We must return before iEntryUnderConstruction is set to KMsvNullIndexEntryId
+ // and the notification list is edited
+
+ if ( error <= (TInt) KMsvMediaUnavailable &&
+ error >= (TInt) KMsvIndexRestore &&
+ !iDoNotWaitForBackupEnd )
+ {
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("- must wait for backup end ") );
+#endif
+ iState = EMmsOperationWaitingForBackupEnd;
+ // This will take us back to RunL
+ WaitForBackupEnd();
+ return;
+ }
+ }
+
+ if ( iMmsSettings->LocalMode() )
+ {
+ CloseLocalFileL( ETrue );
+ }
+
+ // done with this entry
+ iEntryUnderConstruction = KMsvNullIndexEntryId;
+ }
+
+ // The task manager seems to handle deletion of entries
+ // gracefully nowadays. We can just delete handled entries
+ // We delete the notification as soon as possible
+ // as we don't want it hanging around after the message
+ // has been successfully fetched
+
+ if ( !fatal )
+ {
+ // Check duplicate before deleting notification entry
+ if ( iNotificationParent == KMsvGlobalInBoxIndexEntryIdValue ||
+ ( iNotificationParent == iMmsSettings->MMBoxFolder() ))
+ {
+ // For the time being Java wants these notifications to be deleted
+ // and applicationMessageStatus is always 0.
+ // This may change for other type of applications.
+ ClearOperationL( applicationMessageStatus );
+ }
+ else
+ {
+ // If the notification is not visible to the user,
+ // we don't need to save the application routing status.
+ // The rest of the handling can proceed normally -
+ // the notification will be deleted
+ applicationMessageStatus = 0;
+ }
+
+ // If the notification does not need to be left around to inform user,
+ // it can be deleted now
+ if ( applicationMessageStatus == 0 )
+ {
+ error = iServerEntry->SetEntry( iNotificationParent );
+ if ( error == KErrNone )
+ {
+ iServerEntry->DeleteEntry( iSelection->At( iCurrentMessageNo - 1 ) );
+ }
+ else
+ {
+ // we use this list as backup:
+ // if we cannot delete now, we try again later.
+ iSuccessful->AppendL( iSelection->At( iCurrentMessageNo - 1 ) );
+ }
+ }
+ // Even if the notification was left in the inbox,
+ // it is deleted from the failed list because it needs no more handling
+ iFailed->Delete( iCurrentMessageNo - 1 );
+
+ // All went well. We can acknowledge the delivery.
+ // If the MMSC is not interested in the acknowledgement,
+ // it has sent us no TID.
+ // If there is no TID, the response won't be sent.
+ // If Retrieve confirmation has not been sent, it must be
+ // sent instead of acknowledge indication
+
+ // We don't send an ack back if we have received a response
+ // from MMSC that indicates a fatal failure.
+ // Most likely the message was expired or has disappeared
+ // for some other reason (or did not exist in the first place)
+
+ iResponse->SetStatus( KMmsMessageStatusRetrieved );
+ if ( !iAlreadyDeferred )
+ {
+ EncodeNotifyResponseL();
+ }
+ else
+ {
+ EncodeAcknowledgeIndicationL();
+ }
+ }
+ }
+
+ if ( iFileOpen )
+ {
+ iFile.Close(); // just in case...
+ iFileOpen = EFalse;
+ }
+
+ // release entry in case we were holding the service entry
+ // We should not leave our entry pointing to the serive entry
+ // when we become active, others may want to use it.
+ iServerEntry->SetEntry( KMsvNullIndexEntryId );
+
+ iStatus = KRequestPending;
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ // We propagate the original error no matter what has happened here
+ User::RequestComplete( status, iError );
+
+ }
+
+// ---------------------------------------------------------
+// CMmsReceiveMessage::SendAckL
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::SendAckL()
+ {
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("Receivemsg Sending response to receive request") );
+#endif
+
+ // Send response to MMSC.
+ // response is in iResponse.
+ // If no reply should actually be sent, length of TID is 0.
+
+ // We may try to send response even if we have encountered an error.
+ // We try to send "deferred" if we couldn't fetch the message.
+ // We hope the MMSC will try to keep the message in that case.
+
+ // iResponse has Tid, if it contains something reasonable.
+
+ if ( iResponse->Tid().Length() > 0 )
+ {
+ if ( !iMmsSettings->LocalMode() )
+ {
+ // send the response
+ iMmsSession->SendMessageL(
+ iUri->Des(),
+ *iEncodeBuffer,
+ *iEncoder,
+ *iDecoder,
+ iStatus );
+ SetActive();
+ }
+ else
+ {
+ iStatus = KRequestPending;
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ // We propagate the original error no matter what has happened here
+ User::RequestComplete( status, iError );
+ }
+ }
+ else
+ {
+ // No response to send.
+ // Just continue to next state.
+ iStatus = KRequestPending;
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ // We propagate the original error no matter what has happened here
+ User::RequestComplete( status, iError );
+ }
+ }
+
+// ---------------------------------------------------------
+// CMmsReceiveMessage::UpdateEntryStatusL()
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::UpdateEntryStatusL()
+ {
+
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("Receivemsg Checking response success") );
+#endif
+
+ TInt error;
+ TMsvEntry tEntry;
+ TInt count = iBad->Count() - 1;
+
+ // update scheduling info for this notification
+ error = iServerEntry->SetEntry( iSelection->At( iCurrentMessageNo - 1 ) );
+ if ( error == KErrNone )
+ {
+ tEntry = iServerEntry->Entry();
+ error = tEntry.iError;
+ if ( error == KErrNone )
+ {
+ error = iError;
+ }
+ // In some rare cases accessing the store for the notification may fail
+ // in that case the schedule is not updated.
+ TRAP( error,
+ {
+ CMsvStore* store = iServerEntry->EditStoreL();
+ CleanupStack::PushL( store );
+ CMmsScheduledEntry* mmsScheduledEntry =
+ CMmsScheduledEntry::NewL( iServerEntry->Entry() );
+ CleanupStack::PushL( mmsScheduledEntry );
+ mmsScheduledEntry->RestoreL( *store );
+ UpdateRecipient( iError, *mmsScheduledEntry );
+ mmsScheduledEntry->StoreL( *store );
+ store->CommitL();
+ CleanupStack::PopAndDestroy( mmsScheduledEntry );
+ CleanupStack::PopAndDestroy( store );
+ });
+ }
+
+ // If the current notification has entered the "bad" list,
+ // it should not be rescheduled.
+ // For example, the message may be "deferred" because it is too
+ // big to ever fit in our phone. It must be deleted from the "failed"
+ // list, because it should not be rescheduled.
+
+ TInt count2 = iFailed->Count() - 1;
+ if ( count >= 0 &&
+ count2 >= ( iCurrentMessageNo - 1 ) &&
+ iBad->At( count ) == iFailed->At( iCurrentMessageNo - 1 ) )
+ {
+ // should not be rescheduled.
+ iFailed->Delete( iCurrentMessageNo - 1 );
+ }
+ else if ( iError == KErrNone )
+ {
+
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("Receivemsg all is well") );
+#endif
+ // All is well.
+ // If message was rejected the notification can be thrown away
+
+ if ( iResponse->Status() == KMmsMessageStatusRejected ||
+ iResponse->Status() == KMmsMessageStatusUnrecognized )
+ {
+ // The notifications in the received list will be deleted.
+ // If the message was rejected, the notification will be
+ // deleted.
+ error = iServerEntry->SetEntry( iNotificationParent );
+ if ( error == KErrNone )
+ {
+ iServerEntry->DeleteEntry( iSelection->At( iCurrentMessageNo - 1 ) );
+ }
+ else
+ {
+ // we use this list as backup:
+ // if we cannot delete now, we try again later.
+ iSuccessful->AppendL( iSelection->At( iCurrentMessageNo - 1 ) );
+ }
+ iFailed->Delete( iCurrentMessageNo - 1 );
+ }
+
+ if ( iResponse->Status() == KMmsMessageStatusDeferred )
+ {
+
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("Receivemsg responsestatus is deferred.") );
+#endif
+ // we have sent a "deferred" response.
+ // We should keep the notification, but not reschedule it.
+ // If we delete it from failed list, it wont get rescheduled.
+ // If we don't add it into received list, it will not be deleted.
+ // We must mark, that the "deferred" response was successfully sent
+ // so that we will not send it again later.
+
+ error = iServerEntry->SetEntry( iSelection->At( iCurrentMessageNo - 1 ) );
+ // If we cannot update our entry - that's too bad
+ // it just means that the response may be sent a second time...
+ // The system must not get mad about that.
+ // The system may be unreliable anyway, and some response may get lost.
+ // We just do our best.
+ if ( error == KErrNone )
+ {
+ iNotification->SetStatus( KMmsMessageStatusDeferred );
+ CMsvStore * store = iServerEntry->EditStoreL();
+ CleanupStack::PushL( store );
+ iNotification->StoreL( *store );
+ store->CommitL();
+ CleanupStack::PopAndDestroy( store );
+ tEntry = iServerEntry->Entry();
+ tEntry.iMtmData2 |= KMmsNotifyResponseSent;
+ tEntry.iMtmData2 &= ~KMmsDeferredButResponseNotSent;
+ tEntry.SetConnected( EFalse );
+ tEntry.SetFailed( EFalse );
+ tEntry.SetSendingState( KMsvSendStateUnknown );
+
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("Receivemsg notify response sent") );
+#endif
+
+ // change the iMtm type to notification
+ // and move the notification to the inbox
+ TBool moveToInbox = EFalse;
+
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("- message receiving mode %d"), iReceivingMode );
+#endif
+ if( iReceivingMode == EMmsReceivingManual && !iMmsSettings->FetchOverride() )
+ {
+ // Change the iMtm from KUidMsgTypeMultimedia to
+ // KUidMsgMMSNotification
+ tEntry.iMtm = KUidMsgMMSNotification;
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("marking as a notification") );
+#endif
+
+#ifndef _NO_MMSS_LOGGING_
+TMmsLogger::Log( _L("tentry.iMtm is %d"), tEntry.iMtm.iUid );
+#endif
+ tEntry.SetVisible( ETrue );
+ tEntry.SetComplete( ETrue );
+ tEntry.SetInPreparation( EFalse );
+ tEntry.SetReadOnly( ETrue );
+ // This is a notification, therefore there is no sending time available.
+ // We can only display the arrival time
+ tEntry.iDate.UniversalTime(); // this is arrival time
+
+ tEntry.iMtmData1 |= KMmsMessageMobileTerminated;
+
+ // Subject, sender and size are set in CMmsDecode.
+ // Notification cannot contain multiple recipients
+ // no need to check or set the multiple recipient bit
+
+ moveToInbox = ETrue;
+ }
+ iServerEntry->ChangeEntry( tEntry );
+
+
+ // if manual mode is on and the fetchoverride is not on.
+ // we have received a notification and sent a notifyresponse to the MMSC
+ // the notification should be moved to the inbox
+ if ( moveToInbox )
+ {
+
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("Receivemsg notification entry to Inbox") );
+#endif
+
+ if ( iServerEntry->SetEntry( tEntry.Parent() ) == KErrNone )
+ {
+ iServerEntry->MoveEntryWithinService( tEntry.Id(),
+ KMsvGlobalInBoxIndexEntryIdValue );
+ }
+ }
+ }
+
+ if ( iReceivingMode != EMmsReceivingAutomatic && !iMmsSettings->FetchOverride() )
+ {
+ // If fetching is on, the message was deferred because of an error.
+ // In that case we let it remain in the failed list for retries.
+ // If fetching is deferred, manual or off, we don't keep the failed list,
+ // The receiving mode must be changed before we retry the operation.
+
+ // Should we remove the schedule...
+ iFailed->Delete( iCurrentMessageNo - 1 );
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("Receivemsg deleting from the iFailedList") );
+#endif
+ }
+ }
+ }
+ else
+ {
+ // keep LINT happy
+ }
+
+ // release entry in case we were holding the service entry
+ // We should not leave our entry pointing to the serive entry
+ // when we become active, others may want to use it.
+ iServerEntry->SetEntry( KMsvNullIndexEntryId );
+ // just return back to the start of the loop
+ // to handle next message
+ iStatus = KRequestPending;
+ SetActive();
+ TRequestStatus* status = &iStatus;
+ // We propagate the original error no matter what has happened here
+ User::RequestComplete( status, iError );
+
+ }
+
+// ---------------------------------------------------------
+// CMmsReceiveMessage::EncodeNotifyResponseL
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::EncodeNotifyResponseL()
+ {
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("- encoding m-notifyresp-ind") );
+#endif
+ iResponse->SetMessageType( KMmsMessageTypeMNotifyRespInd );
+ iResponse->SetTidL( iNotification->Tid() );
+ // message status has been set before we are called.
+ iResponse->SetReportAllowed( iMmsSettings->DeliveryReportSendingAllowed() );
+ iEncoder->EncodeHeadersL( *iResponse, *iEncodeBuffer );
+ }
+
+// ---------------------------------------------------------
+// CMmsReceiveMessage::EncodeAcknowledgeIndicationL
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::EncodeAcknowledgeIndicationL()
+ {
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("- encoding m-acknowledge-ind") );
+#endif
+ iResponse->SetMessageType( KMmsMessageTypeAcknowledgeInd );
+
+ // The TID has already been set to iResponse earlier, do not override it here
+
+ // version value is set by the encoder.
+ // This response has no status. It is only sent when the status is "Retrieved"
+ iResponse->SetReportAllowed( iMmsSettings->DeliveryReportSendingAllowed() );
+ iEncoder->EncodeHeadersL( *iResponse, *iEncodeBuffer );
+ }
+
+// ---------------------------------------------------------
+// CMmsReceiveMessage::HandleMultipartAlternativeL()
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::HandleMultipartAlternativeL()
+ {
+ // This is just "best effort"
+ // If we cannot properly clear the extra attachments, they are just left "as is"
+
+ if ( iMmsHeaders->MultipartType() != KMmsAssignedApplicationVndWapMultipartAlternative )
+ {
+ return; // nothing to do
+ }
+
+ User::LeaveIfError( iEntryWrapper->SetCurrentEntry( iEntryUnderConstruction ) );
+ CMsvStore* store = iEntryWrapper->EditStoreL();
+ CleanupStack::PushL( store );
+
+ MMsvAttachmentManager& attachMan = store->AttachmentManagerL();
+ MMsvAttachmentManagerSync& attachManSync = store->AttachmentManagerExtensionsL();
+
+ TInt count = attachMan.AttachmentCount();
+
+ if ( count <= 1 )
+ {
+ CleanupStack::PopAndDestroy( store );
+ return; // only one part, keep it
+ }
+
+ TInt i;
+ CMsvMimeHeaders* mimeHeaders = CMsvMimeHeaders::NewL();
+ CleanupStack::PushL( mimeHeaders );
+
+ for ( i = count; i > 0; i-- )
+ {
+ CMsvAttachment* attachInfo = attachMan.GetAttachmentInfoL( i - 1 );
+ CleanupStack::PushL( attachInfo );
+ TPtrC8 pointer;
+ pointer.Set( attachInfo->MimeType() );
+ HBufC8* temp = NULL;
+ if ( pointer.Length() == 0 )
+ {
+ // mime type not set. Try mime headers
+ mimeHeaders->RestoreL( *attachInfo );
+ temp = HBufC8::NewL( mimeHeaders->ContentType().Length() +
+ mimeHeaders->ContentSubType().Length() + 1 );
+ temp->Des().Copy( mimeHeaders->ContentType() );
+ temp->Des().Append( KMmsSlash8 );
+ temp->Des().Append( mimeHeaders->ContentSubType() );
+ pointer.Set( temp->Des() );
+ }
+ CleanupStack::PushL( temp );
+ if ( pointer.CompareF( KMmsTextPlain ) != 0 )
+ {
+ attachManSync.RemoveAttachmentL( i - 1 );
+ count--;
+ }
+ CleanupStack::PopAndDestroy( temp );
+ CleanupStack::PopAndDestroy( attachInfo );
+ temp = NULL;
+ attachInfo = NULL;
+ }
+
+ if ( count > 0 )
+ {
+ // we have something left in the selection
+ // When we commit the store, deleted attachments should disappear
+ store->CommitL();
+ }
+
+ CleanupStack::PopAndDestroy( mimeHeaders );
+ CleanupStack::PopAndDestroy( store );
+ iEntryWrapper->SetCurrentEntry( KMsvNullIndexEntryId );
+ }
+
+// ---------------------------------------------------------
+// CMmsReceiveMessage::::EncodePDUL
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::EncodePDUL()
+ {
+ // This state is used to check what must be done to the notification
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("CMmsReceiveMessage EncodePDUL - Finalize of continue"));
+#endif
+
+ iError = iServerEntry->SetEntry( iSelection->At( iCurrentMessageNo - 1 ) );
+
+ if ( iError != KErrNone )
+ {
+ // The code called by SkipEntryL will make us active again
+ SkipEntryL();
+ return;
+ }
+
+ TMsvEntry tEntry;
+ tEntry = iServerEntry->Entry();
+
+ if ( iReceivingMode == EMmsReceivingAutomatic || iMmsSettings->FetchOverride() )
+ {
+ // if notification is in Inbox, set the fetch flags on
+ if ( tEntry.Parent() == KMsvGlobalInBoxIndexEntryIdValue )
+ {
+ // mark the flags to reserve the notification for fetch
+ MarkNotificationOperationReserved( tEntry, KMmsOperationFetch );
+
+ iServerEntry->ChangeEntry( tEntry );
+ #ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("mark notification that is being fetched") );
+ #endif
+ }
+ // continue fetching
+ FallThrough();
+ return;
+ }
+
+ // mode is deferred of reject
+
+ // entry is in inbox - clear flags and leave it
+ if ( tEntry.Parent() == KMsvGlobalInBoxIndexEntryIdValue )
+ {
+ tEntry.iMtmData2 &= ~KMmsNewOperationForbidden;
+ tEntry.SetReadOnly( ETrue );
+ iServerEntry->ChangeEntry( tEntry );
+ #ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("notification in inbox. Let it be") );
+ #endif
+ LoopToNextEntryL();
+ return;
+ }
+
+ // entry is in mms folder or mmbox folder
+
+ // already deferred - leave it and loop to next entry
+ if ( tEntry.iMtmData2 & KMmsNotifyResponseSent )
+ {
+ #ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("notification already deferred. Let it be") );
+ #endif
+ tEntry.iMtmData2 &= ~KMmsNewOperationForbidden;
+ iServerEntry->ChangeEntry( tEntry );
+ LoopToNextEntryL();
+ return;
+ }
+
+ // reject mode is on
+ if ( iReceivingMode == EMmsReceivingReject )
+ {
+ // Let the notification be, if we have received this notification
+ // earlier in the manual or postpone mode when we have roamed.
+ // In that case KMmsDeferredButResponseNotSent flag is set.
+ // Delete it, if it is a new one that has arrives while we are in reject mode
+ tEntry.iMtmData2 &= ~KMmsNewOperationForbidden;
+ iServerEntry->ChangeEntry( tEntry );
+ if ( !( tEntry.iMtmData2 & KMmsDeferredButResponseNotSent ) )
+ {
+ #ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("deleting the notification") );
+ #endif
+ // we ignore the error. If setting entry to parent fails, deletion will fail
+ iServerEntry->SetEntry( tEntry.Parent() );
+ iServerEntry->DeleteEntry( iSelection->At( iCurrentMessageNo - 1 ) );
+ }
+ LoopToNextEntryL();
+ return;
+ }
+
+ // deferred and response not yet sent
+
+ if ( iRegistrationStatus == 0 ) // home network - continue
+ {
+ #ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("in homenw and deferred mode") );
+ #endif
+ // continue fetching - will send "deferred" response
+ FallThrough();
+ return;
+ }
+
+ // state is deferred, and we are roaming
+
+ // if the status of the notification is retrieved, this
+ // notification will be deleted.
+ // This happens if the notification was extended notification
+ // and the whole message arrived in the notification.
+ // When roaming, no response is sent. The extended notification
+ // is already in the inbox. This notification is deleted.
+
+ CMsvStore* store = iServerEntry->ReadStoreL();
+ CleanupStack::PushL( store );
+ iNotification->RestoreL( *store );
+ CleanupStack::PopAndDestroy( store );
+ store = NULL;
+
+ if ( iNotification->Status() == KMmsMessageStatusRetrieved )
+ {
+ #ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L(" the whole extended notification received") );
+ TMmsLogger::Log( _L("deleting the notification") );
+ #endif
+ // ignore error, if setting parent fails, deletion will fail
+ iServerEntry->SetEntry( tEntry.Parent() );
+ iServerEntry->DeleteEntry( iSelection->At( iCurrentMessageNo - 1 ) );
+ LoopToNextEntryL();
+ return;
+ }
+
+ // The notification is not completely fetched, finalize flags
+
+ #ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("Finalizing the notification") );
+ #endif
+ iNotification->SetStatus( KMmsMessageStatusDeferred );
+ store = iServerEntry->EditStoreL();
+ CleanupStack::PushL( store );
+ iNotification->StoreL( *store );
+ store->CommitL();
+ CleanupStack::PopAndDestroy( store );
+ store = NULL;
+
+ tEntry.SetConnected( EFalse );
+ tEntry.SetFailed( EFalse );
+ tEntry.SetSendingState( KMsvSendStateUnknown );
+
+ tEntry.iMtmData1 |= KMmsMessageMobileTerminated;
+
+ // When roaming it is not allowed to send a notify response
+ // to MMSC.
+ tEntry.iMtmData2 |= KMmsDeferredButResponseNotSent;
+
+ // The receiving mode is either manual or postpone, when roaming.
+ // If the manual mode is on, the mtm type is changed to notification
+ // and the notification is moved to Inbox.
+ //
+ if ( iMmsSettings->ReceivingModeForeign() != EMmsReceivingManual )
+ {
+ // this is all we need
+ iServerEntry->ChangeEntry( tEntry );
+ }
+ else
+ {
+ // Change the iMtm from KUidMsgTypeMultimedia to
+ // KUidMsgMMSNotification
+ tEntry.iMtm = KUidMsgMMSNotification;
+ tEntry.iMtmData2 &= ~KMmsNewOperationForbidden;
+ #ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("marking as a notification") );
+ #endif
+ // Readonly flag has to be set on in inbox.
+ // Not in mms folder
+ tEntry.SetReadOnly( ETrue );
+ iServerEntry->ChangeEntry( tEntry );
+ #ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("moving to inbox") );
+ #endif
+ // Ignore error from set entry. If it fails, move will fail (not panic)
+ // Setting service entry to a folder should not fail.
+ iServerEntry->SetEntry( tEntry.Parent() );
+ iServerEntry->MoveEntryWithinService( tEntry.Id(), KMsvGlobalInBoxIndexEntryIdValue );
+ }
+
+ LoopToNextEntryL();
+
+ }
+
+// ---------------------------------------------------------
+// CMmsReceiveMessage::::SkipEntryL
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::SkipEntryL()
+ {
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("receivemsg - can't access notification") );
+#endif
+ // If the notification cannot be accessed, we must try the next one
+ // If the notification was not found, or was used by someone else,
+ // then nothing can be done. Nothing can be done to the scheduling data.
+
+ // We completely discard only entries that cannot be found
+ if ( iError == KErrNotFound )
+ {
+ iFailed->Delete( iCurrentMessageNo - 1 );
+ }
+ // we must return to the beginning of the loop without doing anything
+ iState = EMmsOperationUpdatingEntryStatus;
+ iServerEntry->SetEntry( KMsvNullIndexEntryId );
+ // The code called by ChangeStateL will make us active again
+ ChangeStateL();
+ }
+
+// ---------------------------------------------------------
+// CMmsReceiveMessage::::LoopToNextEntryL
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::LoopToNextEntryL()
+ {
+ // release entry
+ iServerEntry->SetEntry( KMsvNullIndexEntryId );
+ // loop to next entry
+ iFailed->Delete( iCurrentMessageNo - 1 );
+ iState = EMmsOperationUpdatingEntryStatus;
+ SelectNextState();
+ // The code called by ChangeStateL will make us active again
+ ChangeStateL();
+ }
+
+// ---------------------------------------------------------
+// CMmsReceiveMessage::FolderEntryL
+//
+// ---------------------------------------------------------
+//
+TInt CMmsReceiveMessage::FolderEntryL(
+ TMsvId aParent, const TDesC& aFolderName, TMsvId& aFolderId )
+ {
+ aFolderId = KMsvNullIndexEntryId;
+
+ TInt error = KErrNone;
+
+ // get a new entry, don't mess up with the original entry.
+ CMsvServerEntry* workingEntry = NULL;
+ TRAP( error, workingEntry = iServerEntry->NewEntryL( aParent ) );
+ CleanupStack::PushL( workingEntry );
+
+ if ( error != KErrNone )
+ {
+ CleanupStack::PopAndDestroy( workingEntry ); // workingEntry
+ return error;
+ }
+
+ // Show invisible entries
+ TMsvSelectionOrdering ordering =
+ TMsvSelectionOrdering( KMsvNoGrouping, EMsvSortByIdReverse, ETrue );
+ workingEntry->SetSort( ordering );
+
+ CMsvEntrySelection* selection = new ( ELeave ) CMsvEntrySelection;
+ error = workingEntry->GetChildrenWithType( KUidMsvFolderEntry, *selection );
+ if ( error == KErrNone )
+ {
+ // If selection contains folders, check if the folder is found.
+ TInt count = selection->Count();
+ for ( TInt i = 0; i < count && aFolderId == KMsvNullIndexEntryId; i++ )
+ {
+ error = workingEntry->SetEntry( selection->At( i ) );
+ if ( error == KErrNone )
+ {
+ // must be exact match
+ if ( workingEntry->Entry().iDetails.Compare( aFolderName ) == 0 )
+ {
+ aFolderId = selection->At( i );
+ }
+ }
+ }
+ }
+ delete selection;
+ selection = NULL;
+ CleanupStack::PopAndDestroy( workingEntry );
+ workingEntry = NULL;
+
+ return error;
+
+ }
+
+ // -----------------------------------------------------------------------------
+// CMmsReceiveMessage::CreateFolderEntryL
+//
+// -----------------------------------------------------------------------------
+//
+TInt CMmsReceiveMessage::CreateFolderEntryL(
+ TMsvId aParentFolder, const TDesC& aFolderName, TMsvId& aFolderId )
+ {
+
+ // Check if the folder already exists under parent folder.
+ TInt error = FolderEntryL( aParentFolder, aFolderName, aFolderId );
+ if ( aFolderId != KMsvNullIndexEntryId || error != KErrNone )
+ {
+ // if error == KErrNone and aFolderId not equal to KMsvNullIndexEntryId
+ // the folder already exists, and we don't need to create anything
+ return error;
+ }
+
+ CMsvServerEntry* serverEntry = NULL;
+ TRAP( error, serverEntry = iServerEntry->NewEntryL( aParentFolder ) );
+ CleanupStack::PushL( serverEntry );
+
+ if ( error != KErrNone )
+ {
+ CleanupStack::PopAndDestroy( serverEntry );
+ return error;
+ }
+
+ // Create a new folder.
+ error = serverEntry->SetEntry( aParentFolder );
+
+ if ( error == KErrNone )
+ {
+ TMsvEntry entry;
+ entry.iType = KUidMsvFolderEntry;
+ entry.iMtm = KUidMsvLocalServiceMtm;
+ entry.iDetails.Set( aFolderName );
+ entry.SetVisible( EFalse );
+ entry.SetInPreparation( EFalse );
+ entry.iServiceId = KMsvLocalServiceIndexEntryId;
+ error = serverEntry->CreateEntry( entry );
+ aFolderId = entry.Id();
+ }
+ CleanupStack::PopAndDestroy( serverEntry );
+ serverEntry = NULL;
+ return error;
+
+ }
+
+
+// ---------------------------------------------------------
+// CMmsReceiveMessage::FindDuplicateNotificationL
+//
+// ---------------------------------------------------------
+//
+TInt CMmsReceiveMessage::FindDuplicateNotificationL(
+ TMsvId aParent, CMmsHeaders& aHeaders, TMsvId& aDuplicate )
+ {
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("CMmsReceiveMessage::FindDuplicateNotificationL") );
+#endif
+
+ aDuplicate = KMsvNullIndexEntryId;
+
+ if ( aParent == KMsvNullIndexEntryId )
+ {
+ return KErrNotSupported;
+ }
+
+ // Get a new entry, dont mess up with our original entry
+ TInt error = KErrNone;
+
+ CMsvServerEntry* workingEntry = NULL;
+ TRAP( error, workingEntry = iServerEntry->NewEntryL( aParent ));
+ CleanupStack::PushL( workingEntry );
+
+ if ( error != KErrNone )
+ {
+ CleanupStack::PopAndDestroy( workingEntry );
+ return error;
+ }
+
+ CMsvEntrySelection* selection = new ( ELeave ) CMsvEntrySelection;
+ CleanupStack::PushL( selection );
+
+ error = workingEntry->GetChildrenWithMtm( KUidMsgMMSNotification, *selection );
+
+ TInt count = selection->Count();
+ if ( count == 0 )
+ {
+ error = KErrNotSupported;
+ }
+
+ if ( error != KErrNone )
+ {
+ CleanupStack::PopAndDestroy( selection );
+ CleanupStack::PopAndDestroy( workingEntry );
+ return error;
+ }
+
+ CMmsHeaders* mmsHeaders = CMmsHeaders::NewL( iMmsSettings->MmsVersion() );
+ CleanupStack::PushL( mmsHeaders );
+
+ for ( TInt i = count; i > 0 && ( aDuplicate == KMsvNullIndexEntryId ); i-- )
+ {
+ error = workingEntry->SetEntry( selection->At( i - 1 ) );
+ if ( error == KErrNone )
+ {
+ CMsvStore* store = workingEntry->ReadStoreL();
+ CleanupStack::PushL( store );
+ mmsHeaders->RestoreL( *store );
+ CleanupStack::PopAndDestroy( store );
+
+ // content location must match
+ if ( mmsHeaders->ContentLocation().Compare( aHeaders.ContentLocation() ) == 0 )
+ {
+ // Identical. This probably means that we have not sent a response yet,
+ // and MMSC has sent us a new notification.
+
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("- content locations match") );
+#endif
+ TMsvEntry entry = workingEntry->Entry();
+ aDuplicate = entry.Id();
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy( mmsHeaders );
+ CleanupStack::PopAndDestroy( selection );
+ CleanupStack::PopAndDestroy( workingEntry );
+
+ return error;
+ }
+
+// ---------------------------------------------------------
+// CMmsReceiveMessage::LocalModeFetchL
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::LocalModeFetchL()
+ {
+
+ HBufC* buffer = HBufC::NewL( KMaxFileName );
+ CleanupStack::PushL( buffer );
+ if ( iNotification->ContentLocation().Length() <= KMaxPath &&
+ iMmsSettings->LocalMode() )
+ {
+ buffer->Des().Copy( iNotification->ContentLocation() );
+ }
+ TPtr temp = buffer->Des();
+ #ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("...Fetching from : %S"), &temp );
+ #endif
+
+ HBufC* filename = HBufC::NewL( iMmsSettings->LocalModeIn().Length() );
+ CleanupStack::PushL( filename );
+ TPtr fileNamePtr = filename->Des();
+ fileNamePtr.Copy( iMmsSettings->LocalModeIn() );
+
+ if ( iNotification->ContentLocation().Length() <= KMaxPath &&
+ buffer->Des().FindF( fileNamePtr ) == 0 )
+ {
+ // The file reading code is for local mode (simulated MMSC)
+ // Only one can try to get the file at a time
+ #ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("opening file") );
+ #endif
+ iError = iFile.Open( iFs, temp, EFileShareExclusive );
+
+ if ( iError == KErrNone )
+ {
+ #ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("file opened") );
+ #endif
+ iFileOpen = ETrue;
+ TInt size = 0;
+ iError = iFile.Size( size );
+
+ // Here we try to use chunked buffer.
+ // Read the message in chunks and keep calling decode
+ // Before we can do that, we must create the message entry
+ // Because it must be ready to receive data
+ // If receiving fails, the entry must be removed
+
+ DoCreateEntryL();
+ iDecoder->InitializeChunkedMode( *iEntryWrapper, *iMmsHeaders, *iEncodeBuffer );
+ TInt chunkSize = KMmsChunkedBufferSize;
+ if ( iError == KErrNone )
+ {
+ TRAP( iError, iEncodeBuffer->ResizeL( chunkSize ) );
+ }
+ if ( iError != KErrNone )
+ {
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("Receivemsg can't resize buffer, error %d"), iError );
+ TMmsLogger::Log( _L("- message size %d"), chunkSize );
+#endif
+ iFile.Close();
+ iFileOpen = EFalse;
+ iDecoder->RelaseDataSink();
+ CleanupStack::PopAndDestroy( filename );
+ CleanupStack::PopAndDestroy( buffer );
+ return;
+ }
+
+ // We now have an open file.
+ // We read it in chunks and feed it to decoder piecewise
+ TPtr8 pos = iEncodeBuffer->Ptr( 0 );
+
+ TInt position = 0;
+ TInt readData = 0;
+ TInt amount = 0;
+ TBool lastChunk = EFalse;
+ TInt error = KErrNone;
+
+ while ( readData < size && error == KErrNone )
+ {
+ chunkSize = KMmsChunkedBufferSize;
+ const TInt KMmsTwo = 2;
+ if ( chunkSize - amount < KMmsChunkedBufferSize / KMmsTwo )
+ {
+ // if almost all data has been left to buffer, increase buffer size
+ chunkSize = amount + KMmsChunkedBufferSize / KMmsTwo;
+ }
+ iEncodeBuffer->ResizeL( chunkSize );
+ pos.Set( iEncodeBuffer->Ptr( amount ) );
+ pos.SetLength( chunkSize - amount );
+ error = iFile.Read( pos, chunkSize - amount );
+ amount += pos.Length();
+ readData += pos.Length();
+ if ( readData >= size )
+ {
+ lastChunk = ETrue;
+ }
+ if ( error == KErrNone )
+ {
+ // this is how much data we have
+ iEncodeBuffer->ResizeL( amount );
+ error = iDecoder->NextDataPart( *iEncodeBuffer, position, lastChunk );
+ }
+ if ( position > iEncodeBuffer->Size() )
+ {
+ position = iEncodeBuffer->Size();
+ }
+ // Check if we can continue and shift the buffer if needed
+ if ( error == KErrNone )
+ {
+ // now position points to the beginning of unhandled data
+ // it must be shifted to the beginning
+ amount -= position; // this much left unhandled
+ if ( amount < 0 )
+ {
+ amount = 0;
+ }
+ iEncodeBuffer->Delete( 0, position );
+ // start from the beginning the next time
+ position = 0;
+ }
+ }
+ if ( error != KErrNone )
+ {
+ iError = error;
+ }
+ // when the loop ends, all data should be handled and all attachments should be created
+ // Decode has also saved message headers.
+ // The changed state indicates what is complete
+ iDecoder->RelaseDataSink();
+ iState = EMmsOperationDecodingResponse;
+ }
+ else
+ {
+ // This corresponds to the situation, where the message
+ // has expired or for some other reason is no longer available.
+ // We lie to RunL that we have already decoded the message
+ iFile.Close();
+ iFileOpen = EFalse;
+ iState = EMmsOperationDecodingResponse;
+ if ( iError != KErrInUse )
+ {
+ iBad->AppendL( iSelection->At( iCurrentMessageNo - 1 ) );
+ }
+ }
+ // We don't close the file yet.
+ // We want to keep it exclusively to ourselves until we are done with it
+ }
+ else
+ {
+ // No directory found in notification
+ // this notification cannot be handled.
+ // It will be marked bad and deleted.
+ iError = KErrNotFound;
+ iState = EMmsOperationDecodingResponse;
+ iBad->AppendL( iSelection->At( iCurrentMessageNo - 1 ) );
+ }
+ CleanupStack::PopAndDestroy( filename );
+ CleanupStack::PopAndDestroy( buffer );
+ }
+
+// ---------------------------------------------------------
+// CMmsReceiveMessage::DumpIfNeededL
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::DumpIfNeededL()
+ {
+#ifndef _NO_MMSS_LOGGING_
+ TInt error = KErrNone;
+ TBool dumpIncoming = EFalse;
+ //
+ // Reading binary dumping from CenRep
+ //
+ CRepository* repository = NULL;
+ TInt retval = KErrNone;
+ TRAP( retval, repository = CRepository::NewL( KUidMmsServerMtm ) ); // ***
+ if( retval == KErrNone )
+ {
+ CleanupStack::PushL( repository );
+ TInt temp = 0;
+ retval = repository->Get( KMmsEngineBinaryDump, temp );
+ if( retval == KErrNone )
+ {
+ dumpIncoming = (TBool)temp;
+ }
+ CleanupStack::PopAndDestroy( repository );
+ }
+
+ TMmsLogger::Log( _L("Receivemsg Dumping Entry") );
+ // If the result was bad, we dump the binary data into file
+ // - unless decode already did it.
+ if ( ( ( !dumpIncoming ) && iError != KErrNone ) &&
+ iEncodeBuffer &&
+ iEncodeBuffer->Size() > 0 )
+ {
+ TParse parse;
+ TFileName fileName;
+ fileName.Copy( KMmsDefaultLogDirectory );
+ TUint att;
+ if ( iFs.Att( fileName, att ) == KErrNone )
+ {
+ _LIT( KRelated, "Rec.mms");
+ parse.Set( fileName, &KRelated, NULL );
+ fileName = parse.FullName();
+ error = CApaApplication::GenerateFileName( iFs, fileName );
+ if ( error == KErrNone )
+ {
+ RFile file;
+ error = file.Create( iFs, fileName, EFileWrite | EFileShareExclusive );
+ // for message id generation
+ parse.Set( fileName, NULL, NULL );
+
+ if ( error == KErrNone )
+ {
+ // the data is supposed to be in the encode buffer
+ TPtr8 ptr = iEncodeBuffer->Ptr( 0 );
+ file.Write( ptr );
+ file.Flush();
+ }
+
+ // done - close files
+ file.Close();
+ }
+ }
+ }
+#endif
+ }
+
+// ---------------------------------------------------------
+// CMmsReceiveMessage::CloseLocalFile
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::CloseLocalFileL( TBool aDeleteFile )
+ {
+ HBufC* buffer = HBufC::NewL( KMaxFileName );
+ CleanupStack::PushL( buffer );
+ buffer->Des().Copy( iNotification->ContentLocation() );
+ HBufC* filename = HBufC::NewL( iMmsSettings->LocalModeIn().Length() );
+ CleanupStack::PushL( filename );
+ TPtr fileNamePtr = filename->Des();
+ fileNamePtr.Copy( iMmsSettings->LocalModeIn() );
+ if ( buffer->Des().FindF( fileNamePtr ) == 0 )
+ {
+ // this was our local message file
+ iFile.Close();
+ iFileOpen = EFalse;
+ if ( aDeleteFile )
+ {
+ iFs.Delete( *buffer );
+ }
+ }
+ CleanupStack::PopAndDestroy( filename );
+ CleanupStack::PopAndDestroy( buffer );
+ }
+
+// ---------------------------------------------------------
+// CMmsReceiveMessage::MoveToApplicationFolderIfNeededL
+//
+// ---------------------------------------------------------
+//
+TInt CMmsReceiveMessage::MoveToApplicationFolderIfNeededL( TMsvEntry& aEntry )
+ {
+ TInt error = KErrNone;
+ TInt returnCode = 0;
+
+ if ( iMmsHeaders->ApplicId().Length() > 0 )
+ {
+ // check if application id is registered
+ if ( iRegistered )
+ {
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("- message to registered application") );
+#endif
+ TMsvId targetFolder = KMsvNullIndexEntryId;
+ // target folder's parent is application folder
+ TMsvId applicationFolder = iMmsSettings->ApplicationFolder();
+ // code scanner gives false positive from the next line
+ error = CreateFolderEntryL( applicationFolder, iMmsHeaders->ApplicId(), targetFolder );
+ if ( targetFolder != KMsvNullIndexEntryId && error == KErrNone )
+ {
+ error = iServerEntry->SetEntry( aEntry.Parent() );
+ if ( error == KErrNone )
+ {
+ error = iServerEntry->MoveEntryWithinService( aEntry.Id(), targetFolder );
+ }
+ if ( error == KErrNone )
+ {
+ // Message was successfully moved to application folder
+ // If we want to keep the notification in inbox we return
+ // KMmsMessageMovedToApplicationFolder.
+ // As long as we serve only Java applications, the notifications
+ // will disappear from inbox if the message was moved to application folder.
+ // Java will start the applet if it is not running, and that should
+ // be sufficient information for the user.
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("- moved to application folder") );
+#endif
+ returnCode = 0;
+ }
+ // If we cannot set our entry back to the one we are handling,
+ // we are in deep trouble
+ User::LeaveIfError( iServerEntry->SetEntry( iEntryUnderConstruction ));
+ }
+ }
+ else
+ {
+ // There was an application id, but the application was not registered
+ // Message will be deleted
+ // If deletion fails, the message remains invisible and under construction
+ // and will be deleted by message server at next boot.
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("- message to unregistered application - deleted") );
+#endif
+ error = iServerEntry->SetEntry( aEntry.Parent() );
+ if ( error == KErrNone )
+ {
+ iServerEntry->DeleteEntry( aEntry.Id() );
+ }
+ returnCode = KMmsMessageForUnregisteredApplication;
+ }
+ }
+ // If no application id, the message is normal
+ return returnCode;
+ }
+
+// ---------------------------------------------------------
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::ClearDuplicateEntryOperationL()
+ {
+ CMsvStore* store = iServerEntry->ReadStoreL();
+ CleanupStack::PushL( store );
+ iMmsHeaders->RestoreL( *store );
+ CleanupStack::PopAndDestroy( store );
+ TMsvId duplicate = KMsvNullIndexEntryId;
+ TMsvId mmboxFolder = iMmsSettings->MMBoxFolder();
+ TMsvEntry dupEntry;
+
+ if ( iNotificationParent == KMsvGlobalInBoxIndexEntryIdValue )
+ {
+ // if duplicate is found from mmbox folder,
+ // mark it as "deleted from mmbox server"
+ if ( mmboxFolder != KMsvNullIndexEntryId )
+ {
+ FindDuplicateNotificationL( mmboxFolder, *iMmsHeaders, duplicate );
+ }
+ if ( duplicate != KMsvNullIndexEntryId )
+ {
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("- duplicate found ") );
+#endif
+ if ( iServerEntry->SetEntry( duplicate ) == KErrNone )
+ {
+ // Mark duplicate as deleted from mmbox server.
+ // If it was successfully fetched it is no longer in MMBox.
+ // This is not exactly correct for full MMBox support but as long as
+ // we don't have full MMBox support this works correctly
+ dupEntry = iServerEntry->Entry();
+ MarkNotificationDeletedFromMmbox( dupEntry );
+ iServerEntry->ChangeEntry( dupEntry );
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("- duplicate marked as deleted from mmbox ") );
+#endif
+ }
+ }
+ }
+ else if ( iNotificationParent == mmboxFolder )
+ {
+ duplicate = iMmsHeaders->RelatedEntry();
+ if ( duplicate != KMsvNullIndexEntryId )
+ {
+#ifndef _NO_MMSS_LOGGING_
+ TMmsLogger::Log( _L("- duplicate found ") );
+#endif
+ if ( iServerEntry->SetEntry( duplicate ) == KErrNone )
+ {
+ // Mark it deleted just in case the actual deletion fails.
+ // This is not exactly correct for full MMBox support but as long as
+ // we don't have full MMBox support this works correctly
+ dupEntry = iServerEntry->Entry();
+ MarkNotificationDeletedFromMmbox( dupEntry );
+ iServerEntry->ChangeEntry( dupEntry );
+ // delete the duplicate notification from inbox
+ if ( iServerEntry->SetEntry( KMsvGlobalInBoxIndexEntryIdValue )
+ == KErrNone )
+ {
+ TInt err = iServerEntry->DeleteEntry( duplicate );
+#ifndef _NO_MMSS_LOGGING_
+ if ( err == KErrNone )
+ {
+ TMmsLogger::Log( _L("- duplicate deleted from inbox ") );
+ }
+#endif
+ }
+ }
+ }
+ }
+ else
+ {
+ // nothing to do - just keep compiler and code analyzer tools happy
+ }
+ }
+
+// ---------------------------------------------------------
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::ClearOperationL( TInt aApplicationMessageStatus )
+ {
+ if ( iServerEntry->SetEntry( iSelection->At( iCurrentMessageNo - 1 ) ) == KErrNone )
+ {
+ if ( aApplicationMessageStatus != 0 )
+ {
+ // The entry is not deleted if it is in inbox or MMBox
+ // and has been routed to application.
+ // We save the error code or routing status to the entry.
+ TMsvEntry tEntry = iServerEntry->Entry();
+ MarkNotificationDeletedFromMmbox( tEntry );
+ tEntry.SetConnected( EFalse );
+ tEntry.SetReadOnly( ETrue );
+
+ if ( aApplicationMessageStatus == KMmsMessageMovedToApplicationFolder )
+ {
+ // This is a successful case
+ tEntry.iMtmData2 |= KMmsMessageRoutedToApplication;
+ }
+ if ( aApplicationMessageStatus ==
+ KMmsMessageForUnregisteredApplication )
+ {
+ // This will be marked as failed operation
+ // even if the message was actually successfully fetched
+ // but it was discarded because it does not belong to anybody
+ tEntry.iError = KMmsErrorUnregisteredApplication;
+ // The earlier operation cleared the possible MMBox bit
+ // This operation marks the result as failed.
+ MarkNotificationOperationFailed( tEntry );
+ }
+
+ // error status not checked here - we just do our best
+ iServerEntry->ChangeEntry( tEntry );
+ }
+ ClearDuplicateEntryOperationL();
+ }
+ }
+
+
+// ---------------------------------------------------------
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::CopyDataFromNotificationToMessageL()
+ {
+ // Only subject and sender take up space when headers are added
+ TInt size = iNotification->Sender().Length() +
+ iNotification->Subject().Length();
+ if ( size > 0 &&
+ TMmsGenUtils::DiskSpaceBelowCriticalLevelL( &iFs, size, iMessageDrive ) )
+ {
+ size = 0;
+ }
+
+ // We copy data from notification to message if the values are missing
+ // But if the message is already complete (status == OK)
+ // we do not copy anything.
+ if ( iMmsHeaders->ResponseStatus() > KMmsResponseStatusOK )
+ {
+ // The critical disk space is checked only when adding the subject.
+ // The sender number is important and only takes a small amount of space
+ // The other fields take the same amount of space regardless of the value.
+ // As the headers have been saved already, only subject may consume
+ // significantly more disk space.
+ if ( size > 0 )
+ {
+ if ( iMmsHeaders->Subject().Length() == 0 )
+ {
+ iMmsHeaders->SetSubjectL( iNotification->Subject() );
+ }
+ }
+ if ( iMmsHeaders->Sender().Length() == 0 )
+ {
+ iMmsHeaders->SetSenderL( iNotification->Sender() );
+ }
+ if ( iMmsHeaders->MessageClass() == 0 )
+ {
+ iMmsHeaders->SetMessageClass( iNotification->MessageClass() );
+ }
+ if ( iMmsHeaders->MessagePriority() == 0 )
+ {
+ iMmsHeaders->SetMessagePriority( iNotification->MessagePriority() );
+ }
+ // Copy the expiry, too
+ if ( iMmsHeaders->ExpiryDate() == 0 && iMmsHeaders->ExpiryInterval() == 0 )
+ {
+ // No expiration data in the message - use what is in the notification
+ iMmsHeaders->SetExpiryDate( iNotification->ExpiryDate() );
+ }
+ }
+ }
+
+// ---------------------------------------------------------
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::CopyDataFromMessageToNotificationL()
+ {
+ TBool saveNotification = EFalse;
+ TInt error = KErrNone;
+
+ iNotification->SetResponseTextL( iMmsHeaders->ResponseText() );
+ iNotification->SetResponseStatus( iMmsHeaders->ResponseStatus() );
+
+ // Notifications do not originally contain any response texts.
+ // If the length is not 0, we have added something
+ if ( iNotification->ResponseText().Length() > 0 || iNotification->ResponseStatus() != 0 )
+ {
+ saveNotification = ETrue;
+ }
+
+ if ( iNotification->ApplicId().Length() == 0 )
+ {
+ iNotification->SetApplicIdL( iMmsHeaders->ApplicId() );
+ if ( iNotification->ApplicId().Length() > 0 )
+ {
+ // If we copied the application id, we must save it.
+ saveNotification = ETrue;
+ }
+ }
+
+ // update the notification
+ if ( saveNotification )
+ {
+ // We update the notification if we added something
+ error = iServerEntry->SetEntry( iSelection->At( iCurrentMessageNo - 1 ) );
+ if ( error == KErrNone )
+ {
+ TRAP( error,
+ {
+ CMsvStore* store = iServerEntry->EditStoreL();
+ CleanupStack::PushL( store );
+ iNotification->StoreL( *store );
+ store->CommitL();
+ CleanupStack::PopAndDestroy( store );
+ })
+ }
+ // If we cannot update the entry, the user does not see the error text, but that's not fatal
+ }
+ // Release the entry
+ iServerEntry->SetEntry( KMsvNullIndexEntryId );
+
+ }
+
+// ---------------------------------------------------------
+//
+// ---------------------------------------------------------
+//
+TBool CMmsReceiveMessage::MapErrorStatus( const TInt32 aErrorStatus )
+ {
+ TBool fatal = EFalse;
+
+ switch ( aErrorStatus )
+ {
+ case 0: // if the header is not present, it is 0
+ case KMmsStatusOk:
+ // No error, don't change iError
+ break;
+ case KMmsErrorPermanentFailure:
+ fatal = ETrue;
+ iError = KMmsErrorStatusPermanentFailure;
+ break;
+ case KMmsErrorTransientFailure:
+ iError = KMmsErrorStatusTransientFailure;
+ break;
+ case KMmsErrorReceivePermanentMessageNotFound:
+ fatal = ETrue;
+ iError = KMmsErrorStatusMessageNotFound;
+ break;
+ case KMmsErrorReceiveTransientMessageNotFound:
+ iError = KMmsErrorStatusTransientMessageNotFound;
+ break;
+ case KMmsErrorReceiveTransientNetworkProblem:
+ iError = KMmsErrorStatusNetworkProblem;
+ break;
+ case KMmsErrorPermanentServiceDenied:
+ fatal = ETrue;
+ iError = KMmsErrorStatusServiceDenied;
+ break;
+ case KMmsErrorReceivePermanentContentUnsupported:
+ fatal = ETrue;
+ iError = KMmsErrorStatusContentUnsupported;
+ break;
+ default:
+ // Unknown error, if not transient, it is fatal
+ if ( ( aErrorStatus & KMmsErrorRangeMask ) == KMmsErrorTransient )
+ {
+ iError = KMmsErrorStatusTransientFailure;
+ }
+ else
+ {
+ iError = KMmsErrorPermanentFailure;
+ fatal = ETrue;
+ }
+ break;
+ }
+
+ return fatal;
+ }
+
+// ---------------------------------------------------------
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::SetIndexEntryBitsForReceivedMessage( TMsvEntry& aEntry )
+ {
+ aEntry.iMtmData1 &= ~KMmsMessageTypeMask;
+ // We override message type for now.
+ // We get send requests instead of retrieve confirmations if in local mode
+ aEntry.iMtmData1 |= KMmsMessageMRetrieveConf | KMmsMessageMobileTerminated;
+
+ aEntry.SetVisible( ETrue );
+ aEntry.SetComplete( ETrue );
+ aEntry.SetInPreparation( EFalse );
+ aEntry.SetReadOnly( ETrue );
+ aEntry.iDate.UniversalTime(); // this is arrival time
+
+ if ( iMmsSettings->ShowSentTime() )
+ {
+ // show the time the message was received by MMSC instead of
+ // the time the message was received by the terminal
+ if ( iMmsHeaders->Date() > 0 )
+ {
+ // date is given as seconds from 1.1.1970, UTC time
+ TTime time = TTime( KMmsYear1970String ) +
+ TTimeIntervalMicroSeconds( iMmsHeaders->Date() * KMmsMillion );
+ aEntry.iDate = time.Int64();
+ }
+ }
+ // subject, sender and size are set in CMmsDecode
+ // - except if we get an empty error message.
+ // In that case the fields were copied from the notification,
+ // and we set sender and subject here.
+ if ( aEntry.iDetails.Length() == 0 )
+ {
+ aEntry.iDetails.Set( iMmsHeaders->Sender() );
+ }
+ if ( aEntry.iDescription.Length() == 0 )
+ {
+ aEntry.iDescription.Set( iMmsHeaders->Subject() );
+ }
+
+ // Set multiple recipients
+ if ( iMmsHeaders->ToRecipients().MdcaCount() +
+ iMmsHeaders->CcRecipients().MdcaCount() +
+ iMmsHeaders->BccRecipients().MdcaCount() > 1 )
+ {
+ aEntry.SetMultipleRecipients( ETrue );
+ }
+ }
+
+
+// ---------------------------------------------------------
+//
+// ---------------------------------------------------------
+//
+void CMmsReceiveMessage::DeleteApplicationMessagesL()
+ {
+ // target folder's parent is application folder
+ TMsvId messageFolder = KMsvNullIndexEntryId;
+ TMsvId applicationFolder = iMmsSettings->ApplicationFolder();
+ // code scanner gives false positive from the next line
+ TInt error = KErrNone;
+ error = FolderEntryL( applicationFolder, iMmsHeaders->ApplicId(), messageFolder );
+
+ if ( messageFolder == KMsvNullIndexEntryId || error != KErrNone )
+ {
+ // We could not find the folder - we cannot free space
+ return;
+ }
+
+ // List all messages in the folder and try to see if we can free enough room.
+ TInt size = iNotification->MessageSize();
+ if ( size > iMmsSettings->MaximumReceiveSize() )
+ {
+ // We cannot fetch more than this anyway
+ size = iMmsSettings->MaximumReceiveSize();
+ }
+ // The safety margin must be added to the indicated size as the size in the
+ // notification only specifies the payload, not all headers and space taken
+ // by message entry and folder entry needed.
+ size += KMmsDiskSafetyMargin;
+
+ error = iServerEntry->SetEntry( messageFolder );
+ if ( error != KErrNone )
+ {
+ // no can do
+ return;
+ }
+
+ // sort entries by date
+ TMsvSelectionOrdering ordering =
+ TMsvSelectionOrdering( KMsvNoGrouping, EMsvSortByDate, EFalse );
+ iServerEntry->SetSort( ordering );
+
+ CMsvEntrySelection* selection = new ( ELeave ) CMsvEntrySelection;
+ CleanupStack::PushL( selection );
+ error = iServerEntry->GetChildrenWithType( KUidMsvMessageEntry, *selection );
+ if ( error != KErrNone )
+ {
+ // no can do
+ iServerEntry->SetEntry( KMsvNullIndexEntryId );
+ CleanupStack::PopAndDestroy( selection );
+ }
+
+ TInt i;
+ TInt deleteCount = 0; // entries to be deleted to free space
+ TInt oldSize = 0;
+ for ( i = 0; i < selection->Count() && deleteCount == 0; i++ )
+ {
+ error = iServerEntry->SetEntry( selection->At( i ) );
+ if ( error == KErrNone )
+ {
+ // If we could not access some entry, it will end up in the
+ // delete list anyway. It may or may not be deleted.
+ oldSize += iServerEntry->Entry().iSize;
+ }
+ if ( oldSize >= size )
+ {
+ deleteCount = i + 1;
+ }
+ }
+
+ // Check if we fond enough old messages to free space.
+ if ( deleteCount > 0 )
+ {
+ for ( i = selection->Count(); i > deleteCount; ++i )
+ {
+ // We may be able to leave some entries
+ selection->Delete( i - 1 );
+ }
+
+ error = iServerEntry->SetEntry( messageFolder );
+ if ( error == KErrNone )
+ {
+ error = iServerEntry->DeleteEntries( *selection );
+ }
+ // If we get an error because some entry is locked or open
+ // the original KErrNoDisk remains and no entries are deleted
+ // The situation will follow normal low disk space handling
+ // If the entries are being accessed by the application, the
+ // space may be freed soon by the application.
+ if ( error == KErrNone )
+ {
+ // We have successfully deleted enough entries
+ // The new message should now fit.
+ // It can be rescheduled or fetch can be manually restarted
+ iError = KMmsErrorApplicationDiskFull;
+ }
+ }
+ iServerEntry->SetEntry( KMsvNullIndexEntryId );
+ CleanupStack::PopAndDestroy( selection );
+ }
+
+
+// ================= OTHER EXPORTED FUNCTIONS ==============
+
+// End of File
+