// 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\sfsrv\cl_cli.cpp

// 

//

#include "cl_std.h"

#include <f32fsys.h>

EFSRV_EXPORT_C TBool RFs::IsValidDrive(TInt aDrive)

/**

Tests whether the specified drive number is valid.

A valid drive number is any number between 0 and (KMaxDrives-1) inclusive,

or the specific value KDefaultDrive (implying the session default drive).

@param aDrive The drive number.

@return True if the drive is valid; false if not.				

@see TDriveNumber 				

*/

	{

	return((aDrive>=0 && aDrive<KMaxDrives) || aDrive==KDefaultDrive);

	}

EFSRV_EXPORT_C TInt RFs::CharToDrive(TChar aChar,TInt& aDrive)

/**

Maps a drive character to a drive number.

The drive character must be in the range A to Z or a to z. For example, drive A (or a)

corresponds to zero, drive B (or b) corresponds to 1 etc. For the drive number

enumeration, see TDriveNumber.

@param aChar  The drive character.

@param aDrive On return, contains the drive number.

@return KErrNone, if successful;

        KErrArgument, if the drive character is not in the range A to Z or a to z.

@see TDriveNumber        

*/

	{

	aChar.UpperCase();

	if (aChar>='A' && aChar<='Z')

		{

		aDrive=(TInt)aChar-'A';

		return(KErrNone);

		}

	return(KErrArgument);

	}

EFSRV_EXPORT_C TInt RFs::DriveToChar(TInt aDrive,TChar& aChar)

/**

Maps a drive number to the corresponding character.

The drive number must be in the range 0 to (KMaxDrives-1). For example, drive

number zero (EDriveA) corresponds to drive A, one (EDriveB)

corresponds to drive B. For the drive number enumeration, see TDriveNumber.

The drive number can also be KDefaultDrive, implying the default drive. In this

case the current drive is taken and converted.

@param aDrive The drive number.

@param aChar  On return, contains the drive character.

@return KErrNone, if successful;

        KErrArgument, if the drive number is invalid;

        otherwise one of the other system-wide error codes.

*/

	{

	if (aDrive==KDefaultDrive)

		{

		TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsDriveToChar, MODULEUID, aDrive);

		RFs fs;

		TFileName path;

		TInt r=fs.Connect();

		if (r!=KErrNone)

			return(r);

		r=fs.SessionPath(path);

		fs.Close();

		if (r!=KErrNone)

			return(r);

		aChar=path[0];

		TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFsDriveToCharReturn, MODULEUID, KErrNone, aChar);

		return(KErrNone);

		}

	if (!IsValidDrive(aDrive))

		return(KErrArgument);

	aChar=aDrive+'A';

	return(KErrNone);

	}

EFSRV_EXPORT_C TBool RFs::IsRomAddress(TAny *aPtr)

/**

Tests whether the specified address is in ROM.

@param aPtr The address.

@return True, if the address is in ROM; false, if not.

*/

	{

	TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsIsRomAddress, MODULEUID, aPtr);

	TBool res;

	TInt r=User::IsRomAddress(res,aPtr); // Only returns error on WINS

	if (r!=KErrNone)

		res=EFalse;

	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsIsRomAddressReturn, MODULEUID, res);

	return(res);

	}

/** 

Obtain the system drive number.

The System Drive is a defined drive on the device which is:

 - Read/Writeable

 - Internal: Always available and not removable from the device

 - Non-Volatile (e.g. Flash memory, battery-backed RAM)

 - Only Accessible via Rfs (e.g. not available via USB mass storage)

The System drive is utilised as:

 - Storage for Persistent settings from system and application software

 - Storage for Localisation resources

 - A Default Drive for user data

 - A Target Drive for Software installations

It the system drive is not set previously (see RFs::SetSystemDrive) EDriveC is returned by default.

@see RFs::GetSystemDriveChar

@see RFs::SetSystemDrive   

@see TDriveNumber

@return TDriveNumber contains the drive number of the system drive.

 */

