// Copyright (c) 2002-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_ext.cpp

// 

//

#include "sf_std.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "sf_extTraces.h"

#endif

typedef CProxyDriveFactory*(*TExtensionNew)();

typedef CExtProxyDriveFactory*(*TProxyDriveNew)();

/**

Constructor.

Initialises drive extension count to zero.

*/

TDriveExtInfo::TDriveExtInfo(){iCount=0;}

/**

Constructor.

Note that the class is intended only as an abstract base for other classes.

@panic FSERV 51 if the supplied CMountCB pointer is NULL.

*/

CProxyDrive::CProxyDrive(CMountCB* aMount)

:iMount(aMount)

	{

//	__ASSERT_DEBUG(iMount!=NULL,Fault(EProxyDriveConstruction));

	}

/**

Destructor.

Frees resources before destruction of the object.

*/

CProxyDrive::~CProxyDrive()

	{

	delete iBody;

	}

/**

An interface with which control commands can be passed to 

the appropriate driver layer.

This base implementation performs no operations.

@param aMessage Message to be sent.

@param aCommand Command type.

@param aParam1  1st parameter of control message.

@param aParam2  2nd parameter of control message.

@return KErrNone

*/

EXPORT_C TInt CProxyDrive::ControlIO(const RMessagePtr2& /*aMessage*/,TInt /*aCommand*/,TAny* /*aParam1*/,TAny* /*aParam2*/)

//

// General purpose function for use by specific file systems and extensions

//

	{

	return(KErrNone);

	}

/**

General purpose read function for use by specific file systems and extensions.

This base implementation performs no operations.

@param aPos    The address from where the read begins.

@param aLength The length of the read.

@param aTrg    A descriptor of the memory buffer from which to read.

@param aThreadHandle The handle-number representing the drive thread.

@param aOffset Offset into aTrg to read the data from.

@param aFlags  Flags to be passed into the driver.

@return KErrNone

*/

EXPORT_C TInt CProxyDrive::Read(TInt64 /*aPos*/,TInt /*aLength*/,const TAny* /*aTrg*/,TInt /*aThreadHandle*/,TInt /*aOffset*/, TInt /*aFlags*/)

	{

	return(KErrNone);

	}

/**

General purpose write function for use by specific file systems and extensions.

This base implementation performs no operations.

@param aPos    The address from where the write begins.

@param aLength The length of the write.

@param aSrc    A descriptor of the memory buffer from which to write.

@param aThreadHandle The handle-number representing the drive thread.

@param aOffset Offset into aSrc to write the data to.

@param aFlags  Flags to be passed into the driver.

@return KErrNone

*/

EXPORT_C TInt CProxyDrive::Write(TInt64 /*aPos*/,TInt /*aLength*/,const TAny* /*aSrc*/,TInt /*aThreadHandle*/,TInt /*aOffset*/, TInt /*aFlags*/)

	{

	return(KErrNone);

	}

/**

Issue a notification that a physical delete has occurred. 

For example a cluster or partition has been freed.

This base implementation performs no operations.

@param aPos    The position of the data which is being deleted.

@param aLength The length of the data which is being deleted.

@return KErrNone

*/

EXPORT_C TInt CProxyDrive::DeleteNotify(TInt64 /*aPos*/, TInt /*aLength*/)

	{

	return(KErrNone);

	}

/**

An interface with which information can be retrieved about disk errors.

This base implementation performs no operations.

@param aErrorInfo Reference to a descriptor containing disk error information.

@return KErrNone

*/	

EXPORT_C TInt CProxyDrive::GetLastErrorInfo(TDes8& /*aErrorInfo*/)

	{

	return(KErrNotSupported);

	}

EXPORT_C TInt CProxyDrive::GetLocalDrive(TBusLocalDrive*& aLocDrv)

	{

	return (GetInterface(EGetLocalDrive, (TAny*&)aLocDrv, (TAny*)this));	// this GetInterface does the dirty work for you...

	}

EXPORT_C TInt CProxyDrive::Finalise(TBool aIsFinalised)

	{

	TAny* dummyInterface;

	return (GetInterface(EFinalised, dummyInterface, (TAny*)aIsFinalised));

	}

