/*

* 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:  Message store server implementation.

*

*/

// ========

// INCLUDES

// ========

#include <e32svr.h>

#include <bautils.h>

#include <driveinfo.h>

#include <s32file.h>

#include "MsgStoreTypes.h"

#include "MsgStorePropertyKeys.h"

#include "EmailStoreUids.hrh"

#include "MessageStoreServer.h"

#include "MessageStoreSession.h"

#include "ContainerStore.h"

#include "PropertiesSerializer.h"

#include "ShutdownServer.h"

//<cmail>

#include "ImsPointsecMonitor.h"

#include "ImsPointsecObserver.h"

#include "emailstorepskeys.h" // Support for on-the-fly upgrade

//</cmail>

// =========

// CONSTANTS

// =========

_LIT8( KNullDescriptor8, "" );

// To support biggest free drive, we have to get rid of hard-coded C: drive

//const TDriveNumber KDbDriveNumber = EDriveC;

_LIT( KDbFilename, "message_store.db" );

const TMsgStoreCounts KInitialCounts = {0, 0};

// This should be more than sufficient.

const TUint KQuickPropertiesMaxLength = 1024;

const TUint KCommandLineSize = 30;

_LIT( KUninstallParameter, "IMS_UNINSTALL" );

_LIT( KImsUninstaller, "IMS Uninstaller" );

_LIT( KUpgradeDetectionFile, "c:\\System\\EsIms\\canary.txt" );

_LIT16( KDriveToUseFile, "db_drive.cfg" );

//_LIT( KMsgStorePrivateDir, "c:\\Private\\200029e1\\" );

//const TChar KColon(':');

// SID list

// This is the list of secure Ids that are allowed to use the message store.  This list must be terminated

// with zero.

/*

const TUint32 KAllowedSecureIds[] =

        {

        0x200029E4,  // bridge process

        0x10274F51,  // IMS process

        0x1000EAEA,  // test automation executable

        0x20009C56,  // another automation test executable

        0x200029E6,  // message store exerciser

        0x20003C0A,

        0x20003C19,

        0x101FD64C,  // Idle server (for active idle plugin)

        0xA0002879,  // Native Composer Screen

        0x101F9A02,	 // DMHostServer1

		0x101F9A03,	 // DMHostServer2

		0x101F9A04,	 // DMHostServer3

		0x101F9A05,	 // DMHostServer4

        // UNIT TESTERS

#ifdef _DEBUG

        0x043ECF25,  // message store unit tester

        0x200029EC,

        0x200029EE,

        0x200029F0,

        0x200029F1,

        0x200029F2,

        0x200029F3,

        0x20004205,

#endif

        0

        }; // end KAllowedSecureIds

*/

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

// DoUninstallL

// Remove the files in private directory.

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

static void DoUninstallL()

    {

	RFs fs;

    if( fs.Connect() == KErrNone )

        {

        if( ! BaflUtils::FileExists( fs, KUpgradeDetectionFile ) )

            {

        	// This is a full uninstallation because the upgrade detection file

        	// does not exist !!

            TFileName privatePath;

            fs.PrivatePath( privatePath );

            CFileMan* fm = CFileMan::NewL( fs );

            CleanupStack::PushL( fm );

            TInt err = fm->RmDir( privatePath );

            CleanupStack::PopAndDestroy( fm );

            } // end if

        fs.Close();

        } // end if

}

// ==========================================================================

// Server startup code

// ==========================================================================

// Perform all server initialisation, in particular creation of the

// scheduler and server and then run the scheduler

//