EFSRV_EXPORT_C TDriveNumber RFs::GetSystemDrive()

    {

	TRACE0(UTF::EBorder, UTraceModuleEfsrv::EFsGetSystemDrive, MODULEUID);

    TInt drive;

	TInt err = RProperty::Get(TSecureId(KFileServerUidValue), KSystemDriveKey, drive);

    if(err==KErrNone)

        {

        if((drive>=EDriveA) && (drive<=EDriveZ))

            {

			TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsGetSystemDriveReturn, MODULEUID, drive);

            return static_cast<TDriveNumber>(drive);

            }

        }

	TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsGetSystemDriveReturn, MODULEUID, EDriveC);

    return EDriveC;

	}

/**

This is a wrapper around GetSystemDrive() function. It returns the character corresponding to the system drive.

@parameter aDriveChar On return, contains the system drive character

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

@see RFs::GetSystemDrive

*/

EFSRV_EXPORT_C TChar RFs::GetSystemDriveChar()

	{

	TRACE0(UTF::EBorder, UTraceModuleEfsrv::EFsGetSystemDriveChar, MODULEUID);

	TInt r = 'A' + GetSystemDrive();

	TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsGetSystemDriveCharReturn, MODULEUID, r);

	return r;

	}

/**

Set a specified drive as a "System Drive", see RFs::GetSystemDrive().

The "System Drive" can be set only once, any subsequent calls will result in the error 'KErrAlreadyExists'.

The media type for the system drive shall be one of the: EMediaHardDisk, EMediaFlash, EMediaNANDFlash, EMediaRam

Required drive attributes: KDriveAttLocal, KDriveAttInternal

Prohibited drive attributes: KDriveAttRom,KDriveAttRedirected,KDriveAttSubsted,KDriveAttRemovable

@param  aSystemDrive specifies the drive number to be set as System Drive

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

@capability TCB

*/

EFSRV_EXPORT_C TInt RFs::SetSystemDrive(TDriveNumber aSystemDrive)

	{

	TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFsSetSystemDrive, MODULEUID, Handle(), aSystemDrive);

    TInt r = SendReceive(EFsSetSystemDrive, TIpcArgs(aSystemDrive));

	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsSetSystemDriveReturn, MODULEUID, r);

	return r;

	}

EFSRV_EXPORT_C TInt RFs::Connect(TInt aMessageSlots)

/**

Connects a client to the file server.

To end the file server session, use Close().

@param aMessageSlots The number of message slots required. The default value of

				     KFileServerDefaultMessageSlots indicates that message

				     slots will be acquired dynamically from the system

				     wide pool. Override this value with a fixed number, if

				     a fixed number of slots are to be allocated to the session.

				     If overriding, note that the number of message slots

				     represents the number of operations, such as reads

				     and writes, that can be outstanding at once;

				     always remember to provide a spare slot for

				     the cancel operation.

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

        error codes.

*/

	{

	TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsConnect, MODULEUID, aMessageSlots);

	_LIT(KFileServerName,"!FileServer");

	TInt r = CreateSession(KFileServerName,Version(),aMessageSlots);

	TRACERET2(UTF::EBorder, UTraceModuleEfsrv::EFsConnectReturn, MODULEUID, r, Handle());

	return r;

	}

EFSRV_EXPORT_C TInt RFs::SetSessionToPrivate(TInt aDrive)

/**

Sets the session path to point to the private path on the specified drive.

The private directory does not need to exist at this point.

The private path for a process has the form: \\Private\\13579BDF\\

where 13579BDF is the identity of the process.

@param aDrive The drive for which information is requested.

              Specify a drive in the range EDriveA to EDriveZ for drives

			  A to Z respectively.

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

        error codes.

*/

	{	

	TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFsSetSessionToPrivate, MODULEUID, Handle(), aDrive);

	TInt r = SendReceive(EFsSessionToPrivate,TIpcArgs(aDrive));

	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsSetSessionToPrivateReturn, MODULEUID, r);

	return r;

	}

EFSRV_EXPORT_C TInt RFs::PrivatePath(TDes& aPath)

