// 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:
//

#include "sf_std.h"




/**
Default constructor.
*/
EXPORT_C CMountCB::CMountCB()
	              :iMountQ(_FOFF(CFileCB,iMountLink))
	{
    __PRINT1(_L("CMountCB::CMountCB()[0x%x]"),this);
	}




EXPORT_C CMountCB::~CMountCB()
	{
	__PRINT1(_L("CMountCB::~CMountCB()[0x%x]"),this);
	delete iBody;
	delete iVolumeName;
	}


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

/**
    Compares the specified mount control block with this one for inequality.

    Two mount control blocks are different if either the addresses of
    the mount control blocks ar different, or their iMountNumber values
    are different.

    @param aMount The mount control block to be compared.

    @return True, if the mount control blocks are different, false otherwise.
*/
EXPORT_C TBool CMountCB::operator!=(const CMountCB& aMount) const
	{

	if (this==(&aMount) && MountNumber()==aMount.MountNumber())
		return(FALSE);
	return(TRUE);
	}


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

/**
    Tests whether the given attribute mask matches given criteria (specified
    in another mask).

    This function is used when filtering entries. aMatt specifies the criteria
    to be matched by anAtt.

    Volumes are ignored, so if anAtt has the volume attribute set then
    the function returns false.

    If aMatt does not have a hidden (KEntryAttHidden), system (KEntryAttSystem),
    or directory (KEntryAttDir) attribute set and anAtt does have
    the corresponding attribute set, then the function returns false.
    Alternatively, if aMatt has KEntryAttMustBeFile set and anAtt has
    the directory attribute set, then the function also returns EFalse.

    Further matching behaviour can be implemented using
    KEntryAttMatchExclusive and KEntryAttMatchExclude.

    @param anAtt Attribute mask to be tested.
    @param aMatt The attribute match mask.

    @return True, if the anAtt entry attributes match, false otherwise.

    @see KEntryAttHidden
    @see KEntryAttSystem
    @see KEntryAttDir
    @see KEntryAttMustBeFile
    @see KEntryAttMatchExclusive
    @see KEntryAttMatchExclude
*/
EXPORT_C TBool CMountCB::MatchEntryAtt(TUint anAtt,TUint aMatt) const
    {
	if (aMatt&KEntryAttMatchExclude)
		{ // Include any except
		if ((anAtt&aMatt)==0)
			return(ETrue);
		return(EFalse);
		}

	anAtt&=KEntryAttMaskSupported;
	if ((aMatt&KEntryAttMustBeFile) && (anAtt&KEntryAttIllegal))
		return(EFalse); // Not a file

	if ((aMatt&KEntryAttHidden)==0 && (anAtt&KEntryAttHidden))
		return(EFalse); // Ignore hidden unless requested
	if ((aMatt&KEntryAttSystem)==0 && (anAtt&KEntryAttSystem))
		return(EFalse); // Ignore system unless requested
	if ((aMatt&KEntryAttDir)==0 && (anAtt&KEntryAttDir))
		return(EFalse); // Ignore directory unless requested
	if (anAtt&KEntryAttVolume)
		return(EFalse); // Ignore volumes

	anAtt&=(~(KEntryAttHidden|KEntryAttSystem)); // remove hidden and system

	if (aMatt&KEntryAttMatchExclusive)
		{ // Exclude all except
		if ((anAtt&aMatt)!=0)
			return(ETrue);
		return(EFalse);
		}
	return(ETrue);
	}



//-----------------------------------------------------------------------------
/**
    Gets the address of the specified file if it is found in ROM. 

    The default implementation sets aFileStart to NULL, and this should only
    be overridden by ROM file systems.

    @param aFileName  A reference to a descriptor containing the full file name.
    @param aFileStart On return, the address of the file, aFileName.
                      The default implementation returns NULL.
*/
EXPORT_C void CMountCB::IsFileInRom(const TDesC& /*aFileName*/,TUint8*& aFileStart)
	{

	aFileStart=NULL;
	}


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

/**
    Notifies the file server that the free disk space of the mounted volume
    has changed outside of the standard file system operations.

    For example, the background thread of the log flash file system will call
    this function after a background roll-forward.

    @param aFreeSpace New free disk space value.
*/
EXPORT_C void CMountCB::SetDiskSpaceChange(TInt64 aFreeSpace)
	{
	const TInt drv=Drive().DriveNumber();
	__ASSERT_ALWAYS(aFreeSpace>=0,Fault(ESvrFreeDiskSpace));
	__PRINT3(_L("CMountCB::SetDiskSpaceChange(%LU) drv:%d, %dKB"), aFreeSpace, drv, (TUint32)(aFreeSpace>>10));

	// Notifying involves memory de-allocation on the file server's heap -
	// check if we need to switch heaps.
	RAllocator* current_alloc = &User::Heap();
	RAllocator* svr_alloc = ServerThreadAllocator;
	if (current_alloc != svr_alloc)
		User::SwitchHeap(svr_alloc);

	FsNotify::HandleDiskSpace(drv, aFreeSpace);
		
		if (current_alloc != svr_alloc)
			User::SwitchHeap(current_alloc);
	}
	
