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

// 

//

#include "sf_std.h"

#include <e32uid.h>

#include "sf_file_cache.h"

#include <kernel\localise.h>

#include <f32file.h>

typedef CFileSystem*(*TFileSystemNew)();

extern CProxyDriveFactory* GetExtension(const TDesC& aName);

#ifndef __WINS__

extern TBool gInitCacheCheckDrivesAndAddNotifications;

#endif

struct TFatUtilityFunctions;

GLREF_D TCodePageUtils TheCodePage;

const TInt KMaxLengthShortNameWithDot = 12;

const TUint8 KLeadingE5Replacement = 0x05;

const TUint8 KEntryErasedMarker=0xE5;           ///< Erased entry marker for a directory entry

/**

Default constructor.

*/

EXPORT_C CFileSystem::CFileSystem()

	{

	TRACE0(UTF::EBorder, UTraceModuleFileSys::ECFileSystemConstructor, EF32TraceUidFileSys);

	TRACE0(UTF::EBorder, UTraceModuleFileSys::ECFileSystemConstructorReturn, EF32TraceUidFileSys);

	}

/**

Destructor.

*/

EXPORT_C CFileSystem::~CFileSystem()

	{

	TRACE0(UTF::EBorder, UTraceModuleFileSys::ECFileSystemDestructor, EF32TraceUidFileSys);

	TRACE0(UTF::EBorder, UTraceModuleFileSys::ECFileSystemDestructorReturn, EF32TraceUidFileSys);

	}

/**

Uninstalls the file system.

This is called just before the file system object is destroyed, and allows

any clean up to be carried out.

The default implementation does nothing except return KErrNone.

Implementations should return an error code on error detection.

@return KErrNone if successful, otherwise one of the other system wide error

        codes.

*/

EXPORT_C TInt CFileSystem::Remove()

	{

	return(KErrNone);

	}

/**

Tests whether a version is supported.

This is done decided by comparing the supplied version with iVersion.

The default implementation uses User::QueryVersionSupported() to

determine this.

@param aVer The version to be tested.

@return True, if aVer is supported; false otherwise

@see User::QueryVersionSupported

@see CFileSystem::iVersion

*/

EXPORT_C TBool CFileSystem::QueryVersionSupported(const TVersion& aVer) const

	{

	return(User::QueryVersionSupported(iVersion,aVer));

	}

//#ifndef __DATA_CAGING__

/**

Retrieves the default path for the file system.

Each session with the file server has a current session path.

When a new session is opened, its session path is set to the default path

of the file server.

At file server start-up, this default path is set to the default path returned

by the local file system. 

The function should return an appropriate error code when the default path

cannot be supplied. 

The derived class should override this base class function.

This default implementation raises an "Fserv fault" 31 panic.

@param aPath On return, contains the default path for the file system for derived classes.

@return KErrNone if successful, otherwise one of the other system wide error codes.

@panic Fserv fault 31 if the default implementation

       for CFileSystem::DefaultPath() is not overridden. 

*/

TInt CFileSystem::DefaultPath(TDes& /*aPath*/) const

	{

	Fault(ESysDefaultPathNotSupported);

	return(KErrNone);

	}

//#endif

/**

Sets the file system's resource library.

This library represents the loaded file system.

This is called internally by InstallFileSystem().

@param aLib The resource library to be set.

*/

EXPORT_C void CFileSystem::SetLibrary(RLibrary aLib)

	{

	iLibrary=aLib;

	}

/**

Gets the file system's resource library.

@return The file system's resource library.

*/

EXPORT_C RLibrary CFileSystem::Library() const

	{

	return(iLibrary);

	}

/**

Tests whether the file system supports extensions.

@return True, if the file system supports extensions, false otherwise.

        The defualt implementation returns false.

*/

EXPORT_C TBool CFileSystem::IsExtensionSupported() const

	{

	return(EFalse);

	}

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

	{

	return(KErrNotSupported);

	}

EXPORT_C TBool CFileSystem::IsProxyDriveSupported()

	{

	TAny* dummyInterface;

	if(GetInterface(EProxyDriveSupport, dummyInterface, NULL) == KErrNone)

		return ETrue;

	return EFalse;

	}

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