/**

Creates the text defining the private path for a process.

The private path for a process has the form: \\Private\\13579BDF\\

where 13579BDF is the identity of the process.

@param aPath On successful return, contains the private path for a process.

*/

	{

	TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsPrivatePath, MODULEUID, Handle());

	TInt r = SendReceive(EFsPrivatePath,TIpcArgs(&aPath));

	TRACERETMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsPrivatePathReturn, MODULEUID, r, aPath);

	return r;

	}

EFSRV_EXPORT_C TInt RFs::CreatePrivatePath(TInt aDrive)

/**

Creates the private path for a process on the specified drive.

The private path for a process has the form: \\Private\\13579BDF\\

where 13579BDF is the identity of the process.

@param aDrive The drive for which the private path is to be created.

              Specify a drive in the range EDriveA to EDriveZ for drives

			  A to Z respectively.

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

        error codes.

*/

	{

	TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFsCreatePrivatePath, MODULEUID, Handle(), aDrive);

	TInt r = SendReceive(EFsCreatePrivatePath,TIpcArgs(aDrive));

	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsCreatePrivatePathReturn, MODULEUID, r);

	return r;

	}	

EFSRV_EXPORT_C TVersion RFs::Version() const

/**

Gets the client side version number.

@return The client side version number.

*/

	{

	TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsVersion, MODULEUID, Handle());

	TVersion r = TVersion(KF32MajorVersionNumber,KF32MinorVersionNumber,KF32BuildVersionNumber);

	TRACERET3(UTF::EBorder, UTraceModuleEfsrv::EFsVersionReturn, MODULEUID, r.iMajor, r.iMinor, r.iBuild);

	return r;

	}

EFSRV_EXPORT_C TInt RFs::AddFileSystem(const TDesC& aFileName) const

/**

Adds a file system to the file server.

After calling this function, use MountFileSystem() to mount the file system

on a drive.

@param aFileName The name of the file system .FSY to install. Its full path can

				 be specified.

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

        error codes.

@capability DiskAdmin

@see RFs::MountFileSystem        

*/

	{

	TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsAddFileSystem, MODULEUID, Handle(), aFileName);

	RLoader loader;

	TInt r = loader.Connect();

	if (r==KErrNone)

		{

		r = loader.SendReceive(ELoadFileSystem, TIpcArgs(0, &aFileName, 0));

		loader.Close();

		}

	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsAddFileSystemReturn, MODULEUID, r);

	return r;

	}

EFSRV_EXPORT_C TInt RFs::RemoveFileSystem(const TDesC& aFileSystemName) const

/**

Removes the specified file system.

@param aFileSystemName The fullname of the file system, as returned from

                       a call to FileSystemName(), to be removed.

@return KErrNone, if successful;

        KErrNotFound, if aFileSystemName is not found;

        otrherwise one of the other system-wide error codes.

@capability DiskAdmin

*/

	{

	TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsRemoveFileSystem, MODULEUID, Handle(), aFileSystemName);

	TInt r = SendReceive(EFsRemoveFileSystem,TIpcArgs(&aFileSystemName));

	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsRemoveFileSystemReturn, MODULEUID, r);

	return r;

	}

EFSRV_EXPORT_C TInt RFs::MountFileSystem(const TDesC& aFileSystemName,TInt aDrive) const

/**

Mounts a file system on a drive.

The file system must first have been added to the file server using AddFileSystem().

The drive is mounted as asynchronous, i.e operations on it don't block the file server and other drives;

@param aFileSystemName The fullname of the file system, as returned from  a call to FileSystemName().

@param aDrive          The drive on which the file system is to be mounted; this can be one of the values defined by TDriveNumber.

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

@capability DiskAdmin

@see RFs::AddFileSystem

@see RFs::FileSystemName

*/

	{

	TRACEMULT3(UTF::EBorder, UTraceModuleEfsrv::EFsMountFileSystem1, MODULEUID, Handle(), aFileSystemName, aDrive);

	TInt r = SendReceive(EFsMountFileSystem,TIpcArgs(&aFileSystemName,aDrive,NULL,EFalse));

	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsMountFileSystem1Return, MODULEUID, r);

	return r;

	}

EFSRV_EXPORT_C TInt RFs::MountFileSystem(const TDesC& aFileSystemName,TInt aDrive, TBool aIsSync) const

/**

Mounts a file system on a specified drive.

The file system must first have been added to the file server using AddFileSystem().

Depending on the aIsSync parameter, the drive can be mounted as synchronous or asynchronous.

Asynchronous drive has its own processing thread, i.e operations on it don't block the file server and other drives;

Synchronous drives' requests are being processed by the main file server thread and there is a possibility to block it along with

all operations on other drives. Mounting a drive as synch. makes a sense if the operations on such drive are very fast e.g. this is an

internal RAM or ROFS drive.

@param aFileSystemName The fullname of the file system, as returned from a call to FileSystemName().

@param aDrive          The drive number on which the file system is to be mounted; this can be one of the values defined by TDriveNumber.

@param aIsSync         if ETrue  the drive will be mounted as synchronous one;

                       if EFalse the drive will be mounted as Asynchronous.

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

@capability DiskAdmin

@see RFs::AddFileSystem

@see RFs::FileSystemName

*/

	{

	TRACEMULT4(UTF::EBorder, UTraceModuleEfsrv::EFsMountFileSystem2, MODULEUID, Handle(), aFileSystemName, aDrive, aIsSync);

	TInt r = SendReceive(EFsMountFileSystem,TIpcArgs(&aFileSystemName,aDrive,NULL,aIsSync));

	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsMountFileSystem2Return, MODULEUID, r);

	return r;

	}

EFSRV_EXPORT_C TInt RFs::MountFileSystem(const TDesC& aFileSystemName,const TDesC& aExtensionName,TInt aDrive)

/**

Mounts a file system on a drive, and the specified extension.

The file system must first have been added to the file server using AddFileSystem().

The drive is mounted as asynchronous, i.e operations on it don't block the file server and other drives;

@param aFileSystemName The fullname of the file system, as returned from a call to FileSystemName().

@param aExtensionName  The filename of the extension.

@param aDrive          The drive on which the file system is to be mounted; this can be one of the values defined by TDriveNumber.

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

@capability DiskAdmin

@see RFs::AddFileSystem

@see RFs::FileSystemName

*/

	{

	TRACEMULT4(UTF::EBorder, UTraceModuleEfsrv::EFsMountFileSystem3, MODULEUID, Handle(), aFileSystemName, aExtensionName, aDrive);

	TInt r = SendReceive(EFsMountFileSystem,TIpcArgs(&aFileSystemName,aDrive,&aExtensionName,EFalse));

	TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsMountFileSystem3Return, MODULEUID, r);

	return r;

	}

EFSRV_EXPORT_C TInt RFs::MountFileSystem(const TDesC& aFileSystemName,const TDesC& aExtensionName,TInt aDrive, TBool aIsSync)

/**

Mounts a file system on a drive, and the specified extension.

The file system must first have been added to the file server using AddFileSystem().

Depending on the aIsSync parameter, the drive can be mounted as synchronous or asynchronous.

Asynchronous drive has its own processing thread, i.e operations on it don't block the file server and other drives;

Synchronous drives' requests are being processed by the main file server thread and there is a possibility to block it along with

all operations on other drives. Mounting a drive as synch. makes  sense if the operations on such drive are very fast e.g. this is an

internal RAM or ROFS drive.

@param aFileSystemName The fullname of the file system, as returned from a call to FileSystemName().

@param aExtensionName  The filename of the extension.

@param aDrive          The drive on which the file system is to be mounted; this can be one of the values defined by TDriveNumber.

@param aIsSync         if ETrue  the drive will be mounted as synchronous one;

                       if EFalse the drive will be mounted as Asynchronous.

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

@capability DiskAdmin

@see RFs::AddFileSystem

@see RFs::FileSystemName