/*

* 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 ) )