/** 

    Extended CMountCB factory interface.

    Produces the CMountCB object which can be associated with another CFileSystem owner.

    Used mostly  with "automounter" file system

    @param  apDrive         in:  pointer to TDrive, producing right CMountCB can require media access ("automounter" recognising the file system)

    @param  apFileSystem    out: pointer to the CFileSystem object that actually produced CMountCB instance (might be different from "this")

    @param  aForceMount     in:  ETrue if it is necessarily to force mounting (formatting the media, for example)

    @param  aFsNameHash     in:  desired file system name hash (optional). Specifies which file system will be used to produce appropriate CMountCB object.

                                 The file system that implements NewMountExL() shall decide how to process it. 0 means "default/not specified".

    @return pointer to the instantiated CMountCB object.

*/

CMountCB* CFileSystem::NewMountExL(TDrive* apDrive, CFileSystem** apFileSystem, TBool aForceMount, TUint32 aFsNameHash)

    {

    TAny* pa;

    if(GetInterface(EExtendedFunctionality, pa, NULL) == KErrNone)

        {//-- special interface for the case, when CMountCB object will be produced by not _this_ CFileSystem object, but some different.

         //-- in this case apFileSystem will contain a pointer to the real factory.

        MFileSystemExtInterface* pExtIf = (CFileSystem::MFileSystemExtInterface*)pa;

        ASSERT(pExtIf);

        return pExtIf->NewMountExL(apDrive, apFileSystem, aForceMount, aFsNameHash);

        }

    else

        {//--This interface is not supported by current CFileSystem implementation, call normal legacy factory method

         //-- and make _this_ object of CFileSystem produce a new CMountCB 

            ASSERT(aFsNameHash == 0); //-- it is impossible to specify the particular FS to be used

            *apFileSystem = this; 

            return NewMountL();

        }

    }

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

/** 

    Get the name of a filesystem from the list of supported on this drive.

    Some filesystems (e.g. "automounter" can support more than one real "child" filesystems.

    For the normal case, only one filesystem is supported (a mouned one).

    @param  aFsNumber   used to enumerate supported filesystems can be:

                        special value KRootFileSystem, or

                        0,1,2... - the sequence number of a "child" FS.

    @param  aFsName     out: buffer for the returned file system name

    @return KErrNone        Ok, aFsName contains valid value for the given aFsNumber

            KErrNotFound    There is no supported filesystem for the given aFsNumber

*/

TInt CFileSystem::GetSupportedFileSystemName(TInt aFsNumber, TDes& aFsName) 

    {

    TAny* pa;

    //-- we need a special interface to find out the name of the supported file system number "aFsNumber"

    if(GetInterface(EExtendedFunctionality, pa, NULL) == KErrNone)

        {

        MFileSystemExtInterface* pExtIf = (CFileSystem::MFileSystemExtInterface*)pa;

        ASSERT(pExtIf);

        return pExtIf->GetSupportedFileSystemName(aFsNumber, aFsName);   

        }

    else

        {//--This interface is not supported by current CFileSystem implementation, but in this case "Root" and first "child" filesystem mean

         //-- the same and this is "this" filesystem

            if(aFsNumber == RFs::KRootFileSystem || aFsNumber == RFs::KFirstChildFileSystem)

                {

                aFsName = Name();

                return KErrNone;               

                }

            else

                {

                return KErrNotFound;

                }

        }

    }

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

TInt InstallFileSystem(CFileSystem* aSys,RLibrary aLib)

//

// Install a file system.

//

	{

	TRACE1(UTF::EBorder, UTraceModuleFileSys::ECFileSystemInstall, EF32TraceUidFileSys, aSys);

	TInt r=aSys->Install();

	TRACERETMULT2(UTF::EBorder, UTraceModuleFileSys::ECFileSystemInstallRet, EF32TraceUidFileSys, r, aSys->Name());

	__PRINT1TEMP(_L("InstallFileSystem %S"),aSys->Name());

	if (r==KErrNone)

		{TRAP(r,FileSystems->AddL(aSys,ETrue))}

	if (r!=KErrNone)

		{

		TRACE1(UTF::EBorder, UTraceModuleFileSys::ECFileSystemRemove, EF32TraceUidFileSys, aSys);

#ifdef SYMBIAN_FTRACE_ENABLE

		TInt r = 

#endif

			aSys->Remove();

		TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECFileSystemRemoveRet, EF32TraceUidFileSys, r);

		}

	if (r==KErrNone)

		aSys->SetLibrary(aLib);

	else

		aSys->Close();

	return(r);

	}

