/*

* Copyright (c) 2006 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:  Implementation of RemoteLock Engine

*

*/

// INCLUDE FILES 

#include <smscmds.h>

#include <smutset.h>

#include <smuthdr.h>

#include <e32property.h>

#include <PSVariables.h>

#include <mtclreg.h> //CClientMtmRegistry

#include <smsclnt.h> //CSmsClientMtm

#include <txtrich.h>

#include <bautils.h> //file system utilities

#include <RemoteLock.rsg>

#ifdef RD_MULTIPLE_DRIVE 

#include <driveinfo.h>

#else

#include <pathinfo.h> 

#endif //RD_MULTIPLE_DRIVE 

#include <coreapplicationuisdomainpskeys.h>

#include <CoreApplicationUIsSDKCRKeys.h>

#include <charconv.h>

#include <ProfileEngineSDKCRKeys.h>

#include <Profile.hrh>

#include <stringresourcereader.h> //CStringResourceReader

#include "RemoteLockTrace.h"

#include "RemoteLock.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

_LIT( KRLockResourceFileName ,"z:\\Resource\\apps\\Remotelock.RSC" );

//Interval of reconnecting to the message server 

const TInt KRLockTimerInterval( 10000000 ); 

const TInt KRLockMaxMemoryCardPasswdLength( 8 );

const TInt KBufLengthInUnicodeCheck = 200;

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

// E32Main()

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

//

GLDEF_C TInt E32Main() 

    {    

    __UHEAP_MARK;

    if ( User::TrapHandler() != NULL )

        {

        User::SetTrapHandler( NULL );

        }

    CTrapCleanup* cleanup = CTrapCleanup::New();

    if ( !cleanup )

        {

        return KErrNone;

        }

    TRAPD( err, ThreadStartL() );

    ( void ) err;

    delete cleanup;

    __UHEAP_MARKEND;

    return err;    

    }

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

// ThreadStartL()

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

//

LOCAL_C TInt ThreadStartL()

    {

    RL_TRACE_PRINT(" [ rl.exe ] Inside ThreadStartL() "); 

    CActiveScheduler *threadScheduler = new CActiveScheduler;

    CleanupStack::PushL( threadScheduler );

    CActiveScheduler::Install( threadScheduler );

    RL_TRACE_PRINT(" [ rl.exe ] Create remotelock object "); 

    CRemoteLock* remoteLock = CRemoteLock::NewL();

    RL_TRACE_PRINT(" [ rl.exe ] Creation of Remotelock is done" );

    CleanupStack::PushL( remoteLock );

    RL_TRACE_PRINT(" Doing Rendezvous..."); 

    // Initialisation complete, now signal the client

    RProcess::Rendezvous(KErrNone);            

    CActiveScheduler::Start();

    CleanupStack::PopAndDestroy( 2 );

    return KErrNone;

    }

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

// CRemoteLock::NewL

// Two-Phased constructor.

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

//

CRemoteLock* CRemoteLock::NewL()

    {

    RL_TRACE_PRINT(" [ rl.exe ] NewL()");

    CRemoteLock* self = new ( ELeave ) CRemoteLock;

    CleanupStack::PushL( self );

    self->ConstructL();  

    CleanupStack::Pop();

    RL_TRACE_PRINT(" [ rl.exe ] exit NewL() ");

    return self;

    }

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

// Destructor

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

CRemoteLock::~CRemoteLock()

    {

    Cancel();

    delete iRemoteLockSetting;

    delete iRemoteLockCode;

    delete iMemoryCardPasswd;

    delete iStoredCode;

    delete iStoredTrimmedCode;

    delete iClientMtmForSending;

    delete iMtmReg;

    delete iMsvSession;

    delete iObserver;

    if ( iProfileNotifyHandler ) 

        {

      iProfileNotifyHandler->StopListening();

      delete iProfileNotifyHandler;

        }

    delete iProfileSession; 

    }

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

// CRemoteLock::HandleSessionEventL

