/*

* Copyright (c) 2006-2009 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:  Monitors file creations, modifications and deletions.*

*/

#include <f32pluginutils.h>

#include "mdsfileserverplugin.h"

#include "harvesterlog.h"

#include "mdsutils.h"

_LIT( KMdsFileServerPlugin, "MdsFileServerPlugin" );

/* Server name */

_LIT( KHarvesterServerName, "HarvesterServer" );

const TInt KCleanQueueTreshoald( 1000 );

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

// CMdsFileServerPlugin implementation

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

//

CMdsFileServerPlugin::CMdsFileServerPlugin()

: iFormatOldMediaId( 0 ), iFormatDriveNumber( -1 ), iConnectionCount( 0 )

	{

	WRITELOG( "CMdsFileServerPlugin::CMdsFileServerPlugin()" );

	}

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

// 

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

//

CMdsFileServerPlugin::~CMdsFileServerPlugin()

    {

    WRITELOG( "CMdsFileServerPlugin::~CMdsFileServerPlugin()" );

    TRAP_IGNORE( DisableL() );

    iFsSession.Close();

    iCreatedFiles.ResetAndDestroy();

    iCreatedFiles.Close();

    iPaths.ResetAndDestroy();

    iPaths.Close();

    iIgnorePaths.ResetAndDestroy();

    iIgnorePaths.Close();

    iQueue.ResetAndDestroy();

    iQueue.Close();

    }

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

// 

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

//

CMdsFileServerPlugin* CMdsFileServerPlugin::NewL()

    {

    WRITELOG( "CMdsFileServerPlugin::NewL()" );

    return new (ELeave) CMdsFileServerPlugin;

    }

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

// 

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

//

void CMdsFileServerPlugin::InitialiseL()

    {

    WRITELOG( "CMdsFileServerPlugin::InitializeL()" );

    User::LeaveIfError( iFsSession.Connect() );

    }

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

// 

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

//

void CMdsFileServerPlugin::EnableL()

    {

    WRITELOG( "CMdsFileServerPlugin::EnableL()" );

    User::LeaveIfError( RegisterIntercept(EFsFileCreate, EPostIntercept) );

    User::LeaveIfError( RegisterIntercept(EFsFileRename, EPostIntercept) );

    User::LeaveIfError( RegisterIntercept(EFsRename, EPostIntercept) );

    User::LeaveIfError( RegisterIntercept(EFsDelete, EPostIntercept) );

    User::LeaveIfError( RegisterIntercept(EFsFileReplace, EPostIntercept) );

    User::LeaveIfError( RegisterIntercept(EFsReplace, EPostIntercept) );

    User::LeaveIfError( RegisterIntercept(EFsFileSetModified, EPostIntercept) );

    User::LeaveIfError( RegisterIntercept(EFsFileSubClose, EPostIntercept) );

    User::LeaveIfError( RegisterIntercept(EFsSetEntry, EPostIntercept) );

	// format events

	User::LeaveIfError( RegisterIntercept(EFsFormatSubClose, EPostIntercept) );

	User::LeaveIfError( RegisterIntercept(EFsFormatOpen, EPreIntercept) );

#ifdef _DEBUG_EVENTS

    RegisterDebugEventsL();

#endif

    }

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

// 

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

//

void CMdsFileServerPlugin::DisableL()

    {

    WRITELOG( "CMdsFileServerPlugin::DisableL()" );

    User::LeaveIfError( UnregisterIntercept(EFsFileCreate, EPrePostIntercept) );

    User::LeaveIfError( UnregisterIntercept(EFsFileRename, EPrePostIntercept) );

    User::LeaveIfError( UnregisterIntercept(EFsRename, EPrePostIntercept) );

    User::LeaveIfError( UnregisterIntercept(EFsDelete, EPrePostIntercept) );

    User::LeaveIfError( UnregisterIntercept(EFsFileReplace, EPrePostIntercept) );

    User::LeaveIfError( UnregisterIntercept(EFsReplace, EPrePostIntercept) );

    User::LeaveIfError( UnregisterIntercept(EFsFileSetModified, EPrePostIntercept) );

    User::LeaveIfError( UnregisterIntercept(EFsFileSubClose, EPrePostIntercept) );

    User::LeaveIfError( UnregisterIntercept(EFsSetEntry, EPrePostIntercept) );

	// format events

	User::LeaveIfError( UnregisterIntercept(EFsFormatSubClose, EPostIntercept) );

	User::LeaveIfError( UnregisterIntercept(EFsFormatOpen, EPreIntercept) );

#ifdef _DEBUG_EVENTS

    UnregisterDebugEventsL();

#endif

    }

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

