// 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_drv.cpp

// 

//

#include "sf_std.h"

#include "sf_file_cache.h"

//const TInt KMaxNotifierAttempts=4; // not used anywhere

static TPtrC StripBackSlash(const TDesC& aName)

//

// If aName ends in a backslash, strip it.

//

	{

	__ASSERT_DEBUG(aName.Length(),Fault(EStripBackSlashBadName));

	if (aName[aName.Length()-1]==KPathDelimiter)

		return(aName.Left(aName.Length()-1));

	return(aName);

	}

static void CheckSubClose(CFsObject* anObj,TInt aHandle, CSessionFs* aSession)

//

// Close anObj if its not NULL.

//

	{

	__PRINT1(_L("CheckSubClose() session 0x0%x"),aSession);

	__PRINT1(_L("CheckSubClose() anObj 0x0%x"),anObj);

	if(!anObj)

		return;

	if(aHandle==0)

		{

		// can't have been added to the object index

		__ASSERT_DEBUG(KErrNotFound==aSession->Handles().At(anObj,ETrue),Fault(ESubOpenBadHandle));

		anObj->Close();

		}

	else

		aSession->Handles().Remove(aHandle,ETrue);

	}

TInt ValidateDrive(TInt aDriveNumber,CFsRequest* aRequest)

//

// Validate a drive number and set iTheDrive.

//

	{

	if (aDriveNumber==KDefaultDrive)

		aDriveNumber=aRequest->Session()->CurrentDrive();

	if (!RFs::IsValidDrive(aDriveNumber))

		return(KErrBadName);

	aRequest->SetDrive(&TheDrives[aDriveNumber]);

	return(KErrNone);

	}

TInt ValidateDriveDoSubst(TInt aDriveNumber,CFsRequest* aRequest)

//

// Validate a drive number and set iTheDrive.

//

	{

	TInt r=ValidateDrive(aDriveNumber,aRequest);

	if (r!=KErrNone)

		return(r);

	if (aRequest->Drive()->IsSubsted())

		{

		aRequest->SetSubstedDrive(aRequest->Drive());

		aRequest->SetDrive(&aRequest->Drive()->SubstedDrive());

		}

	return(KErrNone);

	}

void ValidateAtts(TUint& aSetAttMask,TUint& aClearAttMask)

//

// Do not allow the entry type to be changed

//

	{

	const TUint KReadOnlyAtts = KEntryAttVolume	| 

								KEntryAttDir	| 

								KEntryAttRemote	|

								KEntryAttModified;

	aSetAttMask   &= ~KReadOnlyAtts;

	aClearAttMask &= ~KReadOnlyAtts;

	}

void CheckForLeaveAfterOpenL(TInt leaveError, CFsRequest* aRequest, TInt aHandle)

//

// Tidy up in the event of a leave after opening a file or directory

	{

	if (leaveError)

		{

		CFsObject* anObj=(CFsObject* )aRequest->ScratchValue();

		CheckSubClose(anObj,aHandle,aRequest->Session());

		User::Leave(leaveError);

		}

	}

TDrive::TDrive()

//

// Constructor.

//

	: iDriveNumber(0),iAtt(0),iChanged(EFalse),

	  iFSys(NULL),iCurrentMount(NULL),iSubstedDrive(NULL),iSubst(NULL),

	  iMount(NULL),iDriveFlags(0),iMountFailures(0)

	{}

void TDrive::CreateL(TInt aDriveNumber)

//

// Allocate the drive number and any resources.

//

	{

	__PRINT1(_L("TDrive::CreateL(%d)"),aDriveNumber);

	iDriveNumber=aDriveNumber;

	iMount=TheContainer->CreateL();

	TInt r=iLock.CreateLocal();

	User::LeaveIfError(r);

	}

TInt TDrive::CheckMountAndEntryName(const TDesC& aName)

//

// Check drive is mounted then check aName is legal

//

	{

	__PRINT1(_L("TDrive::CheckMountAndEntryName Drive%d"),DriveNumber());

	TInt r=CheckMount();

	if (r==KErrNone && IsIllegalFullName(aName))

		return(KErrBadName);

	return(r);

	}