EXPORT_C CFileSystem* GetFileSystem(const TDesC& aName)

//

// Lookup a file system by name.

//

	{

	TInt h=0;

	TInt r=FileSystems->FindByName(h,aName);

	if (r!=KErrNone)

		return(NULL);

	return((CFileSystem*)FileSystems->At(h));

	}

TInt TFsAddFileSystem::DoRequestL(CFsRequest* aRequest)

//

// Add a file system.

//

	{

	__PRINT(_L("TFsAddFileSystem::DoRequestL(CFsRequest* aRequest)"));

	RLibrary lib;

	lib.SetHandle(aRequest->Message().Int0()); // Get library handle

	if (lib.Type()[1]!=TUid::Uid(KFileSystemUidValue))

		return KErrNotSupported;

	TFileSystemNew f=(TFileSystemNew)lib.Lookup(1);

	if (!f)

		return KErrCorrupt;

	TRACE1(UTF::EBorder, UTraceModuleFileSys::ECFileSystemNew, EF32TraceUidFileSys, lib.Handle());

	CFileSystem* pS=(*f)();

	TRACE1(UTF::EBorder, UTraceModuleFileSys::ECFileSystemNewRet, EF32TraceUidFileSys, pS);

	if (!pS)

		return KErrNoMemory;

	TInt r=InstallFileSystem(pS,lib);

	if (r==KErrNone && !LocalFileSystemInitialized)

		{

		_LIT(KLocFSY, "ELOCAL.FSY");

		TFileName fn(lib.FileName());

		TParsePtrC ppc(fn);

		if (ppc.NameAndExt().CompareF(KLocFSY) == 0)

			r = InitializeLocalFileSystem(pS->Name());

		}

	return r;

	}

TInt TFsAddFileSystem::Initialise(CFsRequest* aRequest)

//

//