static void RunServerL( TBool aThreadRendezvous )

  {

  // naming the server thread after the server helps to debug panics

  User::LeaveIfError( User::RenameThread( KMsgStoreServerName ) );

  // create and install the active scheduler we need

  CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();

  CleanupStack::PushL( scheduler );

  CActiveScheduler::Install( scheduler );

  // Examine the command line parameters, to determine whether to

  // run the server as normal, or to perform the uninstall operation

  // and exit.

  TBuf<KCommandLineSize> commandLine;

  if( User::CommandLineLength() > 0 && User::CommandLineLength() < KCommandLineSize )

      {        

      User::CommandLine( commandLine );

      }

  // If the executable was launched with the "IMS_UNINSTALL" parameter then do not

  // launch the server, but just performs necessary uninstallation tasks.

  if( commandLine.Length() > 0 && commandLine.Compare( KUninstallParameter ) == 0 )

      {

	  // naming the server thread after the server helps to debug panics

      User::RenameThread( KImsUninstaller );

      // This is an uninstall.  Do not run the server.

      DoUninstallL();

      }

  else

  {

	  // Create the upgrade detection file, if necessary.

      RFs fs;

      if( (fs.Connect() == KErrNone) && !BaflUtils::FileExists( fs, KUpgradeDetectionFile ) )

      {            

    	  TRAP_IGNORE( /*result,*/ BaflUtils::EnsurePathExistsL( fs, KUpgradeDetectionFile ) );

    	  RFile file;

    	  /*result =*/ file.Create( fs, KUpgradeDetectionFile, EFileWrite );

    	  file.Close();

    	  fs.Close();

      } // end if

	  // create the server (leave it on the cleanup stack)

	  CMessageStoreServer* server = CMessageStoreServer::NewLC();

	  // Initialisation complete, now signal the client

	  if( aThreadRendezvous )

	    {    

	    RThread::Rendezvous( KErrNone );

	    }

	  else

	    {

	    RProcess::Rendezvous( KErrNone );    

	    }

	  // Ready to run

	  // Start wait loop, will return when server is shutdown

	  CActiveScheduler::Start();

	  // Cleanup the server

	  CleanupStack::PopAndDestroy( server );

  }

  // Cleanup scheduler after shutdown

  CleanupStack::PopAndDestroy( scheduler );

  __LOG_LEAKED_OBJECTS

  } // end RunServerL

// ==========================================================================

// Server thread main function

// ==========================================================================

EXPORT_C TInt MessageStoreServerThreadFunction( TAny* aParams )

  {

  __UHEAP_MARK;

  CTrapCleanup* cleanup = CTrapCleanup::New();

  TInt ret = KErrNoMemory;

  if( cleanup )

    {

	// At one time, Message Store runs as a dll with Bridge process, but it is

	// decided that MsgStore running as a seperate process in case Bridge process

	// crashes makes more sense

	// (aParams == NULL) is basically to differentiate dll or exe

    TRAP( ret, RunServerL( (aParams == NULL) ) );

    delete cleanup;

    }

  __UHEAP_MARKEND;

  return ret;

  } // end MessageStoreServerThreadFunction

// ==========================================================================

// RMessagePtr2::Panic() also completes the message. This is:

// (a) important for efficient cleanup within the kernel

// (b) a problem if the message is completed a second time

// ==========================================================================

void PanicClient(const RMessagePtr2& aMessage, TMessageStorePanic aPanic)

  {

  _LIT( KPanic, "MessageStoreServer" );

  aMessage.Panic( KPanic, aPanic);

  } // end PanicClient

// ======================

// METHOD IMPLEMENTATIONS

// ======================

// ==========================================================================

// FUNCTION: NewLC

// ==========================================================================

CMessageStoreServer* CMessageStoreServer::NewLC()

  {

  CMessageStoreServer* self = new (ELeave) CMessageStoreServer();

  CleanupStack::PushL( self );

  self->ConstructL();

  return self;

  } // end NewLC

// ==========================================================================

// FUNCTION: Constructor

// ==========================================================================

CMessageStoreServer::CMessageStoreServer()

  :CPolicyServer( 0, KMessageStorePolicy, ESharableSessions )

  {

  __LOG_CONSTRUCT( "msg", "CMessageStoreServer" )

  iLockedByBackupRestore = EFalse;

  iLockedByPointSec = EFalse;

  iLockedByDriveMonitor = EFalse;

  } // end constructor

// ==========================================================================

// FUNCTION: ConstructL

// 2nd phase construction - ensure the timer and server objects are running

// ==========================================================================