void TDrive::MultiSlotDriveCheck()

	{

	// Check whether the current drive is a dual-slot/multi-slot

	// if so, we need to check which drive is connected now and 

	// swap the mapping in LocalDrives::iMapping such that the 

	// mapping of driveNumber to localDriveNumber is correct.

	Lock();

	//Is this a multislot drive?

	if(LocalDrives::iIsMultiSlotDrive[iDriveNumber])

		{

		for(TInt localDrvNum=0; localDrvNum<KMaxLocalDrives; localDrvNum++)

			{

			// ensure that this local drive is a multi-slot choice for this drive number..

			if(LocalDrives::iReverseMapping[localDrvNum]==iDriveNumber)

				{

				// Caps - find out which one is connected

				TLocalDriveCapsBuf capsInfo;

				TInt r = LocalDrives::iLocalDrives[localDrvNum].Caps(capsInfo);

				if(r==KErrNotReady)

					{

					continue; //go to next localdrive

					}

				//found a connected drive

				//Update mapping

				#ifdef _DEBUG

				RDebug::Print(_L("Multislot drive mapping update: DriveNum %d to LocDrv %d"),iDriveNumber,localDrvNum);

				#endif

				LocalDrives::iMapping[iDriveNumber] = localDrvNum;

				break; // Swap complete - don't look any further

				}

			}

		}	

	UnLock();

	}

TInt TDrive::CheckMount()

//

// Check the drive and try to mount a media if not already mounted.

//

	{

	__PRINT2(_L("TDrive::CheckMount Drive%d, changed:%d"),DriveNumber(), iChanged);

	__CHECK_DRIVETHREAD(iDriveNumber);

	if (!iFSys)

		return KErrNotReady;

	if (iChanged)				//	If a media change has occurred

		{

		iMountFailures = 0;

		iChanged=EFalse;		//	Reset the flag

		if (IsMounted())		//	Dismount the mount if it is still marked as mounted

			{

            DoDismount();

			}

		//If we have a dual/multi removable media slot then we may need to

		//swop the mappings.

		MultiSlotDriveCheck();

		}

	if (!IsMounted())				//	Checks that iCurrentMount!=NULL

		{

		__PRINT(_L("TDrive::CheckMount() Not Mounted"));

        const TInt KMaxMountFailures = 3;

		// if we've repeatedly failed to mount, give up until a media change

		if (iMountFailures >= KMaxMountFailures)

			{

			__PRINT1(_L("TDrive::CheckMount() retries exceeded, last Err:%d"), iLastMountError);

			return iLastMountError;

			}

		if (!ReMount())	    //	Have we just remounted a mount we have previously encountered?

			{			

			MountFileSystem(EFalse);	//	If not, mount it for the first time now

			}

		else if(IsWriteProtected() && IsWriteableResource())

			{

			DoDismount();

			return KErrAccessDenied;

			}

		}

	if (iReason==KErrNone && CurrentMount().LockStatus() > 0)

	    {

    	//-- this means that the mount has drive access objects opened (RFormat or RRawDisk)

        __PRINT1(_L("TDrive::CheckMount() Mount is locked! LockStaus:%d"), CurrentMount().LockStatus());

        return KErrInUse;

	    }	

	__PRINT1(_L("TDrive::CheckMount returned %d "),iReason);

	return(iReason);

	}

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

/**

    Try and re-mount any of the pending media

    @return ETrue if the mount matching media found and been attached back (set as iCurrentMount)

*/

TBool TDrive::ReMount()

	{

	const TInt mCount=Mount().Count();

    __PRINT1(_L("TDrive::ReMount() MountCnt:%d"), mCount);

	const TInt u=(Mount().UniqueID()<<16);

	iReason=KErrNone;

    //-- try every instance of CMountCB that is associated with this object of TDrive.

    //-- mounts are stored in the container of mCount elements.

    //-- if some CMountCB recognises the media it belongs, it means that "remount succeded"

    for(TInt i=0; i<mCount; i++)

		{

		CMountCB* pM=(CMountCB*)Mount().At(u|i);

        if (ReMount(*pM))

			return ETrue;

		}

	return EFalse;

	}

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

