/*

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

*     Server Mtm

*

*/

// INCLUDE FILES

#include    <apparc.h>

#include    <msventry.h>

#include    <msvschedulepackage.h>

#include    <msvschedulesettings.h>

#include    <msvsenderroraction.h>

#include    <bautils.h>

#include    <e32math.h> // for notification generation

#include    <logcli.h>

#include    <logview.h>

#include    <flogger.h>

#include    <e32svr.h>

#include    <centralrepository.h>

#include    <utf.h>

#include    <cmsvmimeheaders.h>

#include    "LogsApiConsts.h"

#include    <logengdurations.h>

// MMS specific

#include    "mmsconst.h"

#include    "mmserrors.h"

#include    "mmsmmboxmessageheaders.h"

#include    "mmsservercommon.h"

#include    "mmscmds.h"

#include    "mmssettings.h"

#include    "mmsaccount.h"

#include    "mmsserver.h"

#include    "mmssendoperation.h"

#include    "mmsreceivemessage.h"

#include    "mmsforwardoperation.h"

#include    "mmsdeleteoperation.h"

#include    "mmsmmboxlist.h"

#include    "mmsdecode.h"

#include    "mmsencode.h"

#include    "mmsheaders.h"

#include    "mmsschedulesend.h"

#include    "mmsscheduledentry.h"

#include    "mmslog.h"

#include    "mmsgenutils.h"

#include    "mmsserverentry.h"

#include    "MmsEnginePrivateCRKeys.h"

#include    "mmsreadreport.h"

// LOCAL CONSTANTS AND MACROS

const TInt KMmsGarbageCollectionDelay = 30; // 30s delay

const TInt KMmsSanityInterval = 96;  // 96 hours, 4 days

const TInt KMmsScheduleAllowance = 10;

const TInt KMmsScheduleDelay = 5;

// ================= MEMBER FUNCTIONS =======================

// ---------------------------------------------------------

// C++ default constructor can NOT contain any code, that

// might leave.

// ---------------------------------------------------------

//

CMmsServerMtm::CMmsServerMtm(

    CRegisteredMtmDll& aRegisteredMtmDll,

    CMsvServerEntry* aInitialEntry )

    : CScheduleBaseServerMtm( aRegisteredMtmDll, aInitialEntry ),

    iNotification ( KMsvNullIndexEntryId ),

    iOOMState ( EFalse ),

    iDeliveryStatus (EFalse)

    {

    // Everything not mentioned gets initialized to NULL

    // Save our initial entry id

    // It is either default service or service specified in Entry Selection

    iServiceEntryId = aInitialEntry->Entry().Id();

    // We use the file session offered by initial entry.

    // Documentation says that it is expensive to open new file sessions

    // We offer the same session to all classes we create so that everybody

    // is using the same session.

    // In the final version file session is needed for attachment access

    // only, in the preliminary version we have a fake MMSC set up in a

    // directory on disk, and we need the file session to access that.

    iFs = aInitialEntry->FileSession();

    CActiveScheduler::Add( this );

    }

// ---------------------------------------------------------

// Symbian OS default constructor can leave.

// 

// ---------------------------------------------------------

//

void CMmsServerMtm::ConstructL()

    {

    CScheduleBaseServerMtm::ConstructL();

    iScheduleSend = CMmsScheduleSend::NewL( *iServerEntry );

    iMsvSelection = new( ELeave ) CMsvEntrySelection;

    iMmsSettings = CMmsSettings::NewL();

    // don't load settings yet in case someone else is trying

    // to change the settings.

    iMmsHeaders = CMmsHeaders::NewL( iMmsSettings->MmsVersion() );

    iMessageDrive = EDriveC;

    // see if message server knows better

    iMessageDrive = MessageServer::CurrentDriveL( iFs );

    }

// ---------------------------------------------------------

// Factory function

// 

// ---------------------------------------------------------

//