//

// Called by message server when new event occures.

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

//

void CRemoteLock::HandleSessionEventL( 

    TMsvSessionEvent aEvent, 

    TAny* aArg1, 

    TAny* aArg2, 

    TAny* /*aArg3*/  )

    {

    RL_TRACE_PRINT(" [ rl.exe ] HandleSessionEventL() ");  

    switch ( aEvent )

        {            

        // A new entry has been created in the message server

        case EMsvEntriesCreated: 

            {

            RL_TRACE_PRINT(" [ rl.exe ] HandleSessionEventL() 1");  

            if ( !iIsEnabled )

                {

                // Do nothing if remote lock is disabled

                return;

                }

            if ( *( static_cast<TMsvId*>( aArg2 ) ) != 

                KMsvGlobalInBoxIndexEntryId )

                {

                // Doing nothing if not to inbox

                return;

                }

            CMsvEntrySelection* entries =

                static_cast<CMsvEntrySelection*>( aArg1 );

            for ( TInt i = 0; i < entries->Count(); i++ )

                {

                TMsvEntry entryInfo;

                TMsvId serviceId;

                iMsvSession->GetEntry( entries->At( i ), serviceId, entryInfo );

                if ( entryInfo.iMtm != KUidMsgTypeSMS || 

                    entryInfo.iDescription.Length() > KRLockMaxLockCodeLength || 

                    entryInfo.iDescription.Length() == 0)

                    {

                    // Doing nothing if not a SMS, or length not appropriate.

                    return;

                    }

                // For performance reasons, lets first compare the content of 

                // the SMS (taken from the TMsvEntry, containing no extra 

                // spaces) against the saved digest of a trimmed remote lock 

                // code. This way unnecessary access to CMsvEntry is avoided 

                // if these two do not match.

                if ( iRemoteLockSetting->CompareLockCodesL( 

                    entryInfo.iDescription, *iStoredTrimmedCode ) )

                    {

                    CMsvEntry* entry = 

                        iMsvSession->GetEntryL( entries->At( i ) );

                    // The CMsvEntry object must be deleted by the client

                    // when it is no longer required. 

                    CleanupStack::PushL( entry );

                    TRAPD( error, HandleMessageL( entry ) );

                    CleanupStack::PopAndDestroy( 1 ); // entry

                    delete iRemoteLockCode;

                    iRemoteLockCode = NULL;

                    User::LeaveIfError( error );

                    } // if

                } // for

            break;

            } // case

        // When message server is closed and server terminated

        case EMsvCloseSession:

        case EMsvServerFailedToStart:

        case EMsvServerTerminated:

            {

            RL_TRACE_PRINT(" [ rl.exe ] HandleSessionEventL() 2");  

            // When server is terminated remote lock will

            // try to reconnect it in every 10 seconds.

            After( KRLockTimerInterval );

            break;

            }

        default:

            break;

        }

    RL_TRACE_PRINT(" [ rl.exe ] exit HandleSessionEventL() ");

    }

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

// CRemoteLock::HandleRemoteLockNotifyL

// Function is called when remote lock setting is changed by client

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

//

void CRemoteLock::HandleRemoteLockNotifyL()

    {

    RL_TRACE_PRINT(" [ rl.exe ] HandleNotify() ");

    CheckSettingsL();

    RL_TRACE_PRINT(" [ rl.exe ] exit HandleNotify() ")

    }

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

// CRemoteLock::CRemoteLock

// default constructor

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

CRemoteLock::CRemoteLock() : CTimer( CActive::EPriorityStandard )

    {

    iRemoteLockCode = NULL;

    iMemoryCardPasswd = NULL;

    iStoredCode = NULL;

    iStoredTrimmedCode = NULL;

    iClientMtmForSending = NULL;

    iMtmReg = NULL;

    iRemoteLockSetting = NULL;

    iMsvSession = NULL;

    iIsEnabled = EFalse;

    iLockedByRL = EFalse; 

    iMemoryCardLockedByRL = EFalse;

    iSubscribeProfile = EFalse;

    iProfileSession = NULL;

    iObserver = NULL;

    iProfileNotifyHandler = NULL;   

    }

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

// CRemoteLock::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CRemoteLock::ConstructL()

    {    

    RL_TRACE_PRINT(" [ Rl.exe ] ConstructL()"); 

    CTimer::ConstructL();

    iRemoteLockSetting = CRemoteLockSettings::NewL( this ); 

    iRemoteLockSetting->RemoteLockNotifyL( ETrue );

    CheckSettingsL(); 

    // Add active object into active scheduler

    CActiveScheduler::Add( this );

    RL_TRACE_PRINT(" [ rl.exe ] exit ConstructL() ");

    }

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

// CRemoteLock::HandleMessageL()

//

// Handles the message: checks if it really is remote lock message, and acts

// accordingly.

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

//

void CRemoteLock::HandleMessageL( CMsvEntry* aEntry )

    {

    RL_TRACE_PRINT(" [ rl.exe ] HandleMessageL() ");

    delete iRemoteLockCode;

    iRemoteLockCode = NULL;

    TMsvEntry entryInfo = aEntry->Entry();

    if ( !iMtmReg )

        {

        iMtmReg = CClientMtmRegistry::NewL( *iMsvSession );

        }

    // Loops 100 times to ensure the clientMtm is correctly created

    CBaseMtm* clientMtm = NULL;

    TInt error = 0;

    TInt i;

    for ( i = 0; i < 100; i++ )

        {

        TRAP( error, clientMtm = iMtmReg->NewMtmL( entryInfo.iMtm ));

        if ( error == KErrNone )

            {

            break;

            }

        } 

    RL_TRACE_PRINT_NUM("[rl.exe] HandleMessageL() error after NewMTmL = %d", error );

    User::LeaveIfError( error );

    CleanupStack::PushL( clientMtm );        

    clientMtm->SwitchCurrentEntryL( entryInfo.Id() );

    RL_TRACE_PRINT(" [ rl.exe ] HandleMessageL() after switch Current EntryL");

    CSmsClientMtm* smsClientMTM = STATIC_CAST( CSmsClientMtm*, clientMtm );

    // Change from 100 to 20. When the message storage is memory card. 

    // LoadMessageL() function return -21 when loading the message.

    // It might be caused by slow operation, so we add 0.05 seconds pending 

    // in each loop.

    // @ check why loading operation is slow!

    for ( i = 0; i < 20; i++ )

        {   

        RL_TRACE_PRINT_NUM("[rl.exe] HandleMessageL() error load message1 = %d", error );

        // Loops 100 times to ensure the LoadMessageL() succeedes

        TRAP( error, smsClientMTM->LoadMessageL() );

        RL_TRACE_PRINT_NUM("[rl.exe] HandleMessageL() error load message2 = %d", error );

        if ( error == KErrNone )

            {

            break;

            }

        const TInt KDelay = 50000; // 0.05s

        User::After( KDelay );

        }

    RL_TRACE_PRINT_NUM("[rl.exe] HandleMessageL() error after LoadMessageL = %d", error );

    User::LeaveIfError( error );        

    CRichText& mtmBody = smsClientMTM->Body();                            

    // Let's then use the real content of the SMS (taken from 

    // the message body) and compare that against the 

    // saved digest of a complete (not trimmed) remote lock 

    // code. This ensures that remote locking happens only

    // if the SMS is exactly the same as what the user has 

    // specified.

    iRemoteLockCode = HBufC::NewL( mtmBody.DocumentLength() );

    TPtr smsTextPtr = iRemoteLockCode->Des();

    smsTextPtr.Copy( mtmBody.Read( 0, mtmBody.DocumentLength() ) );

    // The following code is to get the current state

    // of manuallock. If manuallock state is off, that means

    // the owner has unlocked the phone or the phone has

    // never been locked by both remote lock and auto lock.

    RL_TRACE_PRINT(" [ rl.exe ] HandleMessageL() Pub&Sub Get autoLState");    

    TInt autoLState;

    RProperty property;

    #ifndef RD_STARTUP_CHANGE    

    User::LeaveIfError( property.Attach( KUidSystemCategory, KPSUidAutolockStatusValue ));

    #else

    User::LeaveIfError( property.Attach( KPSUidCoreApplicationUIs, KCoreAppUIsAutolockStatus ));

    #endif //RD_STARTUP_CHANGE

    property.Get( autoLState );

    #ifndef RD_STARTUP_CHANGE

    if ( autoLState == EPSAutolockOff ) 

    #else

    if ( autoLState == EAutolockOff ) 

    #endif //RD_STARTUP_CHANGE      

      {  

      //Assign iLockedByRL to EFalse to indicate that

      //the phone is not locked by Remote lock, the 

      //reply SMS should be sent if correct remote lock

      //code is received.

      iLockedByRL = EFalse;

      }

    property.Close();

    // If the phone receives correct lock code, the phone

    // will be locked eventhough it may have been locked by

    // auto lock.

    if ( VerifyAndLockL() ) 

        {

        RL_TRACE_PRINT(" [ rl.exe ] HandleMessageL() After VerifyAndLockL() ");

        // Sets remote lock sms as read

        entryInfo.SetVisible( ETrue );

        entryInfo.SetUnread( EFalse );

        entryInfo.SetNew( EFalse );

        entryInfo.SetInPreparation( EFalse );

        entryInfo.SetReadOnly( ETrue );

        aEntry->ChangeL( entryInfo );

        // Locks MemoryCard drive.

        iStateMemoryCard = SetMemoryCardPasswdL( EFalse );

        if ( iClientMtmForSending )

            {

            // Previous reply sending is still in progress, let's not start 

            // sending new one.

            User::Leave( KErrNone );

            } 

        // The value of iLockedByRL is checked before sending SMS

        // to make sure if the phone has been locked by remote 

        // lock. By doing this, it is able to avoid the threat where 

        // malware tries to use remote lock to keep on sending SMS.

        if ( !iLockedByRL )

            { 

            RL_TRACE_PRINT(" [ rl.exe ] HandleMessageL() Send re-SMS ");

            // Replies sms

            iLockedByRL = ETrue;

            CSmsHeader& header = smsClientMTM->SmsHeader();

            HBufC* recipientAddress = header.FromAddress().AllocLC();

            TBool initialSendMessage = EFalse;

            TRAP( error, initialSendMessage = InitialSendMessageL() );

            if ( error != KErrNone )

                {

                delete iClientMtmForSending;

                iClientMtmForSending = NULL;

                User::Leave( error );

                }

            RL_TRACE_PRINT(" [ rl.exe ] HandleMessageL() Check recipientaddresslenght ");

            if ( recipientAddress->Length() > 0 && initialSendMessage )

                {

                RL_TRACE_PRINT(" [ rl.exe ] HandleMessageL() before call sendMEssage ");

                TRAP( error, SendMessageL( *recipientAddress ) );

                if ( error != KErrNone )

                    {

                    RL_TRACE_PRINT(" [ rl.exe ] HandleMessageL() error occurs ");

                    delete iClientMtmForSending;

                    iClientMtmForSending = NULL;

                    User::Leave( error );

                    }

                }

            delete iClientMtmForSending;

            iClientMtmForSending = NULL;

            CleanupStack::PopAndDestroy( 1 ); // recipientAddress

            }

        CleanupStack::PopAndDestroy( 1 ); // clientMtm    

        }

    else

        {

        CleanupStack::PopAndDestroy( 1 ); // clientMtm

        }

    RL_TRACE_PRINT(" [ rl.exe ] exit HandleMessageL() ");

    }

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

// CRemoteLock::VerifyAndLockL()

//