Mercurial Mercurial > oss > FCL > sf > app > search / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
harvesterplugins/file/fastfindfileserverplugin/src/fastfindfileserverplugin.cpp
changeset 2 208a4ba3894c
parent 0 ccd0fd43f247
equal deleted inserted replaced
0:ccd0fd43f247 2:208a4ba3894c 
    16 */
 
    16 */
 
    17 
    17 
    18 #include <f32pluginutils.h>
 
    18 #include <f32pluginutils.h>
 
    19 #include "fastfindfileserverplugin.h"
 
    19 #include "fastfindfileserverplugin.h"
 
    20 #include "harvesterlog.h"
 
    20 #include "harvesterlog.h"
 
       
    21 #include "OstTraceDefinitions.h"
 
       
    22 #ifdef OST_TRACE_COMPILER_IN_USE
 
       
    23 #include "fastfindfileserverpluginTraces.h"
 
       
    24 #endif
 
       
    25 
    21 
    26 
    22 _LIT( KFastFindFileServerPlugin, "CPixFileServerPlugin" );
 
    27 _LIT( KFastFindFileServerPlugin, "CPixFileServerPlugin" );
 
    23 
    28 
    24 //-----------------------------------------------------------------------------
 
    29 //-----------------------------------------------------------------------------
 
    25 // CFastFindFileServerPlugin implementation
 
    30 // CFastFindFileServerPlugin implementation
 
    26 //-----------------------------------------------------------------------------
 
    31 //-----------------------------------------------------------------------------
 
    27 //
 
    32 //
 
    28 CFastFindFileServerPlugin::CFastFindFileServerPlugin()
 
    33 CFastFindFileServerPlugin::CFastFindFileServerPlugin()
 
    29 : iFormatDriveNumber( -1 )
 
    34 : iFormatDriveNumber( -1 )
 
    30 	{
 
    35 	{
 
       
    36 	OstTrace0( TRACE_NORMAL, CFASTFINDFILESERVERPLUGIN_CFASTFINDFILESERVERPLUGIN, "CFastFindFileServerPlugin::CFastFindFileServerPlugin()" );
 
    31 	WRITELOG( "CFastFindFileServerPlugin::CFastFindFileServerPlugin()" );
 
    37 	WRITELOG( "CFastFindFileServerPlugin::CFastFindFileServerPlugin()" );
 
    32 	}
 
    38 	}
 
    33 	
    39 	
    34 //-----------------------------------------------------------------------------
 
    40 //-----------------------------------------------------------------------------
 
    35 // 
    41 // 
    36 //-----------------------------------------------------------------------------
 
    42 //-----------------------------------------------------------------------------
 
    37 //
 
    43 //
 
    38 CFastFindFileServerPlugin::~CFastFindFileServerPlugin()
 
    44 CFastFindFileServerPlugin::~CFastFindFileServerPlugin()
 
    39     {
 
    45     {
 
       
    46     OstTrace0( TRACE_NORMAL, DUP1_CFASTFINDFILESERVERPLUGIN_CFASTFINDFILESERVERPLUGIN, "CFastFindFileServerPlugin::~CFastFindFileServerPlugin()" );
 
    40     WRITELOG( "CFastFindFileServerPlugin::~CFastFindFileServerPlugin()" );
 
    47     WRITELOG( "CFastFindFileServerPlugin::~CFastFindFileServerPlugin()" );
 
    41     
    48     
    42     TRAP_IGNORE( DisableL() );
 
    49     TRAP_IGNORE( DisableL() );
 
    43     iFsSession.Close();
 
    50     iFsSession.Close();
 
    44     
    51     
    59 // 
    66 // 
    60 //-----------------------------------------------------------------------------
 
    67 //-----------------------------------------------------------------------------
 
    61 //
 
    68 //
 
    62 CFastFindFileServerPlugin* CFastFindFileServerPlugin::NewL()
 
    69 CFastFindFileServerPlugin* CFastFindFileServerPlugin::NewL()
 
    63     {
 
    70     {
 
       
    71     OstTrace0( TRACE_NORMAL, CFASTFINDFILESERVERPLUGIN_NEWL, "CFastFindFileServerPlugin::NewL()" );
 
    64     WRITELOG( "CFastFindFileServerPlugin::NewL()" );
 
    72     WRITELOG( "CFastFindFileServerPlugin::NewL()" );
 
    65     return new (ELeave) CFastFindFileServerPlugin;
 
    73     return new (ELeave) CFastFindFileServerPlugin;
 
    66     }
 
    74     }
 
    67 
    75 
    68 //-----------------------------------------------------------------------------
 
    76 //-----------------------------------------------------------------------------
 
    69 // 
    77 // 
    70 //-----------------------------------------------------------------------------
 
    78 //-----------------------------------------------------------------------------
 
    71 //
 
    79 //
 
    72 void CFastFindFileServerPlugin::InitialiseL()
 
    80 void CFastFindFileServerPlugin::InitialiseL()
 
    73     {
 
    81     {
 
       
    82     OstTrace0( TRACE_NORMAL, CFASTFINDFILESERVERPLUGIN_INITIALISEL, "CFastFindFileServerPlugin::InitializeL()" );
 
    74     WRITELOG( "CFastFindFileServerPlugin::InitializeL()" );
 
    83     WRITELOG( "CFastFindFileServerPlugin::InitializeL()" );
 
    75     User::LeaveIfError( iFsSession.Connect() );
 
    84     User::LeaveIfError( iFsSession.Connect() );
 
    76     }
 
    85     }
 
    77     
    86     
    78 //-----------------------------------------------------------------------------
 
    87 //-----------------------------------------------------------------------------
 
    79 // 
    88 // 
    80 //-----------------------------------------------------------------------------
 
    89 //-----------------------------------------------------------------------------
 
    81 //
 
    90 //
 
    82 void CFastFindFileServerPlugin::EnableL()
 
    91 void CFastFindFileServerPlugin::EnableL()
 
    83     {
 
    92     {
 
       
    93     OstTrace0( TRACE_NORMAL, CFASTFINDFILESERVERPLUGIN_ENABLEL, "CFastFindFileServerPlugin::EnableL()" );
 
    84     WRITELOG( "CFastFindFileServerPlugin::EnableL()" );
 
    94     WRITELOG( "CFastFindFileServerPlugin::EnableL()" );
 
    85     User::LeaveIfError( RegisterIntercept(EFsFileCreate, EPostIntercept) );
 
    95     User::LeaveIfError( RegisterIntercept(EFsFileCreate, EPostIntercept) );
 
    86     User::LeaveIfError( RegisterIntercept(EFsFileRename, EPostIntercept) );
 
    96     User::LeaveIfError( RegisterIntercept(EFsFileRename, EPostIntercept) );
 
    87     User::LeaveIfError( RegisterIntercept(EFsRename, EPostIntercept) );
 
    97     User::LeaveIfError( RegisterIntercept(EFsRename, EPostIntercept) );
 
    88     User::LeaveIfError( RegisterIntercept(EFsDelete, EPostIntercept) );
 
    98     User::LeaveIfError( RegisterIntercept(EFsDelete, EPostIntercept) );
 
    89 //    User::LeaveIfError( RegisterIntercept(EFsFileReplace, EPostIntercept) );
 
    99 //    User::LeaveIfError( RegisterIntercept(EFsFileReplace, EPostIntercept) );
 
    90     User::LeaveIfError( RegisterIntercept(EFsReplace, EPostIntercept) );
 
   100     User::LeaveIfError( RegisterIntercept(EFsReplace, EPostIntercept) );
 
       
   101     User::LeaveIfError( RegisterIntercept(EFsMkDir, EPostIntercept) );
 
       
   102     User::LeaveIfError( RegisterIntercept(EFsRmDir, EPostIntercept) );
 
    91 //    User::LeaveIfError( RegisterIntercept(EFsFileModified, EPostIntercept) );
 
   103 //    User::LeaveIfError( RegisterIntercept(EFsFileModified, EPostIntercept) );
 
    92     User::LeaveIfError( RegisterIntercept(EFsFileSetModified, EPostIntercept) );
 
   104     User::LeaveIfError( RegisterIntercept(EFsFileSetModified, EPostIntercept) );
 
    93     User::LeaveIfError( RegisterIntercept(EFsFileSubClose, EPostIntercept) );
 
   105     User::LeaveIfError( RegisterIntercept(EFsFileSubClose, EPostIntercept) );
 
    94 	// format events
 
   106 	// format events
 
    95 	User::LeaveIfError( RegisterIntercept(EFsFormatSubClose, EPostIntercept) );
 
   107 	User::LeaveIfError( RegisterIntercept(EFsFormatSubClose, EPostIntercept) );
 
   104 // 
   116 // 
   105 //-----------------------------------------------------------------------------
 
   117 //-----------------------------------------------------------------------------
 
   106 //
 
   118 //
 
   107 void CFastFindFileServerPlugin::DisableL()
 
   119 void CFastFindFileServerPlugin::DisableL()
 
   108     {
 
   120     {
 
       
   121     OstTrace0( TRACE_NORMAL, CFASTFINDFILESERVERPLUGIN_DISABLEL, "CFastFindFileServerPlugin::DisableL()" );
 
   109     WRITELOG( "CFastFindFileServerPlugin::DisableL()" );
 
   122     WRITELOG( "CFastFindFileServerPlugin::DisableL()" );
 
   110     User::LeaveIfError( UnregisterIntercept(EFsFileCreate, EPrePostIntercept) );
 
   123     User::LeaveIfError( UnregisterIntercept(EFsFileCreate, EPrePostIntercept) );
 
   111     User::LeaveIfError( UnregisterIntercept(EFsFileRename, EPrePostIntercept) );
 
   124     User::LeaveIfError( UnregisterIntercept(EFsFileRename, EPrePostIntercept) );
 
   112     User::LeaveIfError( UnregisterIntercept(EFsRename, EPrePostIntercept) );
 
   125     User::LeaveIfError( UnregisterIntercept(EFsRename, EPrePostIntercept) );
 
   113     User::LeaveIfError( UnregisterIntercept(EFsDelete, EPrePostIntercept) );
 
   126     User::LeaveIfError( UnregisterIntercept(EFsDelete, EPrePostIntercept) );
 
   114 //    User::LeaveIfError( UnregisterIntercept(EFsFileReplace, EPrePostIntercept) );
 
   127 //    User::LeaveIfError( UnregisterIntercept(EFsFileReplace, EPrePostIntercept) );
 
   115     User::LeaveIfError( UnregisterIntercept(EFsReplace, EPrePostIntercept) );
 
   128     User::LeaveIfError( UnregisterIntercept(EFsReplace, EPrePostIntercept) );
 
       
   129     User::LeaveIfError( UnregisterIntercept(EFsMkDir, EPrePostIntercept) );
 
       
   130     User::LeaveIfError( UnregisterIntercept(EFsRmDir, EPrePostIntercept) );
 
   116 //    User::LeaveIfError( UnregisterIntercept(EFsFileModified, EPrePostIntercept) );
 
   131 //    User::LeaveIfError( UnregisterIntercept(EFsFileModified, EPrePostIntercept) );
 
   117     User::LeaveIfError( UnregisterIntercept(EFsFileSetModified, EPrePostIntercept) );
 
   132     User::LeaveIfError( UnregisterIntercept(EFsFileSetModified, EPrePostIntercept) );
 
   118     User::LeaveIfError( UnregisterIntercept(EFsFileSubClose, EPrePostIntercept) );
 
   133     User::LeaveIfError( UnregisterIntercept(EFsFileSubClose, EPrePostIntercept) );
 
   119 	// format events
 
   134 	// format events
 
   120 	User::LeaveIfError( UnregisterIntercept(EFsFormatSubClose, EPostIntercept) );
 
   135 	User::LeaveIfError( UnregisterIntercept(EFsFormatSubClose, EPostIntercept) );
 
   130 // AddConnection
 
   145 // AddConnection
 
   131 //-----------------------------------------------------------------------------
 
   146 //-----------------------------------------------------------------------------
 
   132 //
 
   147 //
 
   133 void CFastFindFileServerPlugin::AddConnection()
 
   148 void CFastFindFileServerPlugin::AddConnection()
 
   134     {
 
   149     {
 
       
   150     OstTrace0( TRACE_NORMAL, CFASTFINDFILESERVERPLUGIN_ADDCONNECTION, "CFastFindFileServerPlugin::AddConnection()" );
 
   135     WRITELOG( "CFastFindFileServerPlugin::AddConnection()" );
 
   151     WRITELOG( "CFastFindFileServerPlugin::AddConnection()" );
 
   136     
   152     
   137     ++iConnectionCount;
 
   153     ++iConnectionCount;
 
   138     }
 
   154     }
 
   139 
   155 
   141 // RemoveConnection
 
   157 // RemoveConnection
 
   142 //-----------------------------------------------------------------------------
 
   158 //-----------------------------------------------------------------------------
 
   143 //
 
   159 //
 
   144 void CFastFindFileServerPlugin::RemoveConnection()
 
   160 void CFastFindFileServerPlugin::RemoveConnection()
 
   145     {
 
   161     {
 
       
   162     OstTrace0( TRACE_NORMAL, CFASTFINDFILESERVERPLUGIN_REMOVECONNECTION, "CFastFindFileServerPlugin::RemoveConnection()" );
 
   146     WRITELOG( "CFastFindFileServerPlugin::RemoveConnection()" );
 
   163     WRITELOG( "CFastFindFileServerPlugin::RemoveConnection()" );
 
   147     
   164     
   148     --iConnectionCount;
 
   165     --iConnectionCount;
 
   149 
   166 
   150     // remove notification request if this was last connection
 
   167     // remove notification request if this was last connection
 
   151     if ( iConnectionCount <= 0 )
 
   168     if ( iConnectionCount <= 0 )
 
   152         {
 
   169         {
 
       
   170         OstTrace0( TRACE_NORMAL, DUP1_CFASTFINDFILESERVERPLUGIN_REMOVECONNECTION, "CFastFindFileServerPlugin::RemoveConnection() last connection" );
 
   153         WRITELOG( "CFastFindFileServerPlugin::RemoveConnection() last connection" );
 
   171         WRITELOG( "CFastFindFileServerPlugin::RemoveConnection() last connection" );
 
   154 
   172 
   155         iNotification = NULL;
 
   173         iNotification = NULL;
 
   156         }
 
   174         }
 
   157     }
 
   175     }
 
   160 // 
   178 // 
   161 //-----------------------------------------------------------------------------
 
   179 //-----------------------------------------------------------------------------
 
   162 //
 
   180 //
 
   163 TInt CFastFindFileServerPlugin::DoRequestL( TFsPluginRequest& aRequest )
 
   181 TInt CFastFindFileServerPlugin::DoRequestL( TFsPluginRequest& aRequest )
 
   164 	{
 
   182 	{
 
       
   183 	OstTraceFunctionEntry0( CFASTFINDFILESERVERPLUGIN_DOREQUESTL_ENTRY );
 
   165 	TInt err = KErrNone;
 
   184 	TInt err = KErrNone;
 
   166 	TInt function = aRequest.Function();
 
   185 	TInt function = aRequest.Function();
 
   167 	const TBool formatFunction = function == EFsFormatOpen || function == EFsFormatSubClose;
 
   186 	const TBool formatFunction = function == EFsFormatOpen || function == EFsFormatSubClose;
 
   168 
   187 
   169 #ifdef _DEBUG_EVENTS
 
   188 #ifdef _DEBUG_EVENTS
 
   170     PrintDebugEvents( function );
 
   189     PrintDebugEvents( function );
 
   171 #endif
 
   190 #endif
 
   172 
   191 
   173     if ( function == EFsFileSubClose && iCreatedFiles.Count() == 0 )
 
   192     if ( function == EFsFileSubClose && iCreatedFiles.Count() == 0 )
 
   174         {
 
   193         {
 
       
   194         OstTraceFunctionExit0( CFASTFINDFILESERVERPLUGIN_DOREQUESTL_EXIT );
 
   175         return KErrNone;
 
   195         return KErrNone;
 
   176         }
 
   196         }
 
   177 
   197 
       
   198     OstTrace1( TRACE_NORMAL, CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL;Plugin function=%d", function );
 
   178     WRITELOG1( "----- CFastFindFileServerPlugin::DoRequestL() - plugin function: %d -----", function );
 
   199     WRITELOG1( "----- CFastFindFileServerPlugin::DoRequestL() - plugin function: %d -----", function );
 
   179 
   200 
   180     TFileName fileName;
 
   201     TFileName fileName;
 
   181     fileName.Zero();
 
   202     fileName.Zero();
 
   182     TFileName newFileName;
 
   203     TFileName newFileName;
 
   183     newFileName.Zero();
 
   204     newFileName.Zero();
 
   184 
   205 
   185 	if ( !formatFunction )
 
   206 	if ( !formatFunction )
 
   186 		{
 
   207 		{
 
   187 		GetName( &aRequest, fileName );
 
   208 		GetName( &aRequest, fileName );
 
       
   209 		OstTraceExt1( TRACE_NORMAL, DUP1_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL;Filename=%S", fileName );
 
   188 		WRITELOG1( "CFastFindFileServerPlugin::DoRequestL() - fileName: %S", &fileName );
 
   210 		WRITELOG1( "CFastFindFileServerPlugin::DoRequestL() - fileName: %S", &fileName );
 
   189 		}
 
   211 		}
 
       
   212 	
       
   213 	if ( function == EFsMkDir || function == EFsRmDir)
 
       
   214 	    {
 
       
   215         // This will return the folder path with trailing slash, remove it to match
 
       
   216 	    // with the doc_id format
 
       
   217         TFileName filePath;
 
       
   218 	    GetPath(&aRequest, filePath);
 
       
   219 		if (filePath.Length() > 0)
 
       
   220 			{
 
       
   221         	TPtrC temppath( filePath.Left( filePath.Length() - 1 ) );
 
       
   222         	fileName.Zero();
 
       
   223         	fileName.Append(temppath);
 
       
   224 			}
 
       
   225 		OstTraceExt1( TRACE_NORMAL, DUP2_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL;Filename=%S", fileName );
 
       
   226 	    WRITELOG1( "CFastFindFileServerPlugin::DoRequestL() - fileName: %S", &fileName );
 
       
   227 	    }
 
   190 
   228 
   191     // get process id
 
   229     // get process id
 
   192 	TUid processId = { 0 };
 
   230 	TUid processId = { 0 };
 
   193 
   231 
   194     /*RThread clientThread;
 
   232     /*RThread clientThread;
 
   209 
   247 
   210     // if rename, check destination path
 
   248     // if rename, check destination path
 
   211     if ( function == EFsRename || function == EFsFileRename || function == EFsReplace )
 
   249     if ( function == EFsRename || function == EFsFileRename || function == EFsReplace )
 
   212         {
 
   250         {
 
   213         GetNewName( &aRequest, newFileName );
 
   251         GetNewName( &aRequest, newFileName );
 
       
   252         OstTraceExt1( TRACE_NORMAL, DUP3_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL;New Filename=%S", newFileName );
 
   214         WRITELOG1( "CFastFindFileServerPlugin::DoRequestL() - newFileName: %S", &newFileName );
 
   253         WRITELOG1( "CFastFindFileServerPlugin::DoRequestL() - newFileName: %S", &newFileName );
 
   215         if ( !CheckPath(newFileName) )
 
   254         if ( !CheckPath(newFileName) )
 
   216             {
 
   255             {
 
       
   256             OstTrace0( TRACE_NORMAL, DUP4_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL() - path not supported" );
 
   217             WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - path not supported" );
 
   257             WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - path not supported" );
 
       
   258             OstTraceFunctionExit0( DUP1_CFASTFINDFILESERVERPLUGIN_DOREQUESTL_EXIT );
 
   218             return KErrNone;
 
   259             return KErrNone;
 
   219             }
 
   260             }
 
   220         if ( !CheckAttribs(newFileName) )
 
   261         if ( !CheckAttribs(newFileName) )
 
   221             {
 
   262             {
 
       
   263             OstTrace0( TRACE_NORMAL, DUP5_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL() - attribute check failed" );
 
   222             WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - attribute check failed" );
 
   264             WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - attribute check failed" );
 
       
   265             OstTraceFunctionExit0( DUP2_CFASTFINDFILESERVERPLUGIN_DOREQUESTL_EXIT );
 
   223             return KErrNone;
 
   266             return KErrNone;
 
   224             }
 
   267             }
 
   225         }
 
   268         }
 
   226     else if ( !formatFunction )
 
   269     else if ( !formatFunction )
 
   227         {
 
   270         {
 
   228         if ( !CheckPath(fileName) )
 
   271         if ( !CheckPath(fileName) )
 
   229             {
 
   272             {
 
       
   273             OstTrace0( TRACE_NORMAL, DUP6_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL() - path not supported" );
 
   230             WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - path not supported" );
 
   274             WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - path not supported" );
 
       
   275             OstTraceFunctionExit0( DUP3_CFASTFINDFILESERVERPLUGIN_DOREQUESTL_EXIT );
 
   231             return KErrNone;
 
   276             return KErrNone;
 
   232             }
 
   277             }
 
   233 
   278 
   234         if ( !CheckAttribs(fileName) )
 
   279         if ( !CheckAttribs(fileName) )
 
   235             {
 
   280             {
 
       
   281             OstTrace0( TRACE_NORMAL, DUP7_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL() - attribute check failed" );
 
   236             WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - attribute check failed" );
 
   282             WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - attribute check failed" );
 
       
   283             OstTraceFunctionExit0( DUP4_CFASTFINDFILESERVERPLUGIN_DOREQUESTL_EXIT );
 
   237             return KErrNone;
 
   284             return KErrNone;
 
   238             }
 
   285             }
 
   239         }
 
   286         }
 
   240 
   287 
   241     TInt fileEventType = EFastFindFileUnknown;
 
   288     TInt fileEventType = EFastFindFileUnknown;
 
   242     TInt drvNumber = aRequest.DriveNumber();
 
   289     TInt drvNumber = aRequest.DriveNumber();
 
   243 
   290 
       
   291     OstTrace1( TRACE_NORMAL, DUP8_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL;Drive Number=%d", drvNumber );
 
   244     WRITELOG1( "CFastFindFileServerPlugin::DoRequestL() - drive number: %d", drvNumber );
 
   292     WRITELOG1( "CFastFindFileServerPlugin::DoRequestL() - drive number: %d", drvNumber );
 
   245 
   293 
   246     switch( function )
 
   294     switch( function )
 
   247         {
 
   295         {
 
   248         case EFsFileCreate:
 
   296         case EFsFileCreate:
 
   249             {
 
   297             {
 
       
   298             OstTrace0( TRACE_NORMAL, DUP9_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL() - EFsFileCreate" );
 
   250             WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - EFsFileCreate" );
 
   299             WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - EFsFileCreate" );
 
   251 
   300 
   252             TFileName* fn = new (ELeave) TFileName;
 
   301             TFileName* fn = new (ELeave) TFileName;
 
   253             fn->Zero();
 
   302             fn->Zero();
 
   254             fn->Copy( fileName );
 
   303             fn->Copy( fileName );
 
   255             iCreatedFiles.Append( fn );
 
   304             iCreatedFiles.Append( fn );
 
   256             User::LeaveIfError( UnregisterIntercept(EFsFileSetModified, EPrePostIntercept) );
 
   305             User::LeaveIfError( UnregisterIntercept(EFsFileSetModified, EPrePostIntercept) );
 
       
   306             OstTraceFunctionExit0( DUP5_CFASTFINDFILESERVERPLUGIN_DOREQUESTL_EXIT );
 
   257             return KErrNone;
 
   307             return KErrNone;
 
   258             }
 
   308             }
 
   259 
   309 
   260         case EFsFileSubClose:
 
   310         case EFsFileSubClose:
 
   261             {
 
   311             {
 
       
   312             OstTrace0( TRACE_NORMAL, DUP10_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL() - EFsFileSubClose" );
 
   262             WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - EFsFileSubClose" );
 
   313             WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - EFsFileSubClose" );
 
   263 
   314 
   264             TBool found = EFalse;
 
   315             TBool found = EFalse;
 
   265             for ( TInt i = 0; i < iCreatedFiles.Count(); i++ )
 
   316             for ( TInt i = 0; i < iCreatedFiles.Count(); i++ )
 
   266                 {
 
   317                 {
 
   276                     }
 
   327                     }
 
   277                 }
 
   328                 }
 
   278 
   329 
   279             if ( !found )
 
   330             if ( !found )
 
   280                 {
 
   331                 {
 
       
   332                 OstTraceFunctionExit0( DUP6_CFASTFINDFILESERVERPLUGIN_DOREQUESTL_EXIT );
 
   281                 return KErrNone;
 
   333                 return KErrNone;
 
   282                 }
 
   334                 }
 
   283             }
 
   335             }
 
   284             break;
 
   336             break;
 
   285 
   337 
   286         case EFsRename:
 
   338         case EFsRename:
 
   287             {
 
   339             {
 
       
   340             OstTraceExt1( TRACE_NORMAL, DUP11_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL() - EFsRenamed;New Filename=%S", newFileName );
 
   288             WRITELOG1( "CFastFindFileServerPlugin::DoRequestL() - EFsRenamed, new file: %S", &newFileName );
 
   341             WRITELOG1( "CFastFindFileServerPlugin::DoRequestL() - EFsRenamed, new file: %S", &newFileName );
 
   289             fileEventType = EFastFindFileRenamed;
 
   342             fileEventType = EFastFindFileRenamed;
 
   290             }
 
   343             }
 
   291             break;
 
   344             break;
 
   292 
   345 
   293         case EFsFileRename:
 
   346         case EFsFileRename:
 
       
   347             OstTraceExt1( TRACE_NORMAL, DUP12_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL() - EFsFileRenamed;New Filename=%S", newFileName );
 
   294             WRITELOG1( "CFastFindFileServerPlugin::DoRequestL() - EFsFileRenamed, new file: %S", &newFileName );
 
   348             WRITELOG1( "CFastFindFileServerPlugin::DoRequestL() - EFsFileRenamed, new file: %S", &newFileName );
 
   295             fileEventType = EFastFindFileRenamed;
 
   349             fileEventType = EFastFindFileRenamed;
 
   296             break;
 
   350             break;
 
   297 
   351 
   298         case EFsFileSetModified:
 
   352         case EFsFileSetModified:
 
       
   353             OstTrace0( TRACE_NORMAL, DUP13_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL() - EFsFileModified" );
 
   299             WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - EFsFileModified" );
 
   354             WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - EFsFileModified" );
 
   300             fileEventType = EFastFindFileModified;
 
   355             fileEventType = EFastFindFileModified;
 
   301             break;
 
   356             break;
 
   302 
   357 
   303         case EFsReplace:
 
   358         case EFsReplace:
 
       
   359             OstTraceExt1( TRACE_NORMAL, DUP14_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL()  - EFsReplace;New Filename=%S", newFileName );
 
   304             WRITELOG1( "CFastFindFileServerPlugin::DoRequestL() - EFsReplace, new file: %S", &newFileName );
 
   360             WRITELOG1( "CFastFindFileServerPlugin::DoRequestL() - EFsReplace, new file: %S", &newFileName );
 
   305             fileEventType = EFastFindFileReplaced;
 
   361             fileEventType = EFastFindFileReplaced;
 
   306             break;
 
   362             break;
 
   307 
   363 
   308         case EFsDelete:
 
   364         case EFsDelete:
 
       
   365             OstTrace0( TRACE_NORMAL, DUP15_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL() - EFsDelete" );
 
   309             WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - EFsDelete" );
 
   366             WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - EFsDelete" );
 
   310             fileEventType = EFastFindFileDeleted;
 
   367             fileEventType = EFastFindFileDeleted;
 
   311             break;
 
   368             break;
 
   312 
   369 
   313 		case EFsFormatOpen:
 
   370 		case EFsFormatOpen:
 
       
   371 			OstTrace0( TRACE_NORMAL, DUP16_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL() - EFsFormatOpen" );
 
   314 			WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - EFsFormatOpen" );
 
   372 			WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - EFsFormatOpen" );
 
   315 			// get the drive letter
 
   373 			// get the drive letter
 
   316 			iFormatDriveNumber = drvNumber;
 
   374 			iFormatDriveNumber = drvNumber;
 
   317 			fileEventType = EFastFindDriveFormatted;
 
   375 			fileEventType = EFastFindDriveFormatted;
 
   318 			processId.iUid = 0;
 
   376 			processId.iUid = 0;
 
   319 			//return KErrNone;
 
   377 			//return KErrNone;
 
   320 			break;
 
   378 			break;
 
   321 
   379 
   322 		case EFsFormatSubClose:
 
   380 		case EFsFormatSubClose:
 
       
   381 			OstTrace0( TRACE_NORMAL, DUP17_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL() - EFsFormatSubClose" );
 
   323 			WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - EFsFormatSubClose" );
 
   382 			WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - EFsFormatSubClose" );
 
   324 			if ( iFormatDriveNumber < 0 )
 
   383 			if ( iFormatDriveNumber < 0 )
 
   325 				{
 
   384 				{
 
       
   385 				OstTraceFunctionExit0( DUP7_CFASTFINDFILESERVERPLUGIN_DOREQUESTL_EXIT );
 
   326 				return KErrNone;
 
   386 				return KErrNone;
 
   327 				}
 
   387 				}
 
   328 			drvNumber = iFormatDriveNumber;
 
   388 			drvNumber = iFormatDriveNumber;
 
   329 			iFormatDriveNumber = -1;
 
   389 			iFormatDriveNumber = -1;
 
   330 			fileEventType = EFastFindDriveFormatted;
 
   390 			fileEventType = EFastFindDriveFormatted;
 
   331 			if ( processId.iUid == 0 )
 
   391 			if ( processId.iUid == 0 )
 
   332 				{
 
   392 				{
 
   333 				processId.iUid = 1;
 
   393 				processId.iUid = 1;
 
   334 				}
 
   394 				}
 
   335 			break;
 
   395 			break;
 
   336 
   396 			
       
   397 		case EFsMkDir:
 
       
   398 		    OstTrace0( TRACE_NORMAL, DUP18_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL() - EFsMkDir" );
 
       
   399 		    WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - EFsMkDir" );		    
       
   400 		    fileEventType = EFastFindDirCreated;
 
       
   401 		    
       
   402             break;
 
       
   403             
       
   404 		case EFsRmDir:
 
       
   405 		    OstTrace0( TRACE_NORMAL, DUP19_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL() - EFsRmDir" );
 
       
   406 		    WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - EFsRmDir" );
 
       
   407 		    fileEventType = EFastFindDirDeleted;
 
       
   408 		    break;
 
       
   409             
   337         default:
 
   410         default:
 
       
   411             OstTrace0( TRACE_NORMAL, DUP20_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL() - Unknown function" );
 
   338             WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - Unknown function" );
 
   412             WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - Unknown function" );
 
       
   413             OstTraceFunctionExit0( DUP8_CFASTFINDFILESERVERPLUGIN_DOREQUESTL_EXIT );
 
   339             return KErrNone;
 
   414             return KErrNone;
 
   340         }
 
   415         }
 
   341 
   416 
   342     if ( iNotification )
 
   417     if ( iNotification )
 
   343         {
 
   418         {
 
       
   419         OstTrace0( TRACE_NORMAL, DUP21_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL() - iNotification found" );
 
   344         WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - iNotification found" );
 
   420         WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - iNotification found" );
 
   345         TFastFindFSPStatusPckg clientStatusBuf;
 
   421         TFastFindFSPStatusPckg clientStatusBuf;
 
   346         TFastFindFSPStatus& clientStatus = clientStatusBuf();
 
   422         TFastFindFSPStatus& clientStatus = clientStatusBuf();
 
   347         clientStatus.iDriveNumber = drvNumber;
 
   423         clientStatus.iDriveNumber = drvNumber;
 
   348         clientStatus.iFileName.Copy( fileName );
 
   424         clientStatus.iFileName.Copy( fileName );
 
   354         clientStatus.iProcessId = processId;
 
   430         clientStatus.iProcessId = processId;
 
   355 
   431 
   356         TRAP( err, iNotification->WriteParam1L(clientStatusBuf) );
 
   432         TRAP( err, iNotification->WriteParam1L(clientStatusBuf) );
 
   357         iNotification->Complete( err );
 
   433         iNotification->Complete( err );
 
   358         iNotification = NULL;
 
   434         iNotification = NULL;
 
       
   435         OstTrace0( TRACE_NORMAL, DUP22_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL() - iNotification complete" );
 
   359         WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - iNotification complete" );
 
   436         WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - iNotification complete" );
 
   360         }
 
   437         }
 
   361     else // no notification ready, put in the queue
 
   438     else // no notification ready, put in the queue
 
   362         {
 
   439         {
 
       
   440         OstTrace0( TRACE_NORMAL, DUP23_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL() - iNotification not found. Put in the queue" );
 
   363         WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - iNotification not found. Put in the queue" );
 
   441         WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - iNotification not found. Put in the queue" );
 
   364 
   442 
   365         TFastFindFSPStatus* clientStatus = new (ELeave) TFastFindFSPStatus;
 
   443         TFastFindFSPStatus* clientStatus = new (ELeave) TFastFindFSPStatus;
 
   366         clientStatus->iDriveNumber = drvNumber;
 
   444         clientStatus->iDriveNumber = drvNumber;
 
   367         clientStatus->iFileName.Copy( fileName );
 
   445         clientStatus->iFileName.Copy( fileName );
 
   372         clientStatus->iFileEventType = fileEventType;
 
   450         clientStatus->iFileEventType = fileEventType;
 
   373         clientStatus->iProcessId = processId;
 
   451         clientStatus->iProcessId = processId;
 
   374 
   452 
   375         iQueue.Append( clientStatus ); // owenership is transferred
 
   453         iQueue.Append( clientStatus ); // owenership is transferred
 
   376         err = KErrNone;
 
   454         err = KErrNone;
 
       
   455         OstTrace0( TRACE_NORMAL, DUP24_CFASTFINDFILESERVERPLUGIN_DOREQUESTL, "CFastFindFileServerPlugin::DoRequestL() - added to queue" );
 
   377         WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - added to queue" );
 
   456         WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - added to queue" );
 
   378         }
 
   457         }
 
   379 
   458 
   380     WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - return" );
 
   459     WRITELOG( "CFastFindFileServerPlugin::DoRequestL() - return" );
 
       
   460     OstTraceFunctionExit0( DUP9_CFASTFINDFILESERVERPLUGIN_DOREQUESTL_EXIT );
 
   381     return err;
 
   461     return err;
 
   382     }
 
   462     }
 
   383 
   463 
   384 //-----------------------------------------------------------------------------
 
   464 //-----------------------------------------------------------------------------
 
   385 // CFastFindFileServerPluginConn implementation
 
   465 // CFastFindFileServerPluginConn implementation
 
   407 * @internalComponent
 
   487 * @internalComponent
 
   408 */
 
   488 */
 
   409 CFastFindFileServerPluginConn* CFastFindFileServerPluginConn::NewL( 
   489 CFastFindFileServerPluginConn* CFastFindFileServerPluginConn::NewL( 
   410 		CFastFindFileServerPlugin& aPlugin )
 
   490 		CFastFindFileServerPlugin& aPlugin )
 
   411     {
 
   491     {
 
       
   492     OstTrace0( TRACE_NORMAL, CFASTFINDFILESERVERPLUGINCONN_NEWL, "CFastFindFileServerPluginConn::NewL()" );
 
   412     WRITELOG( "CFastFindFileServerPluginConn::NewL()" );
 
   493     WRITELOG( "CFastFindFileServerPluginConn::NewL()" );
 
   413     return new (ELeave) CFastFindFileServerPluginConn( aPlugin );
 
   494     return new (ELeave) CFastFindFileServerPluginConn( aPlugin );
 
   414     }
 
   495     }
 
   415 
   496 
   416 
   497 
   420 */
 
   501 */
 
   421 CFastFindFileServerPluginConn::CFastFindFileServerPluginConn(
 
   502 CFastFindFileServerPluginConn::CFastFindFileServerPluginConn(
 
   422                CFastFindFileServerPlugin& aPlugin )
 
   503                CFastFindFileServerPlugin& aPlugin )
 
   423   : iPlugin( aPlugin )
 
   504   : iPlugin( aPlugin )
 
   424     {
 
   505     {
 
       
   506     OstTrace0( TRACE_NORMAL, CFASTFINDFILESERVERPLUGINCONN_CFASTFINDFILESERVERPLUGINCONN, "CFastFindFileServerPluginConn::CFastFindFileServerPluginConn()" );
 
   425     WRITELOG( "CFastFindFileServerPluginConn::CFastFindFileServerPluginConn()" );
 
   507     WRITELOG( "CFastFindFileServerPluginConn::CFastFindFileServerPluginConn()" );
 
   426 
   508 
   427     iPlugin.AddConnection();
 
   509     iPlugin.AddConnection();
 
   428     }
 
   510     }
 
   429 
   511 
   432 * The destructor for the test virus scanner hook.
 
   514 * The destructor for the test virus scanner hook.
 
   433 * @internalComponent
 
   515 * @internalComponent
 
   434 */
 
   516 */
 
   435 CFastFindFileServerPluginConn::~CFastFindFileServerPluginConn()
 
   517 CFastFindFileServerPluginConn::~CFastFindFileServerPluginConn()
 
   436     {
 
   518     {
 
       
   519     OstTrace0( TRACE_NORMAL, DUP1_CFASTFINDFILESERVERPLUGINCONN_CFASTFINDFILESERVERPLUGINCONN, "CFastFindFileServerPluginConn::~CFastFindFileServerPluginConn()" );
 
   437     WRITELOG( "CFastFindFileServerPluginConn::~CFastFindFileServerPluginConn()" );
 
   520     WRITELOG( "CFastFindFileServerPluginConn::~CFastFindFileServerPluginConn()" );
 
   438 
   521 
   439     iPlugin.RemoveConnection();
 
   522     iPlugin.RemoveConnection();
 
   440     }
 
   523     }
 
   441 
   524 
   443 // 
   526 // 
   444 //-----------------------------------------------------------------------------
 
   527 //-----------------------------------------------------------------------------
 
   445 //
 
   528 //
 
   446 TInt CFastFindFileServerPluginConn::DoControl( CFsPluginConnRequest& aRequest )
 
   529 TInt CFastFindFileServerPluginConn::DoControl( CFsPluginConnRequest& aRequest )
 
   447     {
 
   530     {
 
       
   531     OstTrace0( TRACE_NORMAL, CFASTFINDFILESERVERPLUGINCONN_DOCONTROL, "CFastFindFileServerPluginConn::DoControl()" );
 
   448     WRITELOG( "CFastFindFileServerPluginConn::DoControl()" );
 
   532     WRITELOG( "CFastFindFileServerPluginConn::DoControl()" );
 
   449     TInt err = KErrNotSupported;
 
   533     TInt err = KErrNotSupported;
 
   450     
   534     
   451     CFastFindFileServerPlugin& myPlugin = *(CFastFindFileServerPlugin*)Plugin();
 
   535     CFastFindFileServerPlugin& myPlugin = *(CFastFindFileServerPlugin*)Plugin();
 
   452     
   536     
   453     switch( aRequest.Function() )
 
   537     switch( aRequest.Function() )
 
   454         {
 
   538         {
 
   455         case EFastFindFSPOpEnable:
 
   539         case EFastFindFSPOpEnable:
 
   456             {
 
   540             {
 
       
   541             OstTrace0( TRACE_NORMAL, DUP1_CFASTFINDFILESERVERPLUGINCONN_DOCONTROL, "CFastFindFileServerPluginConn::DoControl() - EFastFindFSPOpEnable" );
 
   457             WRITELOG( "CFastFindFileServerPluginConn::DoControl() - EFastFindFSPOpEnable" );
 
   542             WRITELOG( "CFastFindFileServerPluginConn::DoControl() - EFastFindFSPOpEnable" );
 
   458             TRAP( err, myPlugin.EnableL() );
 
   543             TRAP( err, myPlugin.EnableL() );
 
   459             break;
 
   544             break;
 
   460             }
 
   545             }
 
   461         
   546         
   462         case EFastFindFSPOpDisable:
 
   547         case EFastFindFSPOpDisable:
 
   463             {
 
   548             {
 
       
   549             OstTrace0( TRACE_NORMAL, DUP2_CFASTFINDFILESERVERPLUGINCONN_DOCONTROL, "CFastFindFileServerPluginConn::DoControl() - EFastFindFSPOpDisable" );
 
   464             WRITELOG( "CFastFindFileServerPluginConn::DoControl() - EFastFindFSPOpDisable" );
 
   550             WRITELOG( "CFastFindFileServerPluginConn::DoControl() - EFastFindFSPOpDisable" );
 
   465             TRAP( err, myPlugin.DisableL() );
 
   551             TRAP( err, myPlugin.DisableL() );
 
   466             break;
 
   552             break;
 
   467             }
 
   553             }
 
   468         
   554         
   469         default:
 
   555         default:
 
   470             {
 
   556             {
 
       
   557             OstTrace0( TRACE_NORMAL, DUP3_CFASTFINDFILESERVERPLUGINCONN_DOCONTROL, "CFastFindFileServerPluginConn::DoControl() - Unknown Control" );
 
   471             WRITELOG( "CFastFindFileServerPluginConn::DoControl() - Unknown Control" );
 
   558             WRITELOG( "CFastFindFileServerPluginConn::DoControl() - Unknown Control" );
 
   472             break;            
   559             break;            
   473             }
 
   560             }
 
   474         }
 
   561         }
 
   475 
   562 
   481 // 
   568 // 
   482 //-----------------------------------------------------------------------------
 
   569 //-----------------------------------------------------------------------------
 
   483 //
 
   570 //
 
   484 void CFastFindFileServerPluginConn::DoRequest( CFsPluginConnRequest& aRequest )
 
   571 void CFastFindFileServerPluginConn::DoRequest( CFsPluginConnRequest& aRequest )
 
   485     {
 
   572     {
 
       
   573     OstTraceFunctionEntry0( CFASTFINDFILESERVERPLUGINCONN_DOREQUEST_ENTRY );
 
   486     WRITELOG( "CFastFindFileServerPluginConn::DoRequest()" );
 
   574     WRITELOG( "CFastFindFileServerPluginConn::DoRequest()" );
 
   487     CFastFindFileServerPlugin& myPlugin = *(CFastFindFileServerPlugin*)Plugin();
 
   575     CFastFindFileServerPlugin& myPlugin = *(CFastFindFileServerPlugin*)Plugin();
 
   488     
   576     
   489     switch( aRequest.Function() )
 
   577     switch( aRequest.Function() )
 
   490         {
 
   578         {
 
   491         case EFastFindFSPOpRegisterNotification:
 
   579         case EFastFindFSPOpRegisterNotification:
 
   492             {
 
   580             {
 
       
   581             OstTrace0( TRACE_NORMAL, CFASTFINDFILESERVERPLUGINCONN_DOREQUEST, "CFastFindFileServerPluginConn::DoRequest() - EFastFindFSPOpRegisterNotification" );
 
   493             WRITELOG( "CFastFindFileServerPluginConn::DoControl() - EFastFindFSPOpRegisterNotification" );
 
   582             WRITELOG( "CFastFindFileServerPluginConn::DoControl() - EFastFindFSPOpRegisterNotification" );
 
   494             TInt err = myPlugin.RegisterNotification( aRequest );
 
   583             TInt err = myPlugin.RegisterNotification( aRequest );
 
   495             
   584             
   496             if ( err != KErrNone )
 
   585             if ( err != KErrNone )
 
   497                 {
 
   586                 {
 
   500             break;
 
   589             break;
 
   501             }
 
   590             }
 
   502             
   591             
   503         case EFastFindFSPOpAddNotificationPath:
 
   592         case EFastFindFSPOpAddNotificationPath:
 
   504             {
 
   593             {
 
       
   594             OstTrace0( TRACE_NORMAL, DUP1_CFASTFINDFILESERVERPLUGINCONN_DOREQUEST, "CFastFindFileServerPluginConn::DoRequest() - EFastFindFSPOpAddNotificationPath" );
 
   505             WRITELOG( "CFastFindFileServerPluginConn::DoControl() - EFastFindFSPOpAddNotificationPath" );
 
   595             WRITELOG( "CFastFindFileServerPluginConn::DoControl() - EFastFindFSPOpAddNotificationPath" );
 
   506             TInt err = myPlugin.AddNotificationPath( aRequest );
 
   596             TInt err = myPlugin.AddNotificationPath( aRequest );
 
   507             aRequest.Complete( err );
 
   597             aRequest.Complete( err );
 
   508             break;
 
   598             break;
 
   509             }
 
   599             }
 
   510             
   600             
   511         case EFastFindFSPOpRemoveNotificationPath:
 
   601         case EFastFindFSPOpRemoveNotificationPath:
 
   512             {
 
   602             {
 
       
   603             OstTrace0( TRACE_NORMAL, DUP2_CFASTFINDFILESERVERPLUGINCONN_DOREQUEST, "CFastFindFileServerPluginConn::DoRequest() - EFastFindFSPOpRemoveNotificationPath" );
 
   513             WRITELOG( "CFastFindFileServerPluginConn::DoControl() - EFastFindFSPOpRemoveNotificationPath" );
 
   604             WRITELOG( "CFastFindFileServerPluginConn::DoControl() - EFastFindFSPOpRemoveNotificationPath" );
 
   514             TInt err = myPlugin.RemoveNotificationPath( aRequest );
 
   605             TInt err = myPlugin.RemoveNotificationPath( aRequest );
 
   515             aRequest.Complete( err );
 
   606             aRequest.Complete( err );
 
   516             break;
 
   607             break;
 
   517             }
 
   608             }
 
   518             
   609             
   519         case EFastFindFSPOpAddIgnorePath:
 
   610         case EFastFindFSPOpAddIgnorePath:
 
   520             {
 
   611             {
 
       
   612             OstTrace0( TRACE_NORMAL, DUP3_CFASTFINDFILESERVERPLUGINCONN_DOREQUEST, "CFastFindFileServerPluginConn::DoRequest() - EFastFindFSPOpAddIgnorePath" );
 
   521             WRITELOG( "CFastFindFileServerPluginConn::DoControl() - EFastFindFSPOpAddIgnorePath" );
 
   613             WRITELOG( "CFastFindFileServerPluginConn::DoControl() - EFastFindFSPOpAddIgnorePath" );
 
   522             TInt err = myPlugin.AddIgnorePath( aRequest );
 
   614             TInt err = myPlugin.AddIgnorePath( aRequest );
 
   523             aRequest.Complete( err );
 
   615             aRequest.Complete( err );
 
   524             break;
 
   616             break;
 
   525             }
 
   617             }
 
   526             
   618             
   527         case EFastFindFSPOpRemoveIgnorePath:
 
   619         case EFastFindFSPOpRemoveIgnorePath:
 
   528             {
 
   620             {
 
       
   621             OstTrace0( TRACE_NORMAL, DUP4_CFASTFINDFILESERVERPLUGINCONN_DOREQUEST, "CFastFindFileServerPluginConn::DoRequest() - EFastFindFSPOpRemoveIgnorePath" );
 
   529             WRITELOG( "CFastFindFileServerPluginConn::DoControl() - EFastFindFSPOpRemoveIgnorePath" );
 
   622             WRITELOG( "CFastFindFileServerPluginConn::DoControl() - EFastFindFSPOpRemoveIgnorePath" );
 
   530             TInt err = myPlugin.RemoveIgnorePath( aRequest );
 
   623             TInt err = myPlugin.RemoveIgnorePath( aRequest );
 
   531             aRequest.Complete( err );
 
   624             aRequest.Complete( err );
 
   532             break;
 
   625             break;
 
   533             }
 
   626             }
 
   534         }
 
   627         }
 
       
   628     OstTraceFunctionExit0( CFASTFINDFILESERVERPLUGINCONN_DOREQUEST_EXIT );
 
   535     }
 
   629     }
 
   536 
   630 
   537 //-----------------------------------------------------------------------------
 
   631 //-----------------------------------------------------------------------------
 
   538 // 
   632 // 
   539 //-----------------------------------------------------------------------------
 
   633 //-----------------------------------------------------------------------------
 
   540 //
 
   634 //
 
   541 void CFastFindFileServerPluginConn::DoCancel( TInt /*aReqMask*/ )
 
   635 void CFastFindFileServerPluginConn::DoCancel( TInt /*aReqMask*/ )
 
   542     {
 
   636     {
 
       
   637     OstTrace0( TRACE_NORMAL, CFASTFINDFILESERVERPLUGINCONN_DOCANCEL, "CFastFindFileServerPluginConn::DoCancel()" );
 
   543     WRITELOG( "CFastFindFileServerPluginConn::DoCancel()" );
 
   638     WRITELOG( "CFastFindFileServerPluginConn::DoCancel()" );
 
   544     iRequestQue.DoCancelAll( KErrCancel );
 
   639     iRequestQue.DoCancelAll( KErrCancel );
 
   545     }
 
   640     }
 
   546     
   641     
   547 //-----------------------------------------------------------------------------
 
   642 //-----------------------------------------------------------------------------
 
   548 // 
   643 // 
   549 //-----------------------------------------------------------------------------
 
   644 //-----------------------------------------------------------------------------
 
   550 //
 
   645 //
 
   551 CFsPluginConn* CFastFindFileServerPlugin::NewPluginConnL()
 
   646 CFsPluginConn* CFastFindFileServerPlugin::NewPluginConnL()
 
   552     {
 
   647     {
 
       
   648     OstTrace0( TRACE_NORMAL, CFASTFINDFILESERVERPLUGIN_NEWPLUGINCONNL, "CFastFindFileServerPluginConn::NewPluginConnL()" );
 
   553     WRITELOG( "CFastFindFileServerPluginConn::NewPluginConnL()" );
 
   649     WRITELOG( "CFastFindFileServerPluginConn::NewPluginConnL()" );
 
   554     return CFastFindFileServerPluginConn::NewL( *this );
 
   650     return CFastFindFileServerPluginConn::NewL( *this );
 
   555     }
 
   651     }
 
   556     
   652     
   557 //-----------------------------------------------------------------------------
 
   653 //-----------------------------------------------------------------------------
 
   558 // 
   654 // 
   559 //-----------------------------------------------------------------------------
 
   655 //-----------------------------------------------------------------------------
 
   560 //
 
   656 //
 
   561 TInt CFastFindFileServerPlugin::RegisterNotification( CFsPluginConnRequest& aRequest )
 
   657 TInt CFastFindFileServerPlugin::RegisterNotification( CFsPluginConnRequest& aRequest )
 
   562     {
 
   658     {
 
       
   659     OstTrace0( TRACE_NORMAL, CFASTFINDFILESERVERPLUGIN_REGISTERNOTIFICATION, "CFastFindFileServerPlugin::RegisterNotification()" );
 
   563     WRITELOG( "CFastFindFileServerPlugin::RegisterNotification()" );
 
   660     WRITELOG( "CFastFindFileServerPlugin::RegisterNotification()" );
 
   564     
   661     
   565     if ( iNotification )
 
   662     if ( iNotification )
 
   566         {
 
   663         {
 
   567         return KErrInUse;
 
   664         return KErrInUse;
 
   569     
   666     
   570     iNotification = &aRequest;
 
   667     iNotification = &aRequest;
 
   571     
   668     
   572     if ( iQueue.Count() > 0 )
 
   669     if ( iQueue.Count() > 0 )
 
   573         {
 
   670         {
 
       
   671         OstTrace0( TRACE_NORMAL, DUP1_CFASTFINDFILESERVERPLUGIN_REGISTERNOTIFICATION, "CFastFindFileServerPlugin::RegisterNotification() - item in queue" );
 
   574         WRITELOG( "CFastFindFileServerPlugin::RegisterNotification() - item in queue" );
 
   672         WRITELOG( "CFastFindFileServerPlugin::RegisterNotification() - item in queue" );
 
   575         
   673         
   576         TFastFindFSPStatus* queueStatus = iQueue[0];
 
   674         TFastFindFSPStatus* queueStatus = iQueue[0];
 
   577         
   675         
   578         TFastFindFSPStatusPckg pckg;
 
   676         TFastFindFSPStatusPckg pckg;
 
   600 // 
   698 // 
   601 //-----------------------------------------------------------------------------
 
   699 //-----------------------------------------------------------------------------
 
   602 //
 
   700 //
 
   603 TInt CFastFindFileServerPlugin::AddNotificationPath( CFsPluginConnRequest& aRequest )
 
   701 TInt CFastFindFileServerPlugin::AddNotificationPath( CFsPluginConnRequest& aRequest )
 
   604     {
 
   702     {
 
       
   703     OstTrace0( TRACE_NORMAL, CFASTFINDFILESERVERPLUGIN_ADDNOTIFICATIONPATH, "CFastFindFileServerPlugin::AddNotificationPath()" );
 
   605     WRITELOG( "CFastFindFileServerPlugin::AddNotificationPath()" );
 
   704     WRITELOG( "CFastFindFileServerPlugin::AddNotificationPath()" );
 
   606     TInt err = KErrNone;
 
   705     TInt err = KErrNone;
 
   607     
   706     
   608     TFastFindFSPStatusPckg pckg;
 
   707     TFastFindFSPStatusPckg pckg;
 
   609     TRAP( err, aRequest.ReadParam1L(pckg) );
 
   708     TRAP( err, aRequest.ReadParam1L(pckg) );
 
   625                 {
 
   724                 {
 
   626                 return KErrNone;
 
   725                 return KErrNone;
 
   627                 }
 
   726                 }
 
   628             }
 
   727             }
 
   629 
   728 
       
   729         OstTraceExt1( TRACE_NORMAL, DUP1_CFASTFINDFILESERVERPLUGIN_ADDNOTIFICATIONPATH, "CFastFindFileServerPlugin::AddNotificationPath;add path=%S", status.iFileName );
 
   630         WRITELOG1( "CFastFindFileServerPlugin::AddNotificationPath() - add path: %S", &status.iFileName );
 
   730         WRITELOG1( "CFastFindFileServerPlugin::AddNotificationPath() - add path: %S", &status.iFileName );
 
   631         TFileName* fn = new  TFileName;
 
   731         TFileName* fn = new  TFileName;
 
   632         
   732         
   633         if ( fn )
 
   733         if ( fn )
 
   634             {
 
   734             {
 
   652 // 
   752 // 
   653 //-----------------------------------------------------------------------------
 
   753 //-----------------------------------------------------------------------------
 
   654 //
 
   754 //
 
   655 TInt CFastFindFileServerPlugin::RemoveNotificationPath( CFsPluginConnRequest& aRequest )
 
   755 TInt CFastFindFileServerPlugin::RemoveNotificationPath( CFsPluginConnRequest& aRequest )
 
   656     {
 
   756     {
 
       
   757     OstTraceFunctionEntry0( CFASTFINDFILESERVERPLUGIN_REMOVENOTIFICATIONPATH_ENTRY );
 
   657     WRITELOG( "CFastFindFileServerPlugin::RemoveNotificationPath()" );
 
   758     WRITELOG( "CFastFindFileServerPlugin::RemoveNotificationPath()" );
 
   658     TInt err = KErrNone;
 
   759     TInt err = KErrNone;
 
   659     
   760     
   660     TFastFindFSPStatusPckg pckg;
 
   761     TFastFindFSPStatusPckg pckg;
 
   661     TRAP( err, aRequest.ReadParam1L(pckg) );
 
   762     TRAP( err, aRequest.ReadParam1L(pckg) );
 
   662     
   763     
   663     if ( err != KErrNone )
 
   764     if ( err != KErrNone )
 
   664         {
 
   765         {
 
       
   766         OstTraceFunctionExit0( CFASTFINDFILESERVERPLUGIN_REMOVENOTIFICATIONPATH_EXIT );
 
   665         return err;
 
   767         return err;
 
   666         }
 
   768         }
 
   667     
   769     
   668     TFastFindFSPStatus& status = pckg();
 
   770     TFastFindFSPStatus& status = pckg();
 
   669     
   771     
   675             for ( TInt i = 0; i < iPaths.Count(); i++ )
 
   777             for ( TInt i = 0; i < iPaths.Count(); i++ )
 
   676                 {
 
   778                 {
 
   677                 TFileName* tf = iPaths[i];
 
   779                 TFileName* tf = iPaths[i];
 
   678                 if ( tf->Compare(status.iFileName) == 0 )
 
   780                 if ( tf->Compare(status.iFileName) == 0 )
 
   679                     {
 
   781                     {
 
       
   782                     OstTraceExt1( TRACE_NORMAL, CFASTFINDFILESERVERPLUGIN_REMOVENOTIFICATIONPATH, "CFastFindFileServerPlugin::RemoveNotificationPath;remove path=%S", status.iFileName );
 
   680                     WRITELOG1( "CFastFindFileServerPlugin::RemoveNotificationPath() - remove path: %S", &status.iFileName );
 
   783                     WRITELOG1( "CFastFindFileServerPlugin::RemoveNotificationPath() - remove path: %S", &status.iFileName );
 
   681                     delete tf;
 
   784                     delete tf;
 
   682                     tf = NULL;
 
   785                     tf = NULL;
 
   683                     iPaths.Remove( i );
 
   786                     iPaths.Remove( i );
 
   684                     }
 
   787                     }
 
   688     else
 
   791     else
 
   689         {
 
   792         {
 
   690         err = KErrNotFound;
 
   793         err = KErrNotFound;
 
   691         }
 
   794         }
 
   692         
   795         
       
   796     OstTraceFunctionExit0( DUP1_CFASTFINDFILESERVERPLUGIN_REMOVENOTIFICATIONPATH_EXIT );
 
   693     return err;
 
   797     return err;
 
   694     }
 
   798     }
 
   695     
   799     
   696 //-----------------------------------------------------------------------------
 
   800 //-----------------------------------------------------------------------------
 
   697 // 
   801 // 
   698 //-----------------------------------------------------------------------------
 
   802 //-----------------------------------------------------------------------------
 
   699 //
 
   803 //
 
   700 TInt CFastFindFileServerPlugin::AddIgnorePath( CFsPluginConnRequest& aRequest )
 
   804 TInt CFastFindFileServerPlugin::AddIgnorePath( CFsPluginConnRequest& aRequest )
 
   701     {
 
   805     {
 
       
   806     OstTraceFunctionEntry0( CFASTFINDFILESERVERPLUGIN_ADDIGNOREPATH_ENTRY );
 
   702     WRITELOG( "CFastFindFileServerPlugin::AddIgnorePath()" );
 
   807     WRITELOG( "CFastFindFileServerPlugin::AddIgnorePath()" );
 
   703     TInt err = KErrNone;
 
   808     TInt err = KErrNone;
 
   704     
   809     
   705     TFastFindFSPStatusPckg pckg;
 
   810     TFastFindFSPStatusPckg pckg;
 
   706     TRAP( err, aRequest.ReadParam1L(pckg) );
 
   811     TRAP( err, aRequest.ReadParam1L(pckg) );
 
   707     
   812     
   708     if ( err != KErrNone )
 
   813     if ( err != KErrNone )
 
   709         {
 
   814         {
 
       
   815         OstTraceFunctionExit0( CFASTFINDFILESERVERPLUGIN_ADDIGNOREPATH_EXIT );
 
   710         return err;
 
   816         return err;
 
   711         }
 
   817         }
 
   712     
   818     
   713     TFastFindFSPStatus& status = pckg();
 
   819     TFastFindFSPStatus& status = pckg();
 
   714     
   820     
   720             for ( TInt i = 0; i < iIgnorePaths.Count(); i++ )
 
   826             for ( TInt i = 0; i < iIgnorePaths.Count(); i++ )
 
   721                 {
 
   827                 {
 
   722                 TFileName* tf = iIgnorePaths[i];
 
   828                 TFileName* tf = iIgnorePaths[i];
 
   723                 if( tf->Compare(status.iFileName) == 0 )
 
   829                 if( tf->Compare(status.iFileName) == 0 )
 
   724                     {
 
   830                     {
 
       
   831                     OstTraceFunctionExit0( DUP1_CFASTFINDFILESERVERPLUGIN_ADDIGNOREPATH_EXIT );
 
   725                     return KErrNone;
 
   832                     return KErrNone;
 
   726                     }
 
   833                     }
 
   727                 }
 
   834                 }
 
   728             }
 
   835             }
 
   729             
   836             
       
   837         OstTraceExt1( TRACE_NORMAL, CFASTFINDFILESERVERPLUGIN_ADDIGNOREPATH, "CFastFindFileServerPlugin::AddIgnorePath;add path=%S", status.iFileName );
 
   730         WRITELOG1( "CFastFindFileServerPlugin::AddIgnorePath() - add path: %S", &status.iFileName );
 
   838         WRITELOG1( "CFastFindFileServerPlugin::AddIgnorePath() - add path: %S", &status.iFileName );
 
   731         TFileName* fn = new TFileName;
 
   839         TFileName* fn = new TFileName;
 
   732         
   840         
   733         if ( fn )
 
   841         if ( fn )
 
   734             {
 
   842             {
 
   743     else
 
   851     else
 
   744         {
 
   852         {
 
   745         err = KErrNotFound;
 
   853         err = KErrNotFound;
 
   746         }
 
   854         }
 
   747         
   855         
       
   856     OstTraceFunctionExit0( DUP2_CFASTFINDFILESERVERPLUGIN_ADDIGNOREPATH_EXIT );
 
   748     return err;
 
   857     return err;
 
   749     }
 
   858     }
 
   750     
   859     
   751 //-----------------------------------------------------------------------------
 
   860 //-----------------------------------------------------------------------------
 
   752 // 
   861 // 
   753 //-----------------------------------------------------------------------------
 
   862 //-----------------------------------------------------------------------------
 
   754 //
 
   863 //
 
   755 TInt CFastFindFileServerPlugin::RemoveIgnorePath( CFsPluginConnRequest& aRequest )
 
   864 TInt CFastFindFileServerPlugin::RemoveIgnorePath( CFsPluginConnRequest& aRequest )
 
   756     {
 
   865     {
 
       
   866     OstTraceFunctionEntry0( CFASTFINDFILESERVERPLUGIN_REMOVEIGNOREPATH_ENTRY );
 
   757     WRITELOG( "CFastFindFileServerPlugin::RemoveIgnorePath()" );
 
   867     WRITELOG( "CFastFindFileServerPlugin::RemoveIgnorePath()" );
 
   758     TInt err = KErrNone;
 
   868     TInt err = KErrNone;
 
   759     
   869     
   760     TFastFindFSPStatusPckg pckg;
 
   870     TFastFindFSPStatusPckg pckg;
 
   761     TRAP( err, aRequest.ReadParam1L(pckg) );
 
   871     TRAP( err, aRequest.ReadParam1L(pckg) );
 
   762     
   872     
   763     if ( err != KErrNone )
 
   873     if ( err != KErrNone )
 
   764         {
 
   874         {
 
       
   875         OstTraceFunctionExit0( CFASTFINDFILESERVERPLUGIN_REMOVEIGNOREPATH_EXIT );
 
   765         return err;
 
   876         return err;
 
   766         }
 
   877         }
 
   767     
   878     
   768     TFastFindFSPStatus& status = pckg();
 
   879     TFastFindFSPStatus& status = pckg();
 
   769     
   880     
   775             for ( TInt i = 0; i < iIgnorePaths.Count(); i++ )
 
   886             for ( TInt i = 0; i < iIgnorePaths.Count(); i++ )
 
   776                 {
 
   887                 {
 
   777                 TFileName* tf = iIgnorePaths[i];
 
   888                 TFileName* tf = iIgnorePaths[i];
 
   778                 if ( tf->Compare(status.iFileName) == 0 )
 
   889                 if ( tf->Compare(status.iFileName) == 0 )
 
   779                     {
 
   890                     {
 
       
   891                     OstTraceExt1( TRACE_NORMAL, CFASTFINDFILESERVERPLUGIN_REMOVEIGNOREPATH, "CFastFindFileServerPlugin::RemoveIgnorePath;remove path=%S", status.iFileName );
 
   780                     WRITELOG1( "CFastFindFileServerPlugin::RemoveIgnorePath() - remove path: %S", &status.iFileName );
 
   892                     WRITELOG1( "CFastFindFileServerPlugin::RemoveIgnorePath() - remove path: %S", &status.iFileName );
 
   781                     delete tf;
 
   893                     delete tf;
 
   782                     tf = NULL;
 
   894                     tf = NULL;
 
   783                     iIgnorePaths.Remove( i );
 
   895                     iIgnorePaths.Remove( i );
 
   784                     }
 
   896                     }
 
   788     else
 
   900     else
 
   789         {
 
   901         {
 
   790         err = KErrNotFound;
 
   902         err = KErrNotFound;
 
   791         }
 
   903         }
 
   792         
   904         
       
   905     OstTraceFunctionExit0( DUP1_CFASTFINDFILESERVERPLUGIN_REMOVEIGNOREPATH_EXIT );
 
   793     return err;
 
   906     return err;
 
   794     }
 
   907     }
 
   795     
   908     
   796 //-----------------------------------------------------------------------------
 
   909 //-----------------------------------------------------------------------------
 
   797 // 
   910 // 
   896     
  1009     
   897 // Constructor for the plugin factory
 
  1010 // Constructor for the plugin factory
 
   898 // @internalComponent
 
  1011 // @internalComponent
 
   899 CFastFindFileServerPluginFactory::CFastFindFileServerPluginFactory()
 
  1012 CFastFindFileServerPluginFactory::CFastFindFileServerPluginFactory()
 
   900     {
 
  1013     {
 
       
  1014     OstTrace0( TRACE_NORMAL, CFASTFINDFILESERVERPLUGINFACTORY_CFASTFINDFILESERVERPLUGINFACTORY, "CFastFindFileServerPluginFactory::CFastFindFileServerPluginFactory()" );
 
   901     WRITELOG( "CFastFindFileServerPluginFactory::CFastFindFileServerPluginFactory()" );
 
  1015     WRITELOG( "CFastFindFileServerPluginFactory::CFastFindFileServerPluginFactory()" );
 
   902     }
 
  1016     }
 
   903 
  1017 
   904 // Install function for the plugin factory
 
  1018 // Install function for the plugin factory
 
   905 // @internalComponent
 
  1019 // @internalComponent
 
   906 TInt CFastFindFileServerPluginFactory::Install()
 
  1020 TInt CFastFindFileServerPluginFactory::Install()
 
   907     {
 
  1021     {
 
       
  1022     OstTrace0( TRACE_NORMAL, CFASTFINDFILESERVERPLUGINFACTORY_INSTALL, "CFastFindFileServerPluginFactory::Install()" );
 
   908     WRITELOG( "CFastFindFileServerPluginFactory::Install()" );
 
  1023     WRITELOG( "CFastFindFileServerPluginFactory::Install()" );
 
   909     iSupportedDrives = KPluginAutoAttach;
 
  1024     iSupportedDrives = KPluginAutoAttach;
 
   910     
  1025     
   911     return( SetName(&KFastFindFileServerPlugin) );
 
  1026     return( SetName(&KFastFindFileServerPlugin) );
 
   912     }
 
  1027     }
 
   913 
  1028 
   914 // @internalComponent
 
  1029 // @internalComponent
 
   915 TInt CFastFindFileServerPluginFactory::UniquePosition()
 
  1030 TInt CFastFindFileServerPluginFactory::UniquePosition()
 
   916     {
 
  1031     {
 
       
  1032     OstTrace0( TRACE_NORMAL, CFASTFINDFILESERVERPLUGINFACTORY_UNIQUEPOSITION, "CFastFindFileServerPluginFactory::UniquePosition()" );
 
   917     WRITELOG( "CFastFindFileServerPluginFactory::UniquePosition()" );
 
  1033     WRITELOG( "CFastFindFileServerPluginFactory::UniquePosition()" );
 
   918     return( KFastFindFSPluginPosition );
 
  1034     return( KFastFindFSPluginPosition );
 
   919     }
 
  1035     }
 
   920 
  1036 
   921 // Plugin factory function
 
  1037 // Plugin factory function
 
   922 // @internalComponent
 
  1038 // @internalComponent
 
   923 CFsPlugin* CFastFindFileServerPluginFactory::NewPluginL()
 
  1039 CFsPlugin* CFastFindFileServerPluginFactory::NewPluginL()
 
   924     {
 
  1040     {
 
       
  1041     OstTrace0( TRACE_NORMAL, CFASTFINDFILESERVERPLUGINFACTORY_NEWPLUGINL, "CFastFindFileServerPluginFactory::NewPluginL()" );
 
   925     WRITELOG( "CFastFindFileServerPluginFactory::NewPluginL()" );
 
  1042     WRITELOG( "CFastFindFileServerPluginFactory::NewPluginL()" );
 
   926     return CFastFindFileServerPlugin::NewL();
 
  1043     return CFastFindFileServerPlugin::NewL();
 
   927     }
 
  1044     }
 
   928 
  1045 
   929 // Create a new Plugin
 
  1046 // Create a new Plugin
 
   930 // @internalComponent
 
  1047 // @internalComponent
 
   931 extern "C"
 
  1048 extern "C"
 
   932     {
 
  1049     {
 
   933     EXPORT_C CFsPluginFactory* CreateFileSystem()
 
  1050     EXPORT_C CFsPluginFactory* CreateFileSystem()
 
   934         {
 
  1051         {
 
       
  1052         OstTrace0( TRACE_NORMAL, DUP1_CFASTFINDFILESERVERPLUGINFACTORY_NEWPLUGINL, "CFastFindFileServerPluginFactory::CreateFileSystem" );
 
   935         WRITELOG( "CFastFindFileServerPluginFactory::CreateFileSystem" );
 
  1053         WRITELOG( "CFastFindFileServerPluginFactory::CreateFileSystem" );
 
   936         return( new CFastFindFileServerPluginFactory() );
 
  1054         return( new CFastFindFileServerPluginFactory() );
 
   937         }
 
  1055         }
 
   938     }
 
  1056     }
 
   939 
  1057 
   956     User::LeaveIfError( RegisterIntercept( EFsFileReplace, EPreIntercept) );
 
  1074     User::LeaveIfError( RegisterIntercept( EFsFileReplace, EPreIntercept) );
 
   957     User::LeaveIfError( RegisterIntercept( EFsFileLock, EPreIntercept) );
 
  1075     User::LeaveIfError( RegisterIntercept( EFsFileLock, EPreIntercept) );
 
   958     User::LeaveIfError( RegisterIntercept( EFsFileSize, EPreIntercept) );
 
  1076     User::LeaveIfError( RegisterIntercept( EFsFileSize, EPreIntercept) );
 
   959     User::LeaveIfError( RegisterIntercept( EFsFileRename, EPreIntercept) );
 
  1077     User::LeaveIfError( RegisterIntercept( EFsFileRename, EPreIntercept) );
 
   960     User::LeaveIfError( RegisterIntercept( EFsRename, EPreIntercept) );
 
  1078     User::LeaveIfError( RegisterIntercept( EFsRename, EPreIntercept) );
 
       
  1079     User::LeaveIfError( RegisterIntercept( EFsMkDir, EPrePostIntercept) );
 
       
  1080     User::LeaveIfError( RegisterIntercept( EFsRmDir, EPrePostIntercept) );
 
   961     User::LeaveIfError( RegisterIntercept( EFsFileOpen, EPreIntercept) );
 
  1081     User::LeaveIfError( RegisterIntercept( EFsFileOpen, EPreIntercept) );
 
   962     User::LeaveIfError( RegisterIntercept( EFsFileTemp,    EPreIntercept) );
 
  1082     User::LeaveIfError( RegisterIntercept( EFsFileTemp,    EPreIntercept) );
 
   963     User::LeaveIfError( RegisterIntercept( EFsFileUnLock, EPreIntercept) );
 
  1083     User::LeaveIfError( RegisterIntercept( EFsFileUnLock, EPreIntercept) );
 
   964     User::LeaveIfError( RegisterIntercept( EFsFileSetSize, EPreIntercept) );
 
  1084     User::LeaveIfError( RegisterIntercept( EFsFileSetSize, EPreIntercept) );
 
   965     User::LeaveIfError( RegisterIntercept( EFsFileDrive, EPreIntercept) );
 
  1085     User::LeaveIfError( RegisterIntercept( EFsFileDrive, EPreIntercept) );
 
   990     User::LeaveIfError( UnregisterIntercept( EFsFileReplace, EPrePostIntercept) );
 
  1110     User::LeaveIfError( UnregisterIntercept( EFsFileReplace, EPrePostIntercept) );
 
   991     User::LeaveIfError( UnregisterIntercept( EFsFileLock, EPrePostIntercept) );
 
  1111     User::LeaveIfError( UnregisterIntercept( EFsFileLock, EPrePostIntercept) );
 
   992     User::LeaveIfError( UnregisterIntercept( EFsFileSize, EPrePostIntercept) );
 
  1112     User::LeaveIfError( UnregisterIntercept( EFsFileSize, EPrePostIntercept) );
 
   993     User::LeaveIfError( UnregisterIntercept( EFsFileRename, EPrePostIntercept) );
 
  1113     User::LeaveIfError( UnregisterIntercept( EFsFileRename, EPrePostIntercept) );
 
   994     User::LeaveIfError( UnregisterIntercept( EFsRename, EPrePostIntercept) );
 
  1114     User::LeaveIfError( UnregisterIntercept( EFsRename, EPrePostIntercept) );
 
       
  1115     User::LeaveIfError( UnregisterIntercept( EFsMkDir, EPrePostIntercept) );
 
       
  1116     User::LeaveIfError( UnregisterIntercept( EFsRmDir, EPrePostIntercept) );
 
   995     User::LeaveIfError( UnregisterIntercept( EFsFileOpen, EPrePostIntercept) );
 
  1117     User::LeaveIfError( UnregisterIntercept( EFsFileOpen, EPrePostIntercept) );
 
   996     User::LeaveIfError( UnregisterIntercept( EFsFileTemp, EPrePostIntercept) );
 
  1118     User::LeaveIfError( UnregisterIntercept( EFsFileTemp, EPrePostIntercept) );
 
   997     User::LeaveIfError( UnregisterIntercept( EFsFileUnLock, EPrePostIntercept) );
 
  1119     User::LeaveIfError( UnregisterIntercept( EFsFileUnLock, EPrePostIntercept) );
 
   998     User::LeaveIfError( UnregisterIntercept( EFsFileSetSize, EPrePostIntercept) );
 
  1120     User::LeaveIfError( UnregisterIntercept( EFsFileSetSize, EPrePostIntercept) );
 
   999     User::LeaveIfError( UnregisterIntercept( EFsFileDrive, EPrePostIntercept) );
 
  1121     User::LeaveIfError( UnregisterIntercept( EFsFileDrive, EPrePostIntercept) );
 
  1014 void CFastFindFileServerPlugin::PrintDebugEvents( TInt aFunction )
 
  1136 void CFastFindFileServerPlugin::PrintDebugEvents( TInt aFunction )
 
  1015     {
 
  1137     {
 
  1016     switch ( aFunction )
 
  1138     switch ( aFunction )
 
  1017         {
 
  1139         {
 
  1018         case EFsFileDuplicate:
 
  1140         case EFsFileDuplicate:
 
       
  1141             OstTrace0( TRACE_NORMAL, CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileDuplicate" );
 
  1019             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileDuplicate" );
 
  1142             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileDuplicate" );
 
  1020             break;
 
  1143             break;            
  1021             
       
  1022         case EFsFileCreate:
 
  1144         case EFsFileCreate:
 
       
  1145             OstTrace0( TRACE_NORMAL, DUP1_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileCreate" );
 
  1023             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileCreate" );
 
  1146             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileCreate" );
 
  1024             break;
 
  1147             break;
 
  1025         case EFsFileWrite:
 
  1148         case EFsFileWrite:
 
       
  1149             OstTrace0( TRACE_NORMAL, DUP2_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileWrite" );
 
  1026             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileWrite" );
 
  1150             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileWrite" );
 
  1027             break;
 
  1151             break;
 
  1028         case EFsFileFlush:
 
  1152         case EFsFileFlush:
 
       
  1153             OstTrace0( TRACE_NORMAL, DUP3_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileFlush" );
 
  1029             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileFlush" );
 
  1154             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileFlush" );
 
  1030             break;
 
  1155             break;
 
  1031         case EFsFileSetAtt:
 
  1156         case EFsFileSetAtt:
 
       
  1157             OstTrace0( TRACE_NORMAL, DUP4_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileSetAtt" );
 
  1032             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileSetAtt" );
 
  1158             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileSetAtt" );
 
  1033             break;
 
  1159             break;
 
  1034         case EFsFileChangeMode:
 
  1160         case EFsFileChangeMode:
 
       
  1161             OstTrace0( TRACE_NORMAL, DUP5_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileChangeMode" );
 
  1035             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileChangeMode" );
 
  1162             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileChangeMode" );
 
  1036             break;    
  1163             break;    
  1037         case EFsDelete:
 
  1164         case EFsDelete:
 
       
  1165             OstTrace0( TRACE_NORMAL, DUP6_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsDelete" );
 
  1038             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsDelete" );
 
  1166             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsDelete" );
 
  1039             break;    
  1167             break;    
  1040         case EFsFileAdopt:
 
  1168         case EFsFileAdopt:
 
       
  1169             OstTrace0( TRACE_NORMAL, DUP7_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileAdopt" );
 
  1041             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileAdopt" );
 
  1170             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileAdopt" );
 
  1042             break;    
  1171             break;    
  1043         case EFsFileReplace:
 
  1172         case EFsFileReplace:
 
       
  1173             OstTrace0( TRACE_NORMAL, DUP8_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileReplace" );
 
  1044             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileReplace" );
 
  1174             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileReplace" );
 
  1045             break;    
  1175             break;    
  1046         case EFsFileLock:
 
  1176         case EFsFileLock:
 
       
  1177             OstTrace0( TRACE_NORMAL, DUP9_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileLock" );
 
  1047             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileLock" );
 
  1178             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileLock" );
 
  1048             break;    
  1179             break;    
  1049         case EFsFileSize:
 
  1180         case EFsFileSize:
 
       
  1181             OstTrace0( TRACE_NORMAL, DUP10_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileSize" );
 
  1050             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileSize" );
 
  1182             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileSize" );
 
  1051             break;    
  1183             break;    
  1052         case EFsFileModified:
 
  1184         case EFsFileModified:
 
       
  1185             OstTrace0( TRACE_NORMAL, DUP11_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileModified" );
 
  1053             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileModified" );
 
  1186             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileModified" );
 
  1054             break;    
  1187             break;    
  1055         case EFsFileRename:
 
  1188         case EFsFileRename:
 
       
  1189             OstTrace0( TRACE_NORMAL, DUP12_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileRename" );
 
  1056             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileRename" );
 
  1190             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileRename" );
 
  1057             break;    
  1191             break;    
  1058         case EFsRename:
 
  1192         case EFsRename:
 
       
  1193             OstTrace0( TRACE_NORMAL, DUP13_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsRename" );
 
  1059             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsRename" );
 
  1194             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsRename" );
 
  1060             break;    
  1195             break;
 
       
  1196         case EFsMkDir:
 
       
  1197             OstTrace0( TRACE_NORMAL, DUP14_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsMkDir" );
 
       
  1198             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsMkDir" );
 
       
  1199             break;
 
       
  1200         case EFsRmDir:
 
       
  1201             OstTrace0( TRACE_NORMAL, DUP15_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsRmDir" );
 
       
  1202             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsRmDir" );
 
       
  1203             break;
 
  1061         case EFsFileOpen:
 
  1204         case EFsFileOpen:
 
       
  1205             OstTrace0( TRACE_NORMAL, DUP16_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileOpen" );
 
  1062             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileOpen" );
 
  1206             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileOpen" );
 
  1063             break;    
  1207             break;    
  1064         case EFsFileTemp:
 
  1208         case EFsFileTemp:
 
       
  1209             OstTrace0( TRACE_NORMAL, DUP17_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileTemp" );
 
  1065             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileTemp" );
 
  1210             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileTemp" );
 
  1066             break;    
  1211             break;    
  1067         case EFsFileUnLock:
 
  1212         case EFsFileUnLock:
 
       
  1213             OstTrace0( TRACE_NORMAL, DUP18_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileUnLock" );
 
  1068             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileUnLock" );
 
  1214             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileUnLock" );
 
  1069             break;    
  1215             break;    
  1070         case EFsFileSetSize:
 
  1216         case EFsFileSetSize:
 
       
  1217             OstTrace0( TRACE_NORMAL, DUP19_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileSetSize" );
 
  1071             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileSetSize" );
 
  1218             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileSetSize" );
 
  1072             break;    
  1219             break;    
  1073         case EFsFileSetModified:
 
  1220         case EFsFileSetModified:
 
       
  1221             OstTrace0( TRACE_NORMAL, DUP20_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileSetModified" );
 
  1074             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileSetModified" );
 
  1222             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileSetModified" );
 
  1075             break;
 
  1223             break;
 
  1076         case EFsFileDrive:
 
  1224         case EFsFileDrive:
 
       
  1225             OstTrace0( TRACE_NORMAL, DUP21_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileDrive" );
 
  1077             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileDrive" );
 
  1226             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileDrive" );
 
  1078             break;    
  1227             break;    
  1079         case EFsReplace:
 
  1228         case EFsReplace:
 
       
  1229             OstTrace0( TRACE_NORMAL, DUP22_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsReplace" );
 
  1080             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsReplace" );
 
  1230             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsReplace" );
 
  1081             break;    
  1231             break;    
  1082         case EFsFileSubClose:
 
  1232         case EFsFileSubClose:
 
       
  1233             OstTrace0( TRACE_NORMAL, DUP23_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileSubClose" );
 
  1083             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileSubClose" );
 
  1234             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileSubClose" );
 
  1084             break;    
  1235             break;    
  1085         case EFsFileRead:
 
  1236         case EFsFileRead:
 
       
  1237             OstTrace0( TRACE_NORMAL, DUP24_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileRead" );
 
  1086             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileRead" );
 
  1238             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileRead" );
 
  1087             break;
 
  1239             break;
 
  1088         case EFsFileSeek:
 
  1240         case EFsFileSeek:
 
       
  1241             OstTrace0( TRACE_NORMAL, DUP25_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileSeek" );
 
  1089             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileSeek" );
 
  1242             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileSeek" );
 
  1090             break;    
  1243             break;    
  1091         case EFsFileAtt:
 
  1244         case EFsFileAtt:
 
       
  1245             OstTrace0( TRACE_NORMAL, DUP26_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileAtt" );
 
  1092             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileAtt" );
 
  1246             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileAtt" );
 
  1093             break;    
  1247             break;    
  1094         case EFsFileSet:
 
  1248         case EFsFileSet:
 
       
  1249             OstTrace0( TRACE_NORMAL, DUP27_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileSet" );
 
  1095             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileSet" );
 
  1250             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileSet" );
 
  1096             break;    
  1251             break;    
  1097         case EFsFileName:
 
  1252         case EFsFileName:
 
       
  1253             OstTrace0( TRACE_NORMAL, DUP28_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileName" );
 
  1098             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileName" );
 
  1254             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsFileName" );
 
  1099             break;    
  1255             break;    
  1100         case EFsDirOpen:
 
  1256         case EFsDirOpen:
 
       
  1257             OstTrace0( TRACE_NORMAL, DUP29_CFASTFINDFILESERVERPLUGIN_PRINTDEBUGEVENTS, "CFastFindFileServerPlugin::PrintDebugEvents() - EFsDirOpen" );
 
  1101             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsDirOpen" );
 
  1258             WRITELOG( "CFastFindFileServerPlugin::PrintDebugEvents() - EFsDirOpen" );
 
  1102             break;    
  1259             break;    
  1103         default:
 
  1260         default:
 
  1104         break;
 
  1261         break;
 
  1105         }
 
  1262         }
FCL/sf/app/search