//-----------------------------------------------------------------------------
/**
    Initialize the MountCB object. 
    
    @param  aDrive          TDrive object that will be used by the mount for drive access
    @param  apFileSystem    pointer to the File System object that has produced this CMountCB
*/
EXPORT_C void CMountCB::InitL(TDrive& aDrive, CFileSystem* apFileSystem)
	{
	__PRINT3(_L("CMountCB::InitL()[0x%x] drv:%d, FS:0x%x"), this, aDrive.DriveNumber(),  apFileSystem);
    ASSERT(apFileSystem);
    

    SetDrive(&aDrive);
    DoInitL(aDrive.DriveNumber());

	// see whether the file system supports the CFileCB extended API 
	MFileAccessor* fileAccessor = NULL;

	GetInterfaceTraced(CMountCB::EFileAccessor, (void*&) fileAccessor, NULL);

	MFileExtendedInterface* fileExtInterface = NULL;
	GetInterface(CMountCB::EFileExtendedInterface, (void*&) fileExtInterface, NULL);

    if(!iBody)
        {
        iBody = new(ELeave)CMountBody(this, fileAccessor, fileExtInterface);
        }
    else
        {
        //-- some file systems can call this method several times for the same mount.
        //-- composite FS, for example.
        __PRINT1(_L("CMountCB::InitL !!re-initialisation!! iBody:0x%x"), iBody);
        }
	
    SetFileSystem(apFileSystem); //-- associate MountCB object with the file system it belongs to; this relies on iBody
    }

/**
Reports whether the specified interface is supported - if it is,
the a supplied interface object is modified to it

@param aInterfaceId		The interface of interest
@param aInterface		The interface object
@return					KErrNone if the interface is supported, otherwise KErrNotFound 
*/
EXPORT_C TInt CMountCB::GetInterface(TInt /*aInterfaceId*/,TAny*& /*aInterface*/,TAny* /*aInput*/)
	{
	return(KErrNotSupported);
	}

/**
Creates a clamp for the named file, and provides clamp handle data to the caller.

@param aDriveNo		The number of the drive on which the file can be found
@param aName		Name of the file to clamp
@param aHandle		Pointer to the clamp handle data
@return				KErrNone if successful, otherwise one of the systme-wide eror codes.
*/
TInt CMountCB::ClampFile(const TInt aDriveNo, const TDesC& aName, TAny* aHandle)
	{
	return(iBody?iBody->ClampFile(aDriveNo,aName,aHandle):KErrNotSupported);
	};

/**
Reports whether the named file is clamped.

@param aName		Name of the file to clamp
@return				0 if the file is not clamped, 1 if it is, or a system-wide error code.
*/
EXPORT_C TInt CMountCB::IsFileClamped(/*const TDesC& aName,*/ const TInt64 aUniqueId)
	{
	return(iBody?iBody->IsFileClamped(aUniqueId):KErrNotSupported);
	};

/**
Removes the clamp indicated by the specified handle.
If this was the last clamp for the drive, any pending dismount is performed.

@param aHandle		Pointer to the clamp handle data
@return				KErrNone if successful, a system-wide error code otherwise
*/
TInt CMountCB::UnclampFile(RFileClamp* aHandle)
	{
	return(iBody?iBody->UnclampFile(aHandle):KErrNotSupported);
	};

/**
Returns the current number of clamps 

@return				the number of clamps
*/
TInt CMountCB::NoOfClamps()
	{
	return(iBody?iBody->NoOfClamps():KErrNotSupported);
	}




/**
Gets the sub type name of mounted file system (e.g. FAT12, FAT16 or FAT32 of Fat file system).
Uses GetInterface() API to avoid binary compatibility break while providing polymorphism.
The real implementations is done by classes multiple inherited from both CMountCB and
MFileSystemSubType that have implemented MFileSystemSubType::SubType() virtual function.
File system that do not support sub types will have KErrNotSupported returned.

@param aSubTypeName A descriptor contains return of the sub type name.
@return KErrNone if successful; otherwise another of the system wide error codes; 
		KErrNotSupported if sub type is not supported by mounted file system;

@see MFileSystemSubType::SubType()
*/
TInt CMountCB::FileSystemSubType(TDes& aName)
	{
	MFileSystemSubType* interface = NULL;
	TAny* dummy = NULL;
	TInt rel = GetInterfaceTraced(EGetFileSystemSubType, (TAny*&)(interface), dummy);
	if((interface != NULL) && (rel == KErrNone))
		{
		rel = interface->SubType(aName);
		}
	
	return rel;
	}