/**

Called to get a Proxy drive interface.

@param aInterfaceId Interface identifier of the interface to be retrieved.

@param aInterface Address of variable that retrieves the specified interface.

@param aInput Data required for the instantiation of the interface.

This base implementation performs no operations.

@return KErrNotSupported

*/	

EXPORT_C TInt CProxyDrive::GetInterface(TInt /*aInterfaceId*/,TAny*& /*aInterface*/,TAny* /*aInput*/)

	{

	return(KErrNotSupported);

	}	

TInt CProxyDrive::SetAndOpenLibrary(RLibrary aLibrary)

	{

	TInt r = KErrNone;

	if (iBody)

		{

		iBody->iLibrary = aLibrary;

		r = iBody->iLibrary.Duplicate(RThread(), EOwnerProcess);

		}

	return r;

	}

/**

Gets a copy of the Proxy Drive library (previously opened by OpenLibrary()) prior to deleting the proxy drive itself.

After deleting the proxy drive, RLibrary::Close() should be called on the returned RLibrary object.

*/

RLibrary CProxyDrive::GetLibrary()

	{

	RLibrary lib;

	if (iBody)

		{

		lib = iBody->iLibrary;

		iBody->iLibrary.SetHandle(NULL);

		}

	return lib;

	}

/**

Constructor.

*/

EXPORT_C CLocDrvMountCB::CLocDrvMountCB() {}

/**

Destructor.

Frees assigned Proxy drive before destruction of the object.

*/

EXPORT_C CLocDrvMountCB::~CLocDrvMountCB()

	{

	__PRINT1(_L("CLocDrvMountCB::~CLocDrvMountCB() 0x%x"),this);

	if(iProxyDrive && !LocalDrives::IsProxyDrive(Drive().DriveNumber()))

		{

		RLibrary lib = iProxyDrive->GetLibrary();

		delete iProxyDrive;

		lib.Close();

		}

	}

/**

Creates and initialises the local drive.

@param aLocDrv The local drive to be created

@return System wide error code.

*/		

EXPORT_C TInt CLocDrvMountCB::CreateLocalDrive(TBusLocalDrive& aLocDrv)

	{

	__PRINT(_L("CLocDrvMountCB::CreateLocalDrive()"));

	if(iProxyDrive!=NULL)

		return(KErrNone);

	TInt r;

	CProxyDrive* pConcrete=CLocalProxyDrive::New(this,aLocDrv);

	if(pConcrete==NULL)

		{

		r=KErrNoMemory;

		}

	else

		{

		// if failure then pConcrete will be deleted by CreateProxyDriveL()

		TRAP(r,iProxyDrive=CreateProxyDriveL(pConcrete,this));	

		}

	if(r==KErrNone)

		r=InitLocalDrive();

	__PRINT1(_L("CreateLocalDrive r=%d"),r);

	return(r);

	}

EXPORT_C TInt CLocDrvMountCB::CreateDrive(TInt aDriveNumber)

/** Create drive

	Ascertain if the drive is mapped to a local drive or a proxy drive, and create the drive

	as appropriate

	@param	aDriveNumber	drive number

	@return	KErrNone		on success

			KErrArgument	if the drive is not mapped to a proxy or a local drive or if the number

							is invalid

*/

	{

	// dunno why we are using TInts instead of TUints here

	__PRINT(_L("CLocDrvMountCB::CreateDrive()"));

	if (aDriveNumber<0 || aDriveNumber>=KMaxDrives) return KErrArgument;

	TInt r = KErrNone;

	TInt aDriveLocal = LocalDrives::DriveNumberToLocalDriveNumber(aDriveNumber);

	if (aDriveLocal == KDriveInvalid) return KErrArgument;

	if (aDriveLocal < KMaxLocalDrives)

		{

		return CreateLocalDrive(LocalDrives::GetLocalDrive(aDriveNumber));	// drive is really local

		}

	else

		{

		CExtProxyDrive* pProxyDrive = LocalDrives::GetProxyDrive(aDriveNumber);

		__ASSERT_ALWAYS(pProxyDrive != NULL,User::Panic(_L("CreateDrive() - pProxyDrive == NULL"), -999));

		TRAP(r, iProxyDrive = CreateProxyDriveL(pProxyDrive,this));

		__ASSERT_ALWAYS(r == KErrNone,User::Panic(_L("CreateDrive() - CreateProxyDriveL error"), -999));

		r = InitLocalDrive();

		}

	return r;

	}