/**

    Try and re-mount the specified media.

    @return ETrue if remounting succeeded - i.e. the CMountCB instance that matches the media is found in the 

    mounts container (Mount()) and bound to the media.

*/

TBool TDrive::ReMount(CMountCB& aMount)

	{

	__PRINT1(_L("TDrive::ReMount(0x%x)"), &aMount);

	iReason=KErrNone;

	if (!aMount.IsDismounted() && !aMount.ProxyDriveDismounted())

		{

		aMount.SetDrive(this);

        //-- actually, this is asking CMountCB to see if it belongs to the current media. 

        iReason = aMount.ReMount();

        if (iReason == KErrNone)	//	ReMount succeeded

			{

			aMount.Open();

			iCurrentMount = &aMount;

			__PRINT1(_L("TDrive::ReMount for Mount:0x%x OK!"), &aMount);

			return ETrue;

			}

		__PRINT2(_L("TDrive::ReMount for Mount:0x%x failed iReason=%d"),&aMount,iReason);

		}

	else

		{

		__PRINT1(_L("TDrive::ReMount() failed - Mount:0x%x is dismounted"), &aMount);

		}

	return EFalse;

	}

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

/**

    Mount the media on the drive. Optionally force a bad media to be mounted.

    @param  apMount     out: pointer to the produced CMountCB object; NULL if the CMountCB is not constructed

    @param  aForceMount if ETrue, the filesystem will be forcedly mounted on the drive, disregarding what it contains. 

    @param  aFsNameHash file system name hash; see TDrive::MountFileSystem()   

*/

void TDrive::DoMountFileSystemL(CMountCB*& apMount, TBool aForceMount, TUint32 aFsNameHash)

	{

	CFileSystem* pMountsFs = NULL; //-- reference to the filesystem that will be producing CMountCB

    apMount = NULL;

    //-- construct a new CmountCB object.

    //-- on return pMountsFs will be the pointer to the factory object of CFileSystem that produced this mount

    apMount = FSys().NewMountExL(this, &pMountsFs, aForceMount, aFsNameHash);

	__PRINT2(_L("TDrive::MountMediaL created mount:0x%x FileSys:0x%x"), apMount, pMountsFs);

    ASSERT(pMountsFs && apMount);

	apMount->SetMountNumber(iMountNumber++);

    apMount->InitL(*this, pMountsFs);  //-- initialise Mount

    apMount->MountL(aForceMount);      //-- mount the file system  

	Mount().AddL(apMount,EFalse);      //-- add mount object to the mounts container.  

	iCurrentMount=apMount;

    }

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

/*

	Mount file system on the drive. 

	@param  aForceMount if EFalse, will try to mount the file system normally, the file system implementation will decide if it can work on this drive or not.

                        if ETrue, will mount the file suystem by force, this is used mostly for formatting unrecognisable media.

    @param  aFsNameHash optional parameter. Can specify the concrete file system name (hash). It can be used to force mounting  some specific

                        file system. Default value '0' means "not specified / not used"

    TDrive::iReason on return contains the operation result code.

*/

void TDrive::MountFileSystem(TBool aForceMount, TUint32 aFsNameHash /*=0*/ )

	{

	__PRINT2(_L("TDrive::MountFileSystem aForceMount=%d, FSNameHash:0x%x"),aForceMount, aFsNameHash);

	__CHECK_DRIVETHREAD(iDriveNumber);

    iCurrentMount=NULL;

	if(!iFSys)

		{

		iReason=KErrNotReady;

		return;

		}

    CMountCB* pM=NULL;

    TRAP(iReason, DoMountFileSystemL(pM, aForceMount, aFsNameHash));

	if (iReason == KErrNone)

		{

		iMountFailures = 0;

		ASSERT(iCurrentMount);

        }

	else

		{

		iLastMountError = iReason;

		iMountFailures++;

		__PRINT2(_L("TDrive::MountFileSystem 0x%x failed iReason=%d"),pM,iReason);

		if(pM)

			pM->Close();

        ASSERT(!iCurrentMount);

        }

	}

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

/**

    Generic mount control method.

    @param  aLevel  specifies the operation to perfrom on the mount

    @param  aOption specific option for the given operation

    @param  aParam  pointer to generic parameter, its meaning depends on aLevel and aOption

    @return standard error code.

*/

TInt TDrive::MountControl(TInt aLevel, TInt aOption, TAny* aParam)

    {

    TInt r = CurrentMount().MountControl(aLevel, aOption, aParam);

	return r;

    }

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

/**

    Request aFreeSpaceRequired free bytes from the mount associated with this drive.

    The volume free space on for some filesystems can be changing (usually increasing) after it has been mounted.

    If the mount supports this functionality, it can block this call until certain number of free bytes encounted if its free

    space calculation activity hasn't finished yet.

    @param  aFreeSpaceRequired  required free space, bytes.

    @return KErrNone        on success and if there is at least aFreeSpaceRequired bytes on the volume

            KErrDiskFull    on success and if there is no aFreeSpaceRequired bytes on the volume

            system-wide error code otherwise

*/

TInt TDrive::RequestFreeSpaceOnMount(TUint64 aFreeSpaceRequired)

    {

    TInt nRes;

    nRes = CheckMount();

    if(nRes != KErrNone)

        return nRes;

    //-- 1. Try mount-specific request first. If the mount is still performing free space calculations,

    //-- the caller will be suspended until aFreeSpaceRequired bytes is available or scanning process finishes

    {

        TUint64 freeSpaceReq = aFreeSpaceRequired;

        nRes = CurrentMount().RequestFreeSpace(freeSpaceReq);

        if(nRes == KErrNone)

            {

            return (freeSpaceReq >= aFreeSpaceRequired) ? KErrNone : KErrDiskFull;

            }

    }

    //-- given Mount doesn't support this functionality, use legacy method

    TVolumeInfo volInfo;

    nRes = Volume(volInfo);

    if(nRes !=KErrNone)

        return nRes;

    return ((TUint64)volInfo.iFree >= aFreeSpaceRequired) ? KErrNone : KErrDiskFull;

    }

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

/**

    Get size of the mounted volume. It can be less than physical volume size because FileSystem data may occupy some space.

    @param  aSize on success mounted volume size in bytes will be returned there

    @return KErrNone on success, standard error code otherwise

*/

TInt TDrive::MountedVolumeSize(TUint64& aSize)

    {

    TInt nRes;

    nRes = CheckMount();

    if(nRes != KErrNone)

        return nRes;

    //-- 1. Try mount-specific request first. It won't block this call as CMountCB::VolumeL() can do if some background activity is going on the mount

    nRes = CurrentMount().MountedVolumeSize(aSize);

    if(nRes == KErrNone)

        return nRes;

    //-- given Mount doesn't support this functionality, use legacy method

    TVolumeInfo volInfo;

    nRes = Volume(volInfo);

    if(nRes == KErrNone)

        {

        aSize = volInfo.iSize;

        }

    return nRes;

    }

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

/**

    Get _current_ amount of free space on the volume. Some mounts implementations can be updating the amount of free space

    in background. 

    @param  aFreeDiskSpace on success will contain a current amount of free space

    @return KErrNone on success, standard error code otherwise

*/

TInt TDrive::FreeDiskSpace(TInt64& aFreeDiskSpace)

	{

    TInt nRes;

    nRes = CheckMount();

    if(nRes != KErrNone)

        return nRes;

    //-- 1. Try mount-specific request first. It won't block this call as CMountCB::VolumeL() can do 

    nRes = CurrentMount().GetCurrentFreeSpaceAvailable(aFreeDiskSpace);

    if(nRes == KErrNone)

        return nRes;

    //-- given Mount doesn't support this functionality, use legacy method

    TVolumeInfo volInfo;

    nRes = Volume(volInfo);

    if(nRes == KErrNone)

        {

        aFreeDiskSpace = volInfo.iFree;

        }

    return nRes;

	}

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

/**

    Finalise drive (the mount).

    @param  aOperation  describes finalisation operation ,see RFs::TFinaliseDrvMode

    @param  aParam1     not used, for future expansion