/**
Gets the cluster size of mounted file system.
Uses GetInterface() API to avoid binary compatibility break while providing polymorphism.
The real implementation is done by classes multiple inherited from both CMountCB and
MFileSystemClusterSize that have implemented MFileSystemClusterSize::ClusterSize() function.
File system that do not support concept of 'clusters' will have the default KErrNotSupported returned.

@return Cluster size value if successful; otherwise another of the system wide error codes; 
		KErrNotSupported if cluster is not supported by mounted file system;

@see MFileSystemClusterSize::ClusterSize()
*/
TInt CMountCB::FileSystemClusterSize()
	{
	MFileSystemClusterSize* interface = NULL;
	TAny* dummy = NULL;
	TInt rel = GetInterfaceTraced(EGetClusterSize, (TAny*&)(interface), dummy);
	if((interface != NULL) && (rel == KErrNone))
		{
		rel = interface->ClusterSize();
		}
		
	return rel;
	}


/**
@prototype

Reads a specified section of the file, regardless of the file's lock state.

Uses GetInterface() API to avoid binary compatibility break while providing polymorphism.
The real implementation is done by classes multiple inherited from both CMountCB and
MFileSystemExtendedInterface that have implemented MFileSystemExtendedInterface::ExtendedReadSectionL() function.
File system that do not support large file will implement the default CMountCB::ReadSectionL() function.

@see CMountCB::ReadSectionL()

@see MFileSystemExtendedInterface::ExtendedReadSectionL()
*/
void CMountCB::ReadSection64L(const TDesC& aName,TInt64 aPos,TAny* aTrg,TInt aLength,const RMessagePtr2& aMessage)
	{
	iBody->iFileExtendedInterface->ReadSection64L(aName, aPos, aTrg, aLength, aMessage);
	}

TInt CMountCB::GetFileUniqueId(const TDesC& aName, TInt64& aUniqueId)
	{
	return (iBody->iFileAccessor->GetFileUniqueId(aName, aUniqueId));
	}
	
TInt CMountCB::Spare3(TInt aVal, TAny* aPtr1, TAny* aPtr2)
	{
	return (iBody->iFileAccessor->Spare3(aVal, aPtr1, aPtr2));
	}
	
TInt CMountCB::Spare2(TInt aVal, TAny* aPtr1, TAny* aPtr2)
	{
	return (iBody->iFileAccessor->Spare2(aVal, aPtr1, aPtr2));
	}
	
TInt CMountCB::Spare1(TInt aVal, TAny* aPtr1, TAny* aPtr2)
	{
	return (iBody->iFileAccessor->Spare1(aVal, aPtr1, aPtr2));
	}

TInt CMountCB::GetInterfaceTraced(TInt aInterfaceId, TAny*& aInterface, TAny* aInput)
	{
	TRACE3(UTF::EBorder, UTraceModuleFileSys::ECMountCBGetInterface, EF32TraceUidFileSys, 
		DriveNumber(), aInterfaceId, aInput);

	TInt r = GetInterface(aInterfaceId, aInterface, aInput);

	TRACERET2(UTF::EBorder, UTraceModuleFileSys::ECMountCBGetInterfaceRet, EF32TraceUidFileSys, r, aInterface);

	return r;
	}

//-----------------------------------------------------------------------------
/**
    Get the file system name. I.e. The name of the file system that produced this object of CMountCB
    @param  aName buffer for the name
*/
void CMountCB::FileSystemName(TDes& aName)
{
    aName = FileSystem()->Name();
}



//-----------------------------------------------------------------------------
/**
    Associate CFileSystem object (the factory) and the produced CMountCB object.
    @param  aFS pointer to the file system that produced this mount.
*/
void CMountCB::SetFileSystem(CFileSystem* aFS)
    {
    ASSERT(iBody);
    iBody->SetFileSystem(aFS);
    }

/**
    Get reference to the filesystem, associated with this mount.
*/
EXPORT_C CFileSystem* CMountCB::FileSystem() const
    {
    ASSERT(iBody);
    CFileSystem* pFSys = iBody->GetFileSystem();
    ASSERT(pFSys);
    return pFSys;
    }

void CMountCB::SetProxyDriveDismounted()
	{
	iBody->SetProxyDriveDismounted();
	}

TBool CMountCB::ProxyDriveDismounted()
	{
	return iBody->ProxyDriveDismounted();
	}


/**
    Factory method. Produces CFileCB object.
*/
CFileCB* CMountCB::NewFileL() const
    {
    return FileSystem()->NewFileL();
    }

/**
    Factory method. Produces CDirCB object.
*/
CDirCB* CMountCB::NewDirL() const
    {
    return FileSystem()->NewDirL();
    }

    
/**
    Factory method. Produces CFormatCB object.
*/
CFormatCB* CMountCB::NewFormatL() const
    {
    return FileSystem()->NewFormatL();
    }
