void CMessageStoreServer::ConstructL()

    {

    __LOG_ENTER( "ConstructL" )

	// Log filename for this process.

	RProcess thisProcess;

    __LOG_BLOCK( TFileName processName = thisProcess.FileName(); )

	__LOG_WRITE_FORMAT1_INFO( "Filename: %S", &processName );

	thisProcess.Close();

    StartL( KMsgStoreServerName );

    iShutdown = CShutdownServer::NewL();

    //starts the PointsecMonitor

    iPointsecMonitor = CImsPointsecMonitor::NewL( *this );

    //must check if PointSec has locked the system or not,

    //only create the container store if PointSec is NOT locked.

    // This will be used to monitor the drive where message store db is located.

    iStoreDriveMonitor = CStoreDriveMonitor::NewL( *this );

    if ( iPointsecMonitor->IsServiceAllowed() )

        {

        //PointSec does NOT have the device locked, so we can start initialization

        // Construct an instance of the container store to be shared across all message server sessions.

        CreateContainerStoreL();

        // Create the inbox/outbox/draft/sent folders, if needed.

        CreatePredefinedFoldersIfNeededL();

        }

    else

        {

        __LOG_WRITE_INFO("PointSec has system locked! Database NOT initialized!")

        //PointSec has the device locked, DO NOT initialize the database

        iLockedByPointSec = ETrue;

        }

    // Register to receive backup/restore notifications.

    iBackupRestoreNotifier = CBackupRestoreNotifier::NewL( *this );

    // Ensure that the server still exits even if the 1st client fails to connect.

    // This time isn't started until after the code above, so that the shutdown timer isn't

    // running while the database is possibly being created or wiped.

//    iShutdown->Start();

    // Support for on-the-fly upgrade

    // Watch for KProperty_EmailStore_Upgrade property. When set to our UID3/SECUREID,

    // then, this server should stop.

    RProcess process;

	CleanupClosePushL( process ); //+process

    TSecurityPolicy readPolicy( ECapabilityReadDeviceData );

    TSecurityPolicy writePolicy( ECapabilityWriteDeviceData );

    iUpgradePropertyWatcher = CPSIntPropertyWatcher::NewL( this );

    iUpgradePropertyWatcher->StartL( KEmailStoreUpgradePSCategory,

                                     KProperty_EmailStore_Upgrade,

                                     process.SecureId(),

                                     /*ETrue*/EFalse,

                                     readPolicy,

                                     writePolicy ); 

    CleanupStack::PopAndDestroy(); //-process

    __LOG_EXIT

    } // end ConstructL

// ==========================================================================

// FUNCTION: Destructor

// ==========================================================================

CMessageStoreServer::~CMessageStoreServer()

  {

  delete iUpgradePropertyWatcher;

  delete iStoreDriveMonitor;

  delete iShutdown;

  delete iMessageStore;

  iMessageStore = NULL;

  delete iBackupRestoreNotifier;

  delete iPointsecMonitor;

  iSessions.ResetAndDestroy();

  __LOG_DESTRUCT

  } // end destructor

// ==========================================================================

// FUNCTION: NewSessionL

// Create a new client session.

// ==========================================================================

CSession2* CMessageStoreServer::NewSessionL(const TVersion& aVersion, const RMessage2&) const

    {

    __LOG_ENTER( "NewSessionL" )

    if( aVersion.iMajor != KMsgStoreMajorVersion ||

        aVersion.iMinor != KMsgStoreMinorVersion ||

        aVersion.iBuild != KMsgStoreBuild )

        {

        __LOG_WRITE_ERROR( "Session version mismatch" )

        User::Leave( KErrNotSupported );

        } // end if

    // Construct a new session, passing it a pointer to the server object.  This function

    // is const, so the const-ness must be cast away from the this pointer.

    CSession2* returnValue = new (ELeave) CMessageStoreSession( *const_cast<CMessageStoreServer*>(this) );

    __LOG_EXIT

    return returnValue;

    } // end NewSessionL

// ==========================================================================

// FUNCTION: AddSession

// A new session is being created

// Cancel the shutdown timer if it was running

// ==========================================================================

void CMessageStoreServer::AddSession( CMessageStoreSession* aSession )

  {

  __LOG_ENTER( "AddSession" )

  iSessions.Append( aSession );

  // A sesssion was added, so the shutdown timer can be stopped.

//  iShutdown->Stop();

  __LOG_EXIT

  } // end AddSession