/**

Initialise the local drive

@panic FSERV 52 if initialise when no local drive exists.

@return system wide error code

*/

EXPORT_C TInt CLocDrvMountCB::InitLocalDrive()

	{

	__ASSERT_ALWAYS(iProxyDrive!=NULL,Fault(ELocDrvInitLocalDrive));

	iProxyDrive->SetMount(this);

	return(iProxyDrive->Initialise());

	}

/**

Dismount the local drive

@panic FSERV 53 if dismount when no local drive exists.

*/

EXPORT_C void CLocDrvMountCB::DismountedLocalDrive()

	{

	__ASSERT_ALWAYS(iProxyDrive!=NULL,Fault(ELocDrvDismountedLocalDrive));

	iProxyDrive->Dismounted();

	}

/**

static constructor.

Instatiates a CLocalProxyDrive objects with the given arguments.

@param aMount The mount control block

@param aLocDrv The local drive.

@return pointer to instantiated CLocalProxyDrive object.

*/

CLocalProxyDrive* CLocalProxyDrive::New(CMountCB* aMount,TBusLocalDrive& aLocDrv)

	{

	OstTraceExt2(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVENEW, "aMount %x drive %d", (TUint) aMount, (TUint) aMount->DriveNumber());

	CLocalProxyDrive* proxyDrive = new CLocalProxyDrive(aMount,aLocDrv);

	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVENEWRET, "proxyDrive %x", proxyDrive);

	return proxyDrive;

	}

/**

Constructor.

@param aMount The mount control block.

@param aLocDrv The local drive.

*/

CLocalProxyDrive::CLocalProxyDrive(CMountCB* aMount,TBusLocalDrive& aLocDrv)

:CProxyDrive(aMount),iLocDrv(aLocDrv)

	{

	__PRINT(_L("CLocalProxyDrive::CLocalProxyDrive()"));

	}

/**

Initialise the connected drive.

This implementation performs no operations.

@return KErrNone.

*/

TInt CLocalProxyDrive::Initialise()

	{

	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEINITIALISE, "this %x", this);

	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEINITIALISERET, "r %d", KErrNone);

	return(KErrNone);

	}

/**

Ensures any cached data is flushed before unmounting drive.

This implementation performs no operations.

@return KErrNone.

*/

TInt CLocalProxyDrive::Dismounted()

	{

	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEDISMOUNTED, "this %x", this);

	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEDISMOUNTEDRET, "r %d", KErrNone);

	return(KErrNone);

	}

/**

Increase the size of the connected drive by the specified length (in bytes).

@param aLength The length/size (in bytes) by which the drive is to be increased.

@return system wide error code.

*/

TInt CLocalProxyDrive::Enlarge(TInt aLength)

	{

	OstTraceExt2(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEENLARGE, "this %x aLength %d", (TUint) this, (TUint) aLength);

	TInt r = iLocDrv.Enlarge(aLength);

	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEENLARGERET, "r %d", r);

	return r;

	}

/**

Reduce the size of the connected drive by removing the specified length

(in bytes) starting at the specified position.

Refer to relevant media driver documentation for implementation/restriction 

notes.

@param aPos    The start position of area to be removed.

@param aLength The length of the data which is being removed.

@return system wide error code.

*/

TInt CLocalProxyDrive::ReduceSize(TInt aPos, TInt aLength)

	{

	OstTraceExt3(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEREDUCESIZE, "this %x aPos %x aLength %d", (TUint) this, (TUint) aPos, (TUint) aLength);

	TInt r = iLocDrv.ReduceSize(aPos,aLength);

	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEREDUCESIZERET, "r %d", r);

	return r;

	}

/**

Read from the connected drive, and pass flags to driver.

@param aPos    The address from where the read begins.

@param aLength The length of the read.

@param aTrg    A descriptor of the memory buffer from which to read.

@param aThreadHandle The handle-number representing the drive thread.

@param aOffset Offset into aTrg to read the data from.

@param aFlags  Flags to be passed into the driver.

@return system wide error code.

*/

TInt CLocalProxyDrive::Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aThreadHandle,TInt aOffset, TInt aFlags)

	{

	TRACETHREADIDH(aThreadHandle);

	OstTraceExt5(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEREAD1, "this %x clientThreadId %x aPos %x:%x aLength %d", (TUint) this, (TUint) threadId, (TUint) I64HIGH(aPos), (TUint) I64LOW(aPos), aLength);

	TInt r = iLocDrv.Read(aPos,aLength,aTrg,aThreadHandle,aOffset,aFlags);

	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEREAD1RET, "r %d", r);

	return r;

	}

/**

Read from the connected drive.

@param aPos    The address from where the read begins.

@param aLength The length of the read.

@param aTrg    A descriptor of the memory buffer from which to read.

@param aThreadHandle The handle-number representing the drive thread.

@param aOffset Offset into aTrg to read the data from.

@return system wide error code.

*/

TInt CLocalProxyDrive::Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aThreadHandle,TInt anOffset)

	{

	TRACETHREADIDH(aThreadHandle);

	OstTraceExt5(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEREAD2, "this %x clientThreadId %x aPos %x:%x aLength %d", (TUint) this, (TUint) threadId, (TUint) I64HIGH(aPos), (TUint) I64LOW(aPos), aLength);

	TInt r = iLocDrv.Read(aPos,aLength,aTrg,aThreadHandle,anOffset);

	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEREAD2RET, "r %d", r);

	return r;

	}

/**

Read from the connected drive.

@param aPos    The address from where the read begins.

@param aLength The length of the read.

@param aTrg    A descriptor of the memory buffer from which to read.

@return system wide error code.

*/

TInt CLocalProxyDrive::Read(TInt64 aPos,TInt aLength,TDes8& aTrg)

	{

	OstTraceExt5(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEREAD3, "this %x aPos %x:%x aLength %d aTrg %x", (TUint) this, (TUint) I64HIGH(aPos), (TUint) I64LOW(aPos), aLength, (TUint) &aTrg);

	TInt r = iLocDrv.Read(aPos,aLength,aTrg);

	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEREAD3RET, "r %d", r);

	return r;

	}

/**

Write to the connected drive and pass flags to driver.

@param aPos    The address from where the write begins.

@param aLength The length of the write.

@param aSrc    A descriptor of the memory buffer from which to write.

@param aThreadHandle The handle-number representing the drive thread.

@param aOffset Offset into aSrc to write the data to.

@param aFlags  Flags to be passed into the driver.

@return system wide error code.

*/

TInt CLocalProxyDrive::Write(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt aThreadHandle,TInt aOffset,TInt aFlags)

	{

	TRACETHREADIDH(aThreadHandle);

	OstTraceExt5(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEWRITE1, "this %x clientThreadId %x aPos %x:%x aLength %d", (TUint) this, (TUint) threadId, (TUint) I64HIGH(aPos), (TUint) I64LOW(aPos), aLength);

	TInt r = iLocDrv.Write(aPos,aLength,aSrc,aThreadHandle,aOffset,aFlags);

	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEWRITE1RET, "r %d", r);

	return r;

	}

/**

Write to the connected drive.

@param aPos    The address from where the write begins.

@param aLength The length of the write.

@param aSrc    A descriptor of the memory buffer from which to write.

@param aThreadHandle The handle-number representing the drive thread.

@param aOffset Offset into aSrc to write the data to.

@return system wide error code.

*/

TInt CLocalProxyDrive::Write(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt aThreadHandle,TInt anOffset)

	{

	TRACETHREADIDH(aThreadHandle);

	OstTraceExt5(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEWRITE2, "this %x clientThreadId %x aPos %x:%x aLength %d", (TUint) this, (TUint) threadId, (TUint) I64HIGH(aPos), (TUint) I64LOW(aPos), aLength);

	TInt r = iLocDrv.Write(aPos,aLength,aSrc,aThreadHandle,anOffset);

	OstTrace1(TRACE_DRIVE, PROXYDRIVE_ECLOCALPROXYDRIVEWRITE2RET, "r %d", r);

	return r;

	}

/**

Write to the connected drive.