/*

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

_LIT( KExludedThumbPath, "\\_PAlbTN\\");

_LIT( KExludedMediaArtPath, "\\.mediaartlocal\\");

/* Server name */

_LIT( KHarvesterServerName, "HarvesterServer" );

const TInt KCleanQueueTreshold( 1000 );

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

// CMdsFileServerPlugin implementation

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

//

CMdsFileServerPlugin::CMdsFileServerPlugin()

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

	{

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

	}

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

// 

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

//

CMdsFileServerPlugin::~CMdsFileServerPlugin()

    {

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

#ifdef _DEBUG

    TRAPD( error, DisableL() );

    _LIT( KPanicCategory,"CMdsFileServerPlugin" );

    __ASSERT_DEBUG( error == KErrNone, User::Panic( KPanicCategory,  error ) );

#else

    TRAP_IGNORE( DisableL() );    

#endif

    iCreatedFiles.ResetAndDestroy();

    iCreatedFiles.Close();

    iModifiedFiles.ResetAndDestroy();

    iModifiedFiles.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()" );

    }

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

// 

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

//

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 are not any clients listening

	if( iConnectionCount <= 0 )

		{

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

		return KErrNone;

		}

	TInt function = aRequest.Function();

	iFileName.Zero();

    iNewFileName.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 );

    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 = 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 );

        TBool setToBeDeleted( EFalse );

        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;

                setToBeDeleted = ETrue;

                }

            if( !setToBeDeleted )

                {

                RFsPlugin fsPlugin( aRequest ); 

                const TInt rfsPluginErr = fsPlugin.Connect();

                if ( ( rfsPluginErr == KErrNone ) && !CheckAttribs( iNewFileName, isDirectory, fsPlugin, EFalse ) )

                    {

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

                    if( !CheckAttribs(iFileName, isDirectory, fsPlugin, EFalse) )

                        {

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

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

                        fsPlugin.Close();

                        return KErrNone;

                        }

                    // file set to hidden, delete from db

                    function = EFsDelete;

                    }

                fsPlugin.Close();

                }

            }

        else

        	{

            if( !CheckIfValidFile(iFileName, isDirectory, aRequest, EFalse)  )

                {

                return KErrNone;

                }

        	}

        }

    else if ( !formatFunction )

        {

        const TBool deleteFunction( function == EFsDelete );

        if( !CheckIfValidFile(iFileName, isDirectory, aRequest, deleteFunction)  )

            {

            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            

#endif            

            HBufC* createdFileName = iFileName.Alloc();

            if( createdFileName )

                {

                // Ownership transferred if succeeded

                const TInt appendError( iCreatedFiles.Append( createdFileName ) );

                if( appendError != KErrNone )

                    {

                    delete createdFileName;

                    createdFileName = NULL;

                    }

                }

            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[i] = NULL;

            			iCreatedFiles.Remove( i );

						//Have to check whether file has been hidden          			

            	        RFsPlugin fsPlugin( aRequest ); 

            	        const TInt rfsPluginError( fsPlugin.Connect() );

            	        if( (rfsPluginError == KErrNone) && CheckAttribs( iFileName, isDirectory, fsPlugin, EFalse ) )

            	            {

            	            found = ETrue;

            	            }

            	        else if( rfsPluginError != KErrNone )

            	            {

            	            found = ETrue;

            	            }

            	        fsPlugin.Close();

            			}

            		}

           	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:

            {

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

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

                {

                // If file has been created but not closed, do not handle modified events

                // for that file before the application that has created the file is done with writing 

                // it to the disk.

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

                    {

                    return KErrNone;

                    }

                } 

            HBufC* modifiedFileName = iFileName.Alloc();

            if( modifiedFileName )

                {

                // Ownership transferred if succeeded

                const TInt appendError( iModifiedFiles.Append( modifiedFileName ) );

                if( appendError != KErrNone )

                    {

                    delete modifiedFileName;

                    modifiedFileName = NULL;

                    }

                }

            fileEventType = EMdsFileModified;

            }

            break;

        case EFsSetEntry:

            {

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

            TBool found = EFalse;

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

                    {

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

                      {

                        delete iModifiedFiles[i];

                        iModifiedFiles[i] = NULL;

                        iModifiedFiles.Remove( i );

                        found = ETrue;

                        }

                    }

            if( iModifiedFiles.Count() == 0 )

                {

                iModifiedFiles.GranularCompress();

                }

            if ( found )

                {

                return KErrNone;

                }

            fileEventType = EMdsFileAttribsChanged;

            }

            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

		    RFsPlugin fsPlugin( aRequest ); 

		    err = fsPlugin.Connect();

	        if( err == KErrNone )

	            {

	            err = fsPlugin.Volume( volInfo, drvNumber );

	            }

	        fsPlugin.Close();

			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;

				}

			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" );