//

	{

	TSecurityPolicy policy(RProcess().SecureId(), ECapabilityTCB);

	if (!policy.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Add File System")))

		return KErrPermissionDenied;

	return KErrNone;

	}

TInt TFsRemoveFileSystem::DoRequestL(CFsRequest* aRequest)

//

// Remove a file system.

//

	{

	TFullName name;

	aRequest->ReadL(KMsgPtr0,name);

	CFileSystem* pF=GetFileSystem(name);

	if (pF==NULL)

		return(KErrNotFound);

	CFileSystem* pFs = NULL;

	for(TInt drvNum=0; drvNum<KMaxDrives; drvNum++)

		{

		FsThreadManager::LockDrive(drvNum);

		pFs=TheDrives[drvNum].GetFSys();

		FsThreadManager::UnlockDrive(drvNum);

		if(!pFs)

			continue;

        if(name.CompareF(pFs->Name()) == 0)

			return KErrInUse;

		}

    TRACE1(UTF::EBorder, UTraceModuleFileSys::ECFileSystemRemove, EF32TraceUidFileSys, pF);

	TInt r=pF->Remove();

	TRACERET1(UTF::EBorder, UTraceModuleFileSys::ECFileSystemRemoveRet, EF32TraceUidFileSys, r);

	if (r!=KErrNone)

		return(r);

    RLibrary lib=pF->Library();

	pF->Close();

	lib.Close();

    return KErrNone;

	}

TInt TFsRemoveFileSystem::Initialise(CFsRequest* aRequest)

//

//

//

	{

	if (!KCapFsRemoveFileSystem.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Remove File System")))

		return KErrPermissionDenied;

	return KErrNone;

	}

LOCAL_C TInt DoMountFileSystem(CFsRequest* aRequest)

//

//

//

	{

	TInt r = TFileCacheSettings::ReadPropertiesFile(aRequest->Drive()->DriveNumber());

	if (r != KErrNone)

		return r;

	return(aRequest->Drive()->CheckMount());

	}

LOCAL_C TInt DoMountFsInitialise(CFsRequest* aRequest,TDesC& aFsName,TBool aIsExtension,TBool aIsSync)

//

//

//

	{

	if (!KCapFsMountFileSystem.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Mount File System")))

		return KErrPermissionDenied;

	TInt r=ValidateDrive(aRequest->Message().Int1(),aRequest);

	if(r!=KErrNone)

		return(r);

	TBool driveThreadExists = FsThreadManager::IsDriveAvailable(aRequest->DriveNumber(), ETrue);

	if(driveThreadExists)

		{

		// A drive thread already exists for this drive.This could be because a filesystem

		// is already mounted, or a proxy drive is loaded.  Check the mount to be sure...

		if(aRequest->Drive()->GetFSys())

			{

			// Yes, a mount already exists so we can't mount another one!

			return(KErrAccessDenied);

			}

		__ASSERT_DEBUG(IsProxyDrive(aRequest->DriveNumber()), User::Panic(_L("Bad thread state - No Mount or Proxy Drive Exists!"), -999));

		}

	// ...therefore no drive thread can be present

	__ASSERT_DEBUG(!&aRequest->Drive()->FSys(),Fault(EMountFileSystemFSys));

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

		return(KErrAccessDenied);

	CFileSystem* pF = GetFileSystem(aFsName);

	if (pF == NULL)

		return(KErrNotFound);

	// Check that if the drive is a proxy drive (not using TBusLocalDrive) then the filesystem supports these...

	TInt driveNumber = aRequest->DriveNumber();

	if(IsProxyDrive(driveNumber))

		{

		if(!pF->IsProxyDriveSupported())

			return KErrNotSupported;

		r = LocalDrives::SetupMediaChange(driveNumber);

		}

	TDriveInfo driveInfo;

	driveInfo.iDriveAtt=0;

	pF->DriveInfo(driveInfo, driveNumber);

	if(!driveInfo.iDriveAtt)

		r = KErrArgument;

    if(r == KErrNone && !driveThreadExists)

	    {

    	// determine whether file system synchronous or not not by flag passed in

		r=FsThreadManager::InitDrive(driveNumber, aIsSync);

        }

	if(r!=KErrNone)

		return(r);

    //-- let TDrive object know if the drive is synchronous

	aRequest->Drive()->SetSynchronous(aIsSync);

    if(aIsExtension && aRequest->Message().Ptr2()!=NULL)

		{

		TFullName extName;

		r = aRequest->Read(KMsgPtr2,extName);

		if (r!=KErrNone)

			return r;

		CProxyDriveFactory* pE=GetExtension(extName);

		if(pE==NULL)

			return(KErrNotFound);

		r=aRequest->Drive()->MountExtension(pE,ETrue);

		if(r!=KErrNone)

			return(r);

		}

	TInt32 newAtt = 0;

	TInt32 oldAtt = 0;

	_LIT8( KAddAtt, "AddDriveAttributes");

	_LIT8( KRemoveAtt, "RemoveDriveAttributes");

	_LIT8( KLogicallyRemovableAtt, "KDRIVEATTLOGICALLYREMOVABLE");

	_LIT8( KHiddenAtt, "KDRIVEATTHIDDEN");

	_LIT8( KLogicallyRemovableAttHex, "0X200");

	_LIT8( KHiddenAttHex, "0X400");

	TBuf8<0x1000> addbuf;

	addbuf.FillZ();

	TBuf8<0x1000> removebuf;

	removebuf.FillZ();

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

	_LIT8(KLitSectionNameDrive,"Drive%C");

	TBuf8<8> sectionName;

	sectionName.Format(KLitSectionNameDrive, 'A' + drive);

	F32Properties::GetString(sectionName, KAddAtt, addbuf);

	F32Properties::GetString(sectionName, KRemoveAtt, removebuf);  //oldAtt now contains value of the attributes to be removed from iDriveAtt.

	if(addbuf.Length() != 0)

		{

		TInt pos = 0;

		TInt length = 0;

		TPtrC8 ptr;

		TBool endOfFlag=EFalse; 

		while(!endOfFlag)

		{

		ptr.Set(addbuf.Mid(pos));

		length = ptr.Locate(',');

		if(length == KErrNotFound)

			{

			endOfFlag = ETrue;

			} 

		else{

			ptr.Set(ptr.Left(length));

			pos += (length +1);

			}

		if(((ptr.MatchF(KLogicallyRemovableAtt)) != KErrNotFound) || ((ptr.MatchF(KLogicallyRemovableAttHex)) != KErrNotFound))

			newAtt |= KDriveAttLogicallyRemovable;