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

#ifdef OST_TRACE_COMPILER_IN_USE

#include "sf_sysTraces.h"

#endif

typedef CFileSystem*(*TFileSystemNew)();

extern CProxyDriveFactory* GetExtension(const TDesC& aName);

#ifndef __WINS__

extern TBool gInitCacheCheckDrivesAndAddNotifications;

#endif

GLREF_D TCodePageUtils TheCodePage;

/**

Default constructor.

*/

EXPORT_C CFileSystem::CFileSystem()

	{

	OstTrace0(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMCONSTRUCTOR, "");

	OstTrace0(TRACE_FILESYSTEM,FILESYS_ECFILESYSTEMCONSTRUCTORRETURN, "");

	}

/**

Destructor.

*/

EXPORT_C CFileSystem::~CFileSystem()

	{

	OstTrace0(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMDESTRUCTOR, "");

	OstTrace0(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMDESTRUCTORRETURN, "");

	}

/**

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 void CFileSystem::DriveInfo(TDriveInfo& aInfo, TInt aDriveNumber) const

	{

    GetDriveInfo(aInfo, aDriveNumber);

	}

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.

//

	{

	OstTrace1(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMINSTALL, "this %x", aSys);

	TInt r=aSys->Install();

	OstTraceData(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMINSTALLYS_EFILESYSTEMNAME, "FileSystemName %S", aSys->Name().Ptr(), aSys->Name().Length()<<1);

	OstTrace1(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMINSTALLRET, "r %d", r);

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

	if (r==KErrNone)

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

	if (r!=KErrNone)

		{

		OstTrace1(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMREMOVE1, "this %x", aSys);

#ifdef OST_TRACE_COMPILER_IN_USE

		TInt r = 

#endif

			aSys->Remove();

		OstTrace1(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMREMOVE1RET, "r %d", 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;

	OstTrace1(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMNEW, "handle %x", lib.Handle());

	CFileSystem* pS=(*f)();

	OstTrace1(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMNEWRET, "fileSystem %x", 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;

		}

    OstTrace1(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMREMOVE2, "this %x", pF);

	TInt r=pF->Remove();

	OstTrace1(TRACE_FILESYSTEM, FSYS_ECFILESYSTEMREMOVE2RET, "r %d", 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;

    //-- check file system name length. It should not exceed KMaxFSNameLength (32 characters)

    TInt r = aRequest->GetDesLength(KMsgPtr0);

    if(r <=0 || r >KMaxFSNameLength)

        return KErrArgument;

	return KErrNone;

	}

LOCAL_C TInt DoMountFileSystem(CFsRequest* aRequest)

//

//

//

	{

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

	if (r != KErrNone)

		return r;

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

	}

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

/**

    Read optional drive setting from estart.txt that may contain additional drive attributes, like KDRIVEATTLOGICALLYREMOVABLE, KDRIVEATTHIDDEN

    and process them. 

    This may lead to addding/removing some attributes to the existing drive's ones.

    N.B Implementation of this is quite strange, it knows only about 2 specific additional attributes..

    @param  aDrvNum drive number

    @param  aDrvAtt in: original drive attributes, out: altered drive attributes.    

*/

static void DoProcessAdditionalDriveAttributes(TInt aDrvNum, TUint& aDrvAtt)

{

	TUint add_Att= 0;       //-- additional drive attributes to be added

	TUint remove_Att = 0;   //-- additional drive attributes to be removed

	_LIT8( KAddAtt, "AddDriveAttributes");

	_LIT8( KRemoveAtt, "RemoveDriveAttributes");

	_LIT8( KLogicallyRemovableAtt, "KDRIVEATTLOGICALLYREMOVABLE");

	_LIT8( KHiddenAtt, "KDRIVEATTHIDDEN");

	_LIT8( KLogicallyRemovableAttHex, "0X200");

	_LIT8( KHiddenAttHex, "0X400");

    TBuf8<0x100> buf;

	TBuf8<8> sectionName;

    F32Properties::GetDriveSection(aDrvNum, sectionName);

    //-- read and parse "AddDriveAttributes" string

    buf.Zero();

    TBool bSectFound = F32Properties::GetString(sectionName, KAddAtt, buf);

	if(bSectFound && buf.Length() > 0)

		{

		TInt pos = 0;

		TInt length = 0;

		TPtrC8 ptr;

		TBool endOfFlag=EFalse; 

		while(!endOfFlag)

		    {

		    ptr.Set(buf.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))

			    add_Att |= KDriveAttLogicallyRemovable;

		    if(((ptr.MatchF(KHiddenAtt)) != KErrNotFound)  || ((ptr.MatchF(KHiddenAttHex)) != KErrNotFound))

			    add_Att |= KDriveAttHidden;

		    }//while(!endOfFlag)

        }

    //-- read and parse "RemoveDriveAttributes" string

    buf.Zero();

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

	if(bSectFound && buf.Length() > 0)

		{

		TInt pos = 0;

		TInt length = 0;

		TPtrC8 ptr;

		TBool endOfFlag=EFalse; 

		while(!endOfFlag)

            {

            ptr.Set(buf.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))

                remove_Att |= KDriveAttLogicallyRemovable;

            if(((ptr.MatchF(KHiddenAtt)) != KErrNotFound) || ((ptr.MatchF(KHiddenAttHex)) != KErrNotFound))

                remove_Att |= KDriveAttHidden;

            }//while(!endOfFlag)