EXPORT_C CMmsServerMtm* CMmsServerMtm::NewL(

    CRegisteredMtmDll& aRegisteredMtmDll,

    CMsvServerEntry* aInitialEntry )

    {

    CleanupStack::PushL( aInitialEntry ); // Take ownership of aInitialEntry

    CMmsServerMtm* self = new( ELeave ) CMmsServerMtm(

        aRegisteredMtmDll, aInitialEntry );

    CleanupStack::Pop( aInitialEntry ); // Entry now safely stored in member

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------

// Destructor

// 

// ---------------------------------------------------------

//

CMmsServerMtm::~CMmsServerMtm()

    {

    // We don't close the file session anymore, as we

    // obtained if from the initial entry, and it is not ours to close...

    Cancel(); // cancel anything that may be pending...

    if ( iRemoteParties )

        {

        iRemoteParties->Reset();

        }

    delete iEntryWrapper;

    delete iRemoteParties;

    delete iReadReport;

    delete iSendOperation;

    delete iReceiveMessage;

    delete iForwardOperation;

    delete iDeleteOperation;

    delete iUpdateMmboxList;

    delete iMsvSelection;

    delete iMmsSettings;

    delete iScheduleSend;

    delete iDecoder;

    delete iMmsHeaders;

    delete iEncodeBuffer;

    delete iMmsLog;

    delete iLogEvent;

    delete iLogViewEvent;

    delete iLogClient;

#ifndef _NO_MMSS_LOGGING_

    TMmsLogger::Log( _L("MMSServer destructor, done") );

#endif

    }

// ---------------------------------------------------------

// CMmsServerMtm::CopyToLocalL

// 

// ---------------------------------------------------------

//

void CMmsServerMtm::CopyToLocalL(

    const CMsvEntrySelection& /*aSelection*/,

    TMsvId /*aDestination*/,

    TRequestStatus& aStatus )

    {

    TRequestStatus* status = &aStatus;

    aStatus = KRequestPending;

    User::RequestComplete( status, KErrNotSupported );

    }

// ---------------------------------------------------------

// CMmsServerMtm::CopyFromLocalL

// 

// ---------------------------------------------------------

//

void CMmsServerMtm::CopyFromLocalL(

    const CMsvEntrySelection& aSelection,

    TMsvId /*aDestination*/,

    TRequestStatus& aStatus )

    {

    // test code: copy from local means send.

    // sent folder is handled separately

    TCommandParameters parameters;

    parameters.iInitialDelay = 0;

    TCommandParametersBuf paramPack( parameters );

    CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;

    CleanupStack::PushL(selection);

    if ( aSelection.Count() > 0 )

        {

        selection->AppendL( aSelection.Back( 0 ), aSelection.Count() );

        }

    StartCommandL( *selection, EMmsScheduledSend, paramPack, aStatus );

    CleanupStack::PopAndDestroy( selection );

    }

// ---------------------------------------------------------

// CMmsServerMtm::CopyWithinServiceL

// 

// ---------------------------------------------------------

//

void CMmsServerMtm::CopyWithinServiceL(

    const CMsvEntrySelection& /*aSelection*/,

    TMsvId /*aDestination*/,

    TRequestStatus& aStatus )

    {

    TRequestStatus* status = &aStatus;

    aStatus = KRequestPending;

    User::RequestComplete( status, KErrNotSupported );

    }

// ---------------------------------------------------------

// CMmsServerMtm::MoveToLocalL

// 

// ---------------------------------------------------------

//

void CMmsServerMtm::MoveToLocalL(

    const CMsvEntrySelection& /*aSelection*/,

    TMsvId /*aDestination*/,

    TRequestStatus& aStatus )

    {

    TRequestStatus* status = &aStatus;

    aStatus = KRequestPending;

    User::RequestComplete( status, KErrNotSupported );

    }

// ---------------------------------------------------------

// CMmsServerMtm::MoveFromLocalL

// 

// ---------------------------------------------------------

//

void CMmsServerMtm::MoveFromLocalL(

    const CMsvEntrySelection& /*aSelection*/,

    TMsvId /*aDestination*/,

    TRequestStatus& aStatus )

    {

    TRequestStatus* status = &aStatus;

    aStatus = KRequestPending;

    User::RequestComplete( status, KErrNotSupported );

    }

// ---------------------------------------------------------

// CMmsServerMtm::MoveWithinServiceL

// 

// ---------------------------------------------------------

//

void CMmsServerMtm::MoveWithinServiceL(

    const CMsvEntrySelection& /*aSelection*/,

    TMsvId /*aDestination*/,

    TRequestStatus& aStatus )

    {

    TRequestStatus* status = &aStatus;

    aStatus = KRequestPending;

    User::RequestComplete( status, KErrNotSupported );

    }

// ---------------------------------------------------------

// CMmsServerMtm::DeleteAllL

// 

// ---------------------------------------------------------

//

void CMmsServerMtm::DeleteAllL(

    const CMsvEntrySelection& aSelection,

    TRequestStatus& aStatus )

    {

    // this is implemented for scheduled send

    // It needs to change entry asynchronously,

    // and needs help on server mtm

    TInt error;

    // we are always called with a selection that has at least one member.

    // we cannot be called with an empty selection (because then the server

    // does not know whom to call)

    if ( aSelection.Count() == 0 )

        {

        User::Leave( KErrNotFound );

        }

    User::LeaveIfError( iServerEntry->SetEntry( aSelection[0] ) );

    User::LeaveIfError( iServerEntry->SetEntry( iServerEntry->Entry().Parent() ) );

    CMsvEntrySelection* sel = aSelection.CopyL();

    error = iServerEntry->DeleteEntries( *sel );

    if ( error == KErrNotFound )

        {

        error = KErrNone; // if not found, deleted already.

        }

    delete sel;

    TRequestStatus* status = &aStatus;

    aStatus = KRequestPending;

    User::RequestComplete( status, error );

    }

// ---------------------------------------------------------

// CMmsServerMtm::CreateL

// 

// ---------------------------------------------------------

//

void CMmsServerMtm::CreateL(

    TMsvEntry /*aNewEntry*/,

    TRequestStatus& aStatus )

    {

    TRequestStatus* status = &aStatus;

    aStatus = KRequestPending;

    User::RequestComplete( status, KErrNotSupported );

    }

// ---------------------------------------------------------

// CMmsServerMtm::ChangeL

// 

// ---------------------------------------------------------

//

void CMmsServerMtm::ChangeL(

    TMsvEntry aNewEntry,

    TRequestStatus& aStatus )

    {

    // this is implemented for scheduled send

    // It needs to change entry asynchronously,

    // and needs help on server mtm

    User::LeaveIfError( iServerEntry->SetEntry( aNewEntry.Id() ));

    User::LeaveIfError( iServerEntry->ChangeEntry( aNewEntry ) );

    TRequestStatus* status = &aStatus;

    aStatus = KRequestPending;

    User::RequestComplete( status, KErrNone );

    }

// ---------------------------------------------------------

// CMmsServerMtm::StartCommandL

// 

// ---------------------------------------------------------

//

void CMmsServerMtm::StartCommandL(

    CMsvEntrySelection& aSelection,

    TInt aCommand,

    const TDesC8& aParameter,

    TRequestStatus& aStatus )

    {

    TInt error = KErrNone;

    TMsvEntry entry; // This will be used a lot later to access the index data

#ifndef _NO_MMSS_LOGGING_

    TMmsLogger::Log( _L("MMSServer Start Command %d"), aCommand );

#endif // _NO_MMSS_LOGGING_

    // log the code for debugging

    LogCommandCode( aCommand );

    // The content of the parameter depends on command.

    // For EMmsDecodePushedMessage it will be TWatcherParametersBuf structure,

    // but the content is currently ignored because it has become impossible

    // to copy the data between processes in the protected environment.

    // For EMmsScheduledSend, EMmsScheduledReceive, and EMmsScheduledReceiveForced

    // it will be TCommandParametersBuf.

    // For EMmsGarbageCollection it will be TMMSGarbageCollectionParametersBuf

    // containing the reason for the garbage collection.

    // For others the parameter will be ignored.

    // The parameter should be unpackaged only when the contents are known.

    // The default service entry is always used.

    // Because of the restriction that only one mtm

    // per service can be open at any time, the scheduling calls

    // cheat and offer the stuff here using local service instead

    // of mms service. As we would like to load our settings

    // anyway, we try to find out the real service.

    if ( iServiceEntryId == KMsvLocalServiceIndexEntryId )

        {

        // we have been cheated

#ifndef _NO_MMSS_LOGGING_

        TMmsLogger::Log( _L("- local service id") );

#endif

        // Get the actual service id from a message entry

        GetRealServiceId( aSelection );

        }

    // free whatever entry we are holding

    iServerEntry->SetEntry( KMsvNullIndexEntryId );

    //

    // Load the service settings.

    // In case call fails, loading will be retried

    //

    TInt loadServiceError = KErrNone;

    TRAP( loadServiceError, LoadSettingsL( aCommand ) );

#ifndef _NO_MMSS_LOGGING_

    if ( loadServiceError != KErrNone ) 

        {

        TMmsLogger::Log( _L("-ERROR loading settings: %d"), loadServiceError );

        }

    else

        {

        TMmsLogger::Log( _L("- settings loaded successfully") );        

        }

#endif

    iCurrentCommand = aCommand;

    if ( aCommand != EMmsRetryServiceLoading )

        {

        iCommand = aCommand;

        iParameter = aParameter;

        iRequestStatus = &aStatus;

        // We remove the service entry from the selection, as we don't need it anymore

        iMsvSelection->Reset();

        if ( aSelection.Count() > 0 )

            {

            iMsvSelection->AppendL( aSelection.Back( 0 ), aSelection.Count() );

            }

        }

    else

        {

        // iRequestStatus was set on an earlier round.

        // EMmsRetryServiceLoading is never the first command

        iCurrentCommand = iCommand; // orginal command was stored here

        }

    // If service loading has failed, we loop through RunL to retry.

    // Actually only EMmsScheduledReceive and EMmsScheduledReceiveForced

    // need this service.

    // Other callers can handle error situations gracefully.

    // We have saved all our parameters.

    // All we have to do now is to change iCurrent command and complete ourselves

    // In order to get to our RunL.

    // RunL will route us to DoRunL where we can continue

    if ( loadServiceError != KErrNone )

        {

        // Actually we should no longer get load service error as the settings

        // are now in central repository, no longer saved into the service entry

        HandleLoadServiceError( loadServiceError );

        // we cannot continue. HandleLoadServiceError has set completion status

        // as required.

        return;

        }

    // If we have loaded the service, we can discard the service entry

    // if it still is in our selection

    if ( iMsvSelection->Count() > 0 && iMsvSelection->At( 0 ) == iServiceEntryId )

        {

        iMsvSelection->Delete( 0 ); 

        }

#ifndef _NO_MMSS_LOGGING_

    // log the parent folder of the selection (needed for debugging)

    LogEntryParent();

#endif

    // we do not move the entries anywhere.

    // it is the client's responsibility to move them to the right place

    // we just make them visible because some applications left invisible

    // entries to outbox.

    if ( iCurrentCommand == EMmsSend ||

        iCurrentCommand == EMmsScheduledSend ||

        iCurrentCommand == EMmsDeleteSchedule )

        {

        RestoreVisibilityAndService();

        }

    //

    // Following switch handles all the different requests

    //

    switch( iCurrentCommand )

        {

        // scheduled operations can only use default service.

        case EMmsScheduledSend:

            if ( iMsvSelection->Count() > 0 )

                {

                iCommand = EMmsSend;

                // This will complete our caller.

                // If no error, task scheduler will complete the caller.

                // If error, the subroutine will complete

                error = ScheduleSelectionL();

#ifndef _NO_MMSS_LOGGING_

                if ( error != KErrNone )

                    {

                    TMmsLogger::Log( _L("MmsServer Schedule send status %d"), error );

                    }

#endif

                }

            else

                {

                // nothing to send - successfully sent nothing

                // ("You must have keen eyes to see nobody coming")

                *iRequestStatus = KRequestPending;

                User::RequestComplete( iRequestStatus, KErrNone );

                }