// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of the License "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:
// f32\sfile\sf_plugin_ops.cpp
// 
//

#include "sf_std.h"
#include "sf_plugin_priv.h"
#include "sf_file_cache.h"

/**
Platform security check
*/
TInt TFsAddPlugin::Initialise(CFsRequest* aRequest)
	{
	if (!KCapFsPlugin.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Mount Plugin")))
		return KErrPermissionDenied;

	return(KErrNone);
	}

/**
Adds the plugin and installs plugin factory
*/
TInt TFsAddPlugin::DoRequestL(CFsRequest* aRequest)
	{
	__PRINT(_L("TFsAddPlugin::DoRequestL(CFsRequest* aRequest)"));
	
	RLibrary lib;
	lib.SetHandle(aRequest->Message().Int0());				
	if (lib.Type()[1]!=TUid::Uid(KFileSystemUidValue))		
		return KErrNotSupported;

	TPluginNew e=(TPluginNew)lib.Lookup(1);					
	if (!e)
		return KErrCorrupt;

	CFsPluginFactory* pF=(*e)();
	if(!pF)													
		return KErrNoMemory;
	
	TInt r = FsPluginManager::InstallPluginFactory(pF,lib);
	return(r);
	}

/**
Platform security checking
*/
TInt TFsRemovePlugin::Initialise(CFsRequest* aRequest)
	{
	if (!KCapFsPlugin.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Mount Plugin")))
		return KErrPermissionDenied;
	return KErrNone;
	}

/**
Removes the plugin from session. Can't remove if have plugin mounted. 
*/
TInt TFsRemovePlugin::DoRequestL(CFsRequest* aRequest)
	{
	TFullName name;
	aRequest->ReadL(KMsgPtr0,name);	
	
	CFsPluginFactory* pF = FsPluginManager::GetPluginFactory(name);			
	if (pF==NULL)								
		return(KErrNotFound);

	// Check if any plugin is mounted in the chain
	if(pF->MountedPlugins()!=0)
		return KErrInUse;	

	TInt r=pF->Remove();						
	if (r!=KErrNone)
		return(r);
	RLibrary lib=pF->Library();					
	pF->Close();								
	lib.Close();								
	return(KErrNone);
	}

/**
Platform security check.
Finding the plugin factory & checking if the drive supports the plugin
*/
TInt TFsMountPlugin::Initialise(CFsRequest* aRequest)
	{
	
	if (!KCapFsPlugin.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Mount Plugin")))
		return KErrPermissionDenied;
	
	TFullName pluginName;
	TRAPD(err,aRequest->ReadL(KMsgPtr0,pluginName));
	if(err != KErrNone)
		return err;

	CFsPluginFactory* pF = FsPluginManager::GetPluginFactory(pluginName);
	if (pF==NULL)
		return(KErrNotFound);

	if(pF->IsDriveSupported(aRequest->Message().Int1()) == EFalse)
		return KErrNotSupported;

	aRequest->SetScratchValue((TUint)pF);

	return KErrNone;
	}

/**
Mounts the plugin
*/
TInt TFsMountPlugin::DoRequestL(CFsRequest* aRequest)
	{
	CFsPluginFactory* pF = (CFsPluginFactory*)aRequest->ScratchValue();
	if(pF == NULL)
		return KErrNotFound;

	// empty the closed file queue
	TClosedFileUtils::Remove();

	TInt err = FsPluginManager::MountPlugin(*pF,aRequest->Message().Int1(),aRequest->Message().Int2());
	return err;
	}

/**
Platform security check.
Finding the plugin factory & checking if the drive supports the plugin
*/
TInt TFsDismountPlugin::Initialise(CFsRequest* aRequest)
	{
	if (!KCapFsPlugin.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Mount Plugin")))
		return KErrPermissionDenied;

	TFullName name;
	TRAPD(err, aRequest->ReadL(KMsgPtr0,name));					//get plugin name
	if(err!=KErrNone)
		return err;

	TInt drive = aRequest->Message().Int1();
	CFsPluginFactory* pF = FsPluginManager::GetPluginFactory(name);				
	if (!pF || pF->MountedPlugins()==0)
		return(KErrNotFound);
	if(pF->IsDriveSupported(drive) == EFalse)
		return KErrNotSupported;

	FsPluginManager::LockChain();
	err = FsPluginManager::IsInChain(pF->UniquePosition(),aRequest->Message().Int2(),aRequest->Message().Int1(), pF);

	// plugin might have been mounted in different pos and drive. Find the right one
	if(err >= 0)
		{
		TInt pos = err;
		CFsPlugin* plugin = NULL;
		err = FsPluginManager::Plugin(plugin, pos);
		if(err == KErrNone)
			{
			//If we're version2 plugin, and we're dismounting a single drive
			// but we're mounted on many drives, then
			// just remove drive from iMountedOn and return KErrCompletion.
			//
			//NB: Already checked that we're mounted on 'drive' in IsInChain
			
			if(pF->SupportedDrives()&KPluginVersionTwo && drive!=KPluginAutoAttach)
				{
				//Special Case:
				//Z Drive
				if(drive==KPluginMountDriveZ)
					{
					drive = 25;
					}
				
				//Are we mounted on many drives?
				if((plugin->iMountedOn&(~1<<drive)) > 0) //without 'drive' is there still a drive set?
					{
					plugin->iMountedOn &= ~1<<drive;
					FsPluginManager::UnlockChain();
					return KErrCompletion; //don't go to dorequestl
					}
				}
			
			plugin->RegisterIntercept(EFsDismountPlugin, CFsPlugin::EPreIntercept);
			aRequest->SetScratchValue((TUint)pF);
			}
		}
	// pos contains an error code
	FsPluginManager::UnlockChain();
	return err;
	}

/**
Dismount the plugin from the stack
*/
TInt TFsDismountPlugin::DoRequestL(CFsRequest* aRequest)
	{

	CFsPluginFactory* pF = (CFsPluginFactory*)aRequest->ScratchValue();
	if(pF == NULL)
		return KErrNone;	// The plugin has already been dismounted

	TInt drive = aRequest->Message().Int1();

	FsPluginManager::LockChain();

	TInt err = FsPluginManager::IsInChain(pF->UniquePosition(),aRequest->Message().Int2(),drive, pF);
	if(err >= 0)
		{
		TInt pos = err;
		CFsPlugin* plugin = NULL;
		err = FsPluginManager::Plugin(plugin, pos);
		if(err == KErrNone)
			{
			if(aRequest->iCurrentPlugin == plugin)
				{
				FsPluginManager::DismountPlugin(*pF,pos);
				aRequest->SetScratchValue(0);
				}
			}
		}
	FsPluginManager::UnlockChain();
	return err;
	}


/**
Validates the drive
*/
TInt TFsPluginName::Initialise(CFsRequest* aRequest)
	{
	TInt r=ValidateDrive(aRequest->Message().Int1(),aRequest);
	if(r!=KErrNone)
		return r;
	if(aRequest->Drive()->IsSubsted())
		return KErrNotSupported;
	return r;
	}

/**
Return the name of a plugin for a given drive and plugin chain position
*/
TInt TFsPluginName::DoRequestL(CFsRequest* aRequest)
	{
	CFsPlugin* plugin=NULL;
	FsPluginManager::LockChain();
	TInt err = FsPluginManager::Plugin(plugin, aRequest->Message().Int2());
	if(err != KErrNone) //should be ok but just in case
	    {
	    FsPluginManager::UnlockChain();
		return err;
	    }

	TInt r = KErrNotFound;
	if(plugin)
		{
		aRequest->WriteL(KMsgPtr0, plugin->Name());
		r = KErrNone;
		}
	FsPluginManager::UnlockChain();
	return r;
	}
/**
Open a plugin
*/
TInt TFsPluginOpen::Initialise(CFsRequest* aRequest)
	{
	TInt pluginPos = aRequest->Message().Int0();
	CFsPlugin* pP = FsPluginManager::FindByUniquePosition(pluginPos);
	if(pP == NULL)
		return KErrNotFound;

	aRequest->iCurrentPlugin = pP;
	aRequest->SetDriveNumber(-1);
	
	RThread thread;
	aRequest->Message().Client(thread, EOwnerThread);
	aRequest->SetScratchValue((TUint)(thread.Id()));
	thread.Close();
	
	return KErrNone;
	}

/**
open the plugin
*/
TInt TFsPluginOpen::DoRequestL(CFsRequest* aRequest)
	{
	TInt pluginPos = aRequest->Message().Int0();
	CFsPluginConn* pC = FsPluginManager::CreatePluginConnL(pluginPos, aRequest->ScratchValue());

	TInt handle = aRequest->Session()->Handles().AddL(pC,ETrue);
	TPtrC8 pH((TUint8*)&handle, sizeof(TInt));
	aRequest->WriteL(KMsgPtr3, pH);
	aRequest->Session()->IncResourceCount();
	
	return KErrNone;
	}

/**
Initialising the plugin control
*/
LOCAL_C TInt InitPluginControl(CFsRequest* aRequest)
	{
	CFsPluginConn* pC = FsPluginManager::GetPluginConnFromHandle(aRequest->Session(), aRequest->Message().Int3());
	if(pC == NULL)
		return KErrBadHandle;

	aRequest->iCurrentPlugin = pC->Plugin();
	aRequest->SetDriveNumber(-1);

	CFsPluginConnRequest* request = new CFsPluginConnRequest(pC);
	if(request == NULL)
		return KErrNoMemory;

	aRequest->SetScratchValue((TUint)request);
	return KErrNone;
	}

/**
Initialises the plugin control and gets the request
*/
TInt TFsPluginDoControl::Initialise(CFsRequest* aRequest)
	{
	TInt err = InitPluginControl(aRequest);
	if(err != KErrNone)
		return err;

	CFsPluginConnRequest* request = (CFsPluginConnRequest*)aRequest->ScratchValue();
	return request->InitControl(aRequest);
	}

/**
does handle the control request
*/
TInt TFsPluginDoControl::DoRequestL(CFsRequest* aRequest)
	{
	CFsPluginConnRequest* pRequest = (CFsPluginConnRequest*)aRequest->ScratchValue();	
	TInt r = pRequest->DoControl();
	delete pRequest;
	return r;
	}


/**
Initialises the request 
*/
TInt TFsPluginDoRequest::Initialise(CFsRequest* aRequest)
	{
	TInt err = InitPluginControl(aRequest);
	if(err != KErrNone)
		return err;

	CFsPluginConnRequest* request = (CFsPluginConnRequest*)aRequest->ScratchValue();
	return request->InitRequest(aRequest);
	}

/**
Handles the request adding it to the queue of the requests
*/
TInt TFsPluginDoRequest::DoRequestL(CFsRequest* aRequest)
	{
	CFsPluginConnRequest* pRequest = (CFsPluginConnRequest*)aRequest->ScratchValue();	
	pRequest->DoRequest();
	return KErrNone;
	}

/**
Initialises the request
*/
TInt TFsPluginDoCancel::Initialise(CFsRequest* aRequest)
	{
	CFsPluginConn* pC = FsPluginManager::GetPluginConnFromHandle(aRequest->Session(), aRequest->Message().Int3());
	if(pC == NULL)
		return KErrBadHandle;

	aRequest->iCurrentPlugin = pC->Plugin();
	aRequest->SetDriveNumber(-1);
	aRequest->SetScratchValue((TUint)pC);
	
	return KErrNone;
	}

/**
Cancels the outstanding request
*/
TInt TFsPluginDoCancel::DoRequestL(CFsRequest* aRequest)
	{
	CFsPluginConn* pC = (CFsPluginConn*)aRequest->ScratchValue();	
	pC->DoCancel(aRequest->Message().Int0());
	return KErrNone;
	}