// AddConnection

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

//

void CMdsFileServerPlugin::AddConnection()

    {

    WRITELOG( "CMdsFileServerPlugin::AddConnection()" );

    ++iConnectionCount;

    iPendingEvents = 0;

    }

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

// RemoveConnection

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

//

void CMdsFileServerPlugin::RemoveConnection()

    {

    WRITELOG( "CMdsFileServerPlugin::RemoveConnection()" );

    --iConnectionCount;

    // remove notification request if this was last connection

    if( iConnectionCount <= 0 )

    	{

    	WRITELOG( "CMdsFileServerPlugin::RemoveConnection() last connection" );

    	iNotification = NULL;

    	iPendingEvents = 0;

    	iQueue.ResetAndDestroy();

    	iQueue.Compress();

    	}

    }

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

// 

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

//

TInt CMdsFileServerPlugin::DoRequestL( TFsPluginRequest& aRequest )

	{

	// ignore event if there is no any client listening

	if( iConnectionCount <= 0 )

		{

		WRITELOG( "CMdsFileServerPlugin::DoRequestL() - no clients -> ignore event" );

		return KErrNone;

		}

	TInt function = aRequest.Function();

	iFileName.Zero();

#ifdef _DEBUG_EVENTS

    PrintDebugEvents( function );

#endif

    if ( function == EFsFileSubClose && iCreatedFiles.Count() == 0 )

        {

#ifdef _DEBUG_EVENTS

        if( GetName( &aRequest, iFileName ) == KErrNone && iFileName.Length() <= KMaxFileName )

            {

            WRITELOG1("Dropping subclose %S",&iFileName);

            }

#endif

        return KErrNone;

        }

    const TBool formatFunction = function == EFsFormatOpen || function == EFsFormatSubClose;

    iNewFileName.Zero();

    WRITELOG1( "----- CMdsFileServerPlugin::DoRequestL() - plugin function: %d -----", function );

	if ( !formatFunction )

		{

		if( GetName( &aRequest, iFileName ) != KErrNone || iFileName.Length() > KMaxFileName )

		    {

		    return KErrNone;

		    }

		else

		    {

		    WRITELOG1( "CMdsFileServerPlugin::DoRequestL() - fileName: %S", &iFileName );

		    }

		}

    // get process id

	TUid processId = { 0 };

	processId = aRequest.Message().SecureId();

	TBool isDirectory = EFalse;

    // if rename, check destination path

    if ( function == EFsRename  || function == EFsFileRename || 

    	 function == EFsReplace || function == EFsFileReplace  ||

    	 function == EFsSetEntry )

        {

        const TInt newNameErr = GetNewName( &aRequest, iNewFileName );

        if ( iNewFileName.Length() > KMaxFileName )

        	{

        	return KErrNone;

        	}

        WRITELOG2( "CMdsFileServerPlugin::DoRequestL() - newFileName: '%S' %d", &iNewFileName, newNameErr );

        if ( newNameErr == KErrNone )

            {

            if ( !CheckPath(iNewFileName) )

                {

                WRITELOG( "CMdsFileServerPlugin::DoRequestL() - new path not supported" );

                if( !CheckPath(iFileName) )

                    {

                    WRITELOG( "CMdsFileServerPlugin::DoRequestL() - old path not supported" );

                    WRITELOG( "CMdsFileServerPlugin::DoRequestL() - ignore file" );

                    return KErrNone;

                    }

                // file moved to ignored path, delete from db

                function = EFsDelete;

                }

            if ( !CheckAttribs( iNewFileName, isDirectory ) )

                {

                WRITELOG( "CMdsFileServerPlugin::DoRequestL() - new path attribute check failed" );

                if( !CheckAttribs(iFileName, isDirectory) )

                    {

                    WRITELOG( "CMdsFileServerPlugin::DoRequestL() - old path attribute check failed" );

                    WRITELOG( "CMdsFileServerPlugin::DoRequestL() - ignore file" );

                    return KErrNone;

                    }

                // file set to hidden, delete from db

                function = EFsDelete;

                }

            }

        else

        	{

            if ( !CheckPath(iFileName) )

                {

                WRITELOG( "CMdsFileServerPlugin::DoRequestL() - path not supported" );

                return KErrNone;

                }

            if ( !CheckAttribs(iFileName, isDirectory) )

                {

                WRITELOG( "CMdsFileServerPlugin::DoRequestL() - attribute check failed" );

                return KErrNone;

                }

        	}

        }

    else if ( !formatFunction )

        {

        if ( !CheckPath(iFileName) )

            {

            WRITELOG( "CMdsFileServerPlugin::DoRequestL() - path not supported" );

            return KErrNone;

            }

        if ( !CheckAttribs( iFileName, isDirectory ) )

            {

            WRITELOG( "CMdsFileServerPlugin::DoRequestL() - attribute check failed" );

            return KErrNone;

            }

        }

    TInt fileEventType = EMdsFileUnknown;

    TInt drvNumber = aRequest.DriveNumber();

    TVolumeInfo volInfo;

    WRITELOG1( "CMdsFileServerPlugin::DoRequestL() - drive number: %d", drvNumber );

    TInt err( KErrNone );

    switch( function )

        {

        case EFsFileCreate:

            {

#ifdef _DEBUG            

            if (function == EFsFileCreate)            

            	WRITELOG( "CMdsFileServerPlugin::DoRequestL() - EFsFileCreate" );

            if (function == EFsFileReplace)

            	WRITELOG( "CMdsFileServerPlugin::DoRequestL() - EFsFileReplace" );

#endif            

            iCreatedFiles.Append( iFileName.AllocL() );

            User::LeaveIfError( UnregisterIntercept(EFsFileSetModified, EPostIntercept) );

            return KErrNone;

            }

        case EFsFileSubClose:

            {

            WRITELOG( "CMdsFileServerPlugin::DoRequestL() - EFsFileSubClose" );

            TBool found = EFalse;

           	for ( TInt i = iCreatedFiles.Count(); --i >= 0; )

            		{

           			if ( MdsUtils::Compare( iFileName, *(iCreatedFiles[i]) ) == 0 )

            		  {

            			fileEventType = EMdsFileCreated;

            			delete iCreatedFiles[i];

            			iCreatedFiles.Remove( i );

						//Have to check whether file has been hidden

						if ( CheckAttribs( iFileName, isDirectory ) )

							{

							found = ETrue;

							}

            			User::LeaveIfError( RegisterIntercept(EFsFileSetModified, EPostIntercept) );

            			}

            		}

           	if( iCreatedFiles.Count() == 0 )

				{

				iCreatedFiles.GranularCompress();

				}

            if ( !found )

                {

                return KErrNone;

                }

            }

            break;

        case EFsRename:

            {

            WRITELOG1( "CMdsFileServerPlugin::DoRequestL() - EFsRename, new file: %S", &iNewFileName );

            if ( isDirectory )

            	{

				WRITELOG( "CMdsFileServerPlugin::DoRequestL() - it is directory!" );			

				fileEventType = EMdsDirRenamed;

				AddBackslashIfNeeded( iNewFileName ); // new file name 

				AddBackslashIfNeeded( iFileName ); // old file name

            	}

            else

            	{

            	fileEventType = EMdsFileRenamed;

            	}

            }

            break;

        case EFsFileRename:

            WRITELOG1( "CMdsFileServerPlugin::DoRequestL() - EFsFileRename, new file: %S", &iNewFileName );

            fileEventType = EMdsFileRenamed;

            break;

        case EFsFileSetModified:

        case EFsSetEntry:

            WRITELOG( "CMdsFileServerPlugin::DoRequestL() - EFsFileSetModified" );

            fileEventType = EMdsFileModified;

            break;

        case EFsFileReplace:

        case EFsReplace:

            WRITELOG1( "CMdsFileServerPlugin::DoRequestL() - EFsReplace/EFsFileReplace, new file: %S", &iNewFileName );

            fileEventType = EMdsFileReplaced;

            break;

        case EFsDelete:

            WRITELOG( "CMdsFileServerPlugin::DoRequestL() - EFsDelete" );

            fileEventType = EMdsFileDeleted;

            break;

		case EFsFormatOpen:

			WRITELOG( "CMdsFileServerPlugin::DoRequestL() - EFsFormatOpen" );

			// get the drive letter

			err = iFsSession.Volume( volInfo, drvNumber );

			if( KErrNone == err )

				{

				iFormatOldMediaId = volInfo.iUniqueID;

				iFormatDriveNumber = drvNumber;

				fileEventType = EMdsDriveFormatted;

				processId.iUid = 0;

				}

			else

				{

				iFormatDriveNumber = -1;

				}

			return KErrNone;

		case EFsFormatSubClose:

			WRITELOG( "CMdsFileServerPlugin::DoRequestL() - EFsFormatSubClose" );

			if ( iFormatDriveNumber < 0 )

				{

				return KErrNone;

				}

			drvNumber = iFormatOldMediaId;

			volInfo.iUniqueID = iFormatOldMediaId;

			iFormatOldMediaId = 0;

			iFormatDriveNumber = -1;

			fileEventType = EMdsDriveFormatted;

			if ( processId.iUid == 0 )

				{

				processId.iUid = 1;

				}

			break;

        default:

            WRITELOG( "CMdsFileServerPlugin::DoRequestL() - Unknown function" );

            return KErrNone;

        }

    if ( iNotification )

        {

        WRITELOG( "CMdsFileServerPlugin::DoRequestL() - iNotification found" );

        TMdsFSPStatusPckg clientStatusBuf;

        TMdsFSPStatus& clientStatus = clientStatusBuf();

        clientStatus.iDriveNumber = drvNumber;

        clientStatus.iDriveMediaId = volInfo.iUniqueID;

        clientStatus.iFileName.Copy( iFileName );

        clientStatus.iNewFileName.Copy( iNewFileName );

        clientStatus.iFileEventType = fileEventType;

        clientStatus.iProcessId = processId;

        TRAP( err, iNotification->WriteParam1L(clientStatusBuf) );

        iNotification->Complete( err );

        iNotification = NULL;

        WRITELOG( "CMdsFileServerPlugin::DoRequestL() - iNotification complete" );

        }

    else // no notification ready, put in the queue

        {

        WRITELOG( "CMdsFileServerPlugin::DoRequestL() - iNotification not found. Put in the queue" );

        // Check if harvester is still alive

        if( CheckHarvesterStatus() )

            {

            CMdsFSPQueueItem* queueItem = CMdsFSPQueueItem::NewL();

            CleanupStack::PushL( queueItem );

            queueItem->iDriveNumber = drvNumber;

            queueItem->iDriveMediaId = volInfo.iUniqueID;

            queueItem->iFileName = iFileName.AllocL();

            queueItem->iNewFileName = iNewFileName.AllocL();

            queueItem->iFileEventType = fileEventType;

            queueItem->iProcessId = processId;

            iQueue.AppendL( queueItem ); // owenership is transferred

            CleanupStack::Pop( queueItem );

            err = KErrNone;

            iPendingEvents++;

            WRITELOG( "CMdsFileServerPlugin::DoRequestL() - added to queue" );

            }

        else

            {

            WRITELOG( "CMdsFileServerPlugin::DoRequestL() - Harvester process not detected" );

            iConnectionCount = 0;

            iPendingEvents = 0;

            iQueue.ResetAndDestroy();

            iQueue.Compress();

            }

        }

    WRITELOG( "CMdsFileServerPlugin::DoRequestL() - return" );

    return err;

    }

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

// CMdsFileServerPluginConn implementation

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

class CMdsFileServerPluginConn : public CFsPluginConn

    {

    public:

        static CMdsFileServerPluginConn* NewL( CMdsFileServerPlugin& aPlugin );

        virtual ~CMdsFileServerPluginConn();

        virtual TInt DoControl( CFsPluginConnRequest& aRequest );

        virtual void DoRequest( CFsPluginConnRequest& aRequest );

        virtual void DoCancel( TInt aReqMask );

    private:

    	CMdsFileServerPluginConn( CMdsFileServerPlugin& aPlugin );

    	CMdsFileServerPlugin& iPlugin;

        RMessage2* iMessage;

    };

/**

* Leaving New function for the plugin

* @internalComponent

*/

CMdsFileServerPluginConn* CMdsFileServerPluginConn::NewL( 

		CMdsFileServerPlugin& aPlugin )

    {

    WRITELOG( "CMdsFileServerPluginConn::NewL()" );

    return new (ELeave) CMdsFileServerPluginConn( aPlugin );

    }

/**

* Constructor for the plugin

* @internalComponent

*/

CMdsFileServerPluginConn::CMdsFileServerPluginConn( 

		CMdsFileServerPlugin& aPlugin ) : 

		iPlugin( aPlugin )

    {

    WRITELOG( "CMdsFileServerPluginConn::CMdsFileServerPluginConn()" );

    iPlugin.AddConnection();