// ==========================================================================

// FUNCTION: DropSession

// A session is being destroyed

// Start the shutdown timer if it is the last session.

// ==========================================================================

void CMessageStoreServer::DropSession( CMessageStoreSession* aSession )

    {

    __LOG_ENTER( "DropSession" )

    // Find the current session in the list of sessions.

    TInt index = iSessions.Find( aSession );

    if( index == KErrNotFound )

        {

        // This should never happen.

        __LOG_WRITE_ERROR( "ERROR! SESSION NOT FOUND!" );

        }

    else

        {

        // Remove the session from the list of sessions.

        iSessions.Remove( index );

        } // end if

    // If this was the last session to this server then start the shutdown timer with no delay.  This

    // will immediately shut down the server, unless the container store is currently performing

    // background operations.

//    if( iSessions.Count() == 0 )

//        {

//        iShutdown->Start( 0 );

//        } // end if

    __LOG_EXIT

    } // end DropSession

// ==========================================================================

// FUNCTION: CreateContainerStoreL

// ==========================================================================

void CMessageStoreServer::CreateContainerStoreL()

    {

    TDriveNumber drive( EDriveC );

    if ( GetDriveL( drive ) == KErrNotFound )

        {

        FindBiggestCapacityDriveL( drive );

        }

    //set again the drive to be monitored in case is different than previous

    iStoreDriveMonitor->SetDriveL( drive );

    if ( iStoreDriveMonitor->IsDrivePresent() )

        {

    iMessageStore = CContainerStore::NewL( KDbFilename,

                                           drive,

                                           *this,

                                           *iShutdown,

                                           Priority() - 1);  // lower than server

        }

    else

        {

        iLockedByDriveMonitor = ETrue;

        }

    // monitor the message store drive

    iStoreDriveMonitor->WaitForChange();

    } // end CreateContainerStoreL

// ==========================================================================

// FUNCTION: MessageStoreL

// ==========================================================================

CContainerStore& CMessageStoreServer::MessageStoreL()

  {

  if( !iMessageStore )

    {

    // A backup or restore is in progress.

    // Or PointSec has locked the device.

    User::Leave( KErrInUse );

    } // end if

  return *iMessageStore;

  } // end MessageStoreL

// ==========================================================================

// FUNCTION: CreatePredefinedFoldersIfNeededL

// ==========================================================================

void CMessageStoreServer::CreatePredefinedFoldersIfNeededL()

  {

  __LOG_ENTER( "CreatePredefinedFoldersIfNeededL" )

  // Create predefined folders.

  if ( iMessageStore )

      {

      iMessageStore->CreatePredefinedContainerIfNeededL(

              KMsgStoreRootMailBoxId, EMsgStoreMailBoxBits, KMsgStoreInvalidId,

              KNullDescriptor8 );

      }

  __LOG_EXIT

  } // end CreatePredefinedFoldersIfNeededL

// ==========================================================================

// FUNCTION: QuickPropertiesAndCountsL

// This function traverses the properties, looking for the "quick" properties.

// This is not part of the container store in order to keep the container

// store more generic, without any message-specific logic.

// ==========================================================================

void CMessageStoreServer::QuickPropertiesAndCountsL( TContainerId  aType,

													 const TDesC8& aProperties,

													 RBuf8&        aQuickProperties,

													 TDes8&        aCounts ) const

  {

  __LOG_ENTER( "QuickPropertiesAndCountsL" )

  TMsgStoreCounts counts;

  counts.iMessagesCount = 0;

  counts.iUnreadCount   = 0;

    // Quick properties and message counts are for message containers only.

  if( (aType & EMsgStoreContainerMask) == EMsgStoreMessageBits )

    {

    // This container should increment the iMessageCount field of the parent container's child counts.

    counts.iMessagesCount = 1;

    // Iterator through the properties, looking for the quick properties.

    TPropertiesDeserializer propertiesDeserializer( aProperties );

    TPropertiesSerializer   quickPropertiesSerializer( aQuickProperties );

    TBool moreProperties = propertiesDeserializer.First();