diff -r 000000000000 -r a41df078684a userlibandfileserver/fileserver/sfsrv/cl_cli.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/userlibandfileserver/fileserver/sfsrv/cl_cli.cpp Mon Oct 19 15:55:17 2009 +0100 @@ -0,0 +1,3846 @@ +// 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 + + + + + + + +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='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(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 +*/ + { + TRACEMULT5(UTF::EBorder, UTraceModuleEfsrv::EFsMountFileSystem4, MODULEUID, Handle(), aFileSystemName, aExtensionName, aDrive, aIsSync); + TInt r = SendReceive(EFsMountFileSystem,TIpcArgs(&aFileSystemName,aDrive,&aExtensionName,aIsSync)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsMountFileSystem4Return, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::MountFileSystemAndScan(const TDesC& aFileSystemName,TInt aDrive,TBool& aIsMountSuccess) const +/** +Mounts a file system on a drive, and performs a scan on that drive. +The file system must first have been added to the file server using AddFileSystem(). + +Note that the scan is done only if the mount is successful. + +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. +@param aIsMountSuccess On return, set to: ETrue, if the if the mount is successful, set to EFalse otherwise. + +@return KErrNone if successful, otherwise one of the other system-wide error codes, reflecting the failure of the mount operation. + +@capability DiskAdmin + +@see RFs::TDriveNumber +@see RFs::AddFileSystem +@see RFs::FileSystemName +*/ + { + TRACEMULT3(UTF::EBorder, UTraceModuleEfsrv::EFsMountFileSystemAndScan1, MODULEUID, Handle(), aFileSystemName, aDrive); + aIsMountSuccess=EFalse; + TPckg pckg(aIsMountSuccess); + TInt r = SendReceive(EFsMountFileSystemScan,TIpcArgs(&aFileSystemName,aDrive,NULL,&pckg)); + + TRACERET2(UTF::EBorder, UTraceModuleEfsrv::EFsMountFileSystemAndScan1Return, MODULEUID, r, aIsMountSuccess); + return r; + } + +EFSRV_EXPORT_C TInt RFs::MountFileSystemAndScan(const TDesC& aFileSystemName,const TDesC& aExtensionName,TInt aDrive,TBool& aIsMountSuccess) const +/** +Mounts a file system on a drive, and the specified extension and performs a scan on that drive. + +The file system must first have been added to the file server, +using AddFileSystem(). + +Note that the scan is done only if the mount is successful. + +The operation is asynchronous, i.e other concurrent file server operations can continue. + +@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 aIsMountSuccess On return, set to: ETrue, if the if the mount + is successful, set to EFalse otherwise. + +@return KErrNone if successful, otherwise one of the other system-wide + error codes, reflecting the failure of the mount operation. + +@capability DiskAdmin + +@see RFs::TDriveNumber +@see RFs::AddFileSystem +@see RFs::FileSystemName +*/ + { + TRACEMULT5(UTF::EBorder, UTraceModuleEfsrv::EFsMountFileSystemAndScan2, MODULEUID, + Handle(), aFileSystemName, aExtensionName, aDrive, aIsMountSuccess); + + aIsMountSuccess=EFalse; + TPckg pckg(aIsMountSuccess); + TInt r = SendReceive(EFsMountFileSystemScan,TIpcArgs(&aFileSystemName,aDrive,&aExtensionName,&pckg)); + + TRACERET2(UTF::EBorder, UTraceModuleEfsrv::EFsMountFileSystemAndScan2Return, MODULEUID, r, aIsMountSuccess); + return r; + } + +EFSRV_EXPORT_C TInt RFs::DismountFileSystem(const TDesC& aFileSystemName,TInt aDrive) const +/** +Dismounts the file system from the specified drive. + +@param aFileSystemName The fullname of the file system, as returned from + a call to FileSystemName(). +@param aDrive The drive from which the file system is to be dismounted. + +@return KErrNone, if successful; + KErrNotFound, if aFileSystemName is not found; + KErrNotReady, if the drive does not have a file system mounted on it; + KErrInUse, if the drive has a resource open on it; + KErrAccessDenied, if there is an attempt to dismount a ROM file system, + a substituted drive, or the drive which is the default drive; + KErrArgument, if the specified drive value is outsdide of the valid range. + KErrPermissionDenied, if the client does not have the necessary capabilities + to dismount the file system. + +@capability DiskAdmin + +@see RFs::FileSystemName +*/ + { + TRACEMULT3(UTF::EBorder, UTraceModuleEfsrv::EFsDismountFileSystem, MODULEUID, Handle(), aFileSystemName, aDrive); + TInt r = SendReceive(EFsDismountFileSystem,TIpcArgs(&aFileSystemName,aDrive)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsDismountFileSystemReturn, MODULEUID, r); + return r; + } + + + + +/** + Gets the name of the file system mounted on the specified drive. + + The function can be called before calling DismountFileSystem(). + + @param aName On successful return, contains the name of the file system. + @param aDrive The drive for which the file system name is required. + + @return KErrNone, if successful; + KErrNotFound if aFileSystemName is not found, or the drive does not have a file system mounted on it; + KErrArgument, if the drive value is outside the valid range, i.e. zero to KMaxDrives-1 inclusive. + + @see RFs::DismountFileSystem +*/ +EFSRV_EXPORT_C TInt RFs::FileSystemName(TDes& aName,TInt aDrive) const + { + TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFsFileSystemName, MODULEUID, Handle(), aDrive); + + //-- ipc argument "-1" here is to indicate legacy FileSystemName() API + TInt r = SendReceive(EFsFileSystemName,TIpcArgs(&aName, aDrive, -1)); + + TRACERETMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsFileSystemNameReturn, MODULEUID, r, aName); + return r; + } + + +/** + Get one of the supported file system names on a specified drive. This API can be used for enumerating + file systems that can be recognised and mounted automatically, without user's interaction. + If the automatic recognition and mountng some known file systems is supported on the specified drive, there + shall be at least 2 names in the list. For example "FAT" and "exFAT". + If "automatic file system recognising" feature is not supported, the list will consist of just one name, and + this will be the name returned by RFs::FileSystemName() API. + + @param aName On successful return, contains the name of the file system that correspond to the aFsEnumerator value. + m@param aDrive The drive number + @param aFsEnumerator The supported file system enumerator. can be: + KRootFileSystem a special value; in this case the returned name will be the same as obtained by FileSystemName() + 0,1,2... integer values specifying the sequential number of supported filesystem. See the return error code. + + @return KErrNone success, aName contains a valid name for the supported file system number "aFsEnumerator" on this drive. + KErrNotFound the end of the supported file names list; "aFsEnumerator-1" was the last correct value + KErrArgument incorrect arguments + + + @see FileSystemName() + @see KRootFileSystem +*/ +EFSRV_EXPORT_C TInt RFs::SupportedFileSystemName(TDes& aName, TInt aDrive, TInt aFsEnumerator) const + { + if(aFsEnumerator < 0) + return KErrArgument; //-- see RFs::FileSystemName(). "-1" is a reserved value + + TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFsFileSystemName, MODULEUID, Handle(), aDrive); + + TInt r = SendReceive(EFsFileSystemName,TIpcArgs(&aName, aDrive, aFsEnumerator)); + + TRACERETMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsFileSystemNameReturn, MODULEUID, r, aName); + return r; + } + + + + + +EFSRV_EXPORT_C TInt RFs::AddExtension(const TDesC& aFileName) +/** +Loads the specified extension. + +@param aFileName The file name of the extension + +@return KErrNone, if successful; otherwise one of the other system wide error codes. +*/ + { + TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsAddExtension, MODULEUID, Handle(), aFileName); + RLoader loader; + TInt r = loader.Connect(); + if (r==KErrNone) + { + r = loader.SendReceive(ELoadFSExtension, TIpcArgs(0, &aFileName, 0)); + loader.Close(); + } + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsAddExtensionReturn, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::MountExtension(const TDesC& aExtensionName,TInt aDrive) +/** +Mounts the the specified extension. + +The extension must first have been loaded using AddExtension(). + +@param aExtensionName The fullname of the extension, as returned from + a call to ExtensionName(). +@param aDrive The drive on which the extension is to be mounted; + +@return KErrNone if successful; + KErrNotFound, if the extension cannot be found; + otherwise one of the other system-wide error codes. + +@see RFs::ExtensionName +*/ + { + TRACEMULT3(UTF::EBorder, UTraceModuleEfsrv::EFsMountExtension, MODULEUID, Handle(), aExtensionName, aDrive); + TInt r = SendReceive(EFsMountExtension,TIpcArgs(&aExtensionName,aDrive)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsMountExtensionReturn, MODULEUID, r); + return r; + } + + + + +/** +Dismounts the specified extension. + +@param aExtensionName The fullname of the extension, as returned from a call to ExtensionName(). +@param aDrive The drive this extension is to be dismounted from. + +@return KErrNone if successful; + KErrNotFound if the extension cannot be found; + otherwise one of the other system-wide error codes. + +@see RFs::ExtensionName +*/ +EFSRV_EXPORT_C TInt RFs::DismountExtension(const TDesC& aExtensionName,TInt aDrive) + { + TRACEMULT3(UTF::EBorder, UTraceModuleEfsrv::EFsDismountExtension, MODULEUID, Handle(), aExtensionName, aDrive); + TInt r = SendReceive(EFsDismountExtension,TIpcArgs(&aExtensionName,aDrive)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsDismountExtensionReturn, MODULEUID, r); + return r; + } + + +EFSRV_EXPORT_C TInt RFs::RemoveExtension(const TDesC& aExtensionName) +/** +Removes the specified extension. + +@param aExtensionName The fullname of the extension, as returned from + a call to ExtensionName(). + +@return KErrNone, if successful; + KErrNotFound, if aExtensionName is not found; + otrherwise one of the other system-wide error codes. +*/ + { + TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsRemoveExtension, MODULEUID, Handle(), aExtensionName); + TInt r = SendReceive(EFsRemoveExtension,TIpcArgs(&aExtensionName)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsRemoveExtensionReturn, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::ExtensionName(TDes& aExtensionName,TInt aDrive,TInt aPos) +/** +Gets the name of the extension on the specified drive at the specified position +in the extension hierarchy. + +@param aExtensionName On successful return, contains the name of the extension. +@param aDrive The drive for which the extension name is required. +@param aPos The position of the extension in the extension hierarchy. + +@return KErrNone, if successful; + KErrNotFound if the extension name is not found; +*/ + { + TRACEMULT4(UTF::EBorder, UTraceModuleEfsrv::EFsExtensionName, MODULEUID, Handle(), aExtensionName, aDrive, aPos); + TInt r = SendReceive(EFsExtensionName,TIpcArgs(&aExtensionName,aDrive,aPos)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsExtensionNameReturn, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::RemountDrive(TInt aDrive,const TDesC8* aMountInfo,TUint aFlags) +/** +Forces a remount of the specified drive. + +@param aDrive The drive for which a remount is to be forced. +@param aMountInfo Information passed down to the media driver. The meaning of + this information depends on the media driver, for example, + keys for secure areas. +@param aFlags When the flag is set to + 0x00000001 - Used to simulate ejecting and re-inserting the media. + 0x80000000 - used to force the media driver for the specified logical + drive to be closed and reopened. + +@return KErrNone if successful, otherwise one of + the other system wide error codes. +*/ + { + TRACE4(UTF::EBorder, UTraceModuleEfsrv::EFsRemountDrive, MODULEUID, Handle(), aDrive, aMountInfo, aFlags); + TInt r = SendReceive(EFsRemountDrive,TIpcArgs(aDrive,aMountInfo,aFlags)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsRemountDriveReturn, MODULEUID, r); + return r; + } + + + +EFSRV_EXPORT_C void RFs::NotifyChange(TNotifyType aType,TRequestStatus& aStat) +/** +Requests a notification of change to files or directories. + +Changes are notified either: + +1. following any change in the file system + +or + +2. only following the addition or deletion of a directory entry, or after + a disk has been formatted or changed. + +Such notification is useful for programs that maintain displays +of file lists which must be dynamically updated. The alternative is to do +no updating, or to perform periodic monitoring for change, which +is inefficient. + +This is an asynchronous request and, as such, results in precisely one signal +to the request status passed as a parameter. To avoid missing any change, this +request should be issued before the first file list is constructed. When +the request completes, a new request should be issued before the next file +list is constructed. When the file server session is +closed, this request is implicitly cancelled. + +Call NotifyChangeCancel() to explicitly cancel a notification request. + +@param aType Indicates the kind of change that should result in notification. + For example: + ENotifyEntry causes notification only when an entry is added or + deleted, or when a disk is formatted or changed; + ENotifyAll causes notification following any type of change, such + as when a file is written to, or when a file's attributes + are changed. +@param aStat The request status. + This is set to KErrNone on completion, otherwise one of the other + system-wide error codes. + +*/ + { + TRACE3(UTF::EBorder, UTraceModuleEfsrv::EFsNotifyChange1, MODULEUID, Handle(), aType, &aStat); + aStat=KRequestPending; + // for backward compatibility + TNotifyType type = (aType == 0 ? ENotifyEntry : aType); + RSessionBase::SendReceive(EFsNotifyChange, TIpcArgs(type,&aStat) , aStat ); + //This call is to synchronise with the file server when this functions stack varibles can go out of scope + SendReceive(EFsSynchroniseDriveThread, TIpcArgs(-1)); + + TRACE0(UTF::EBorder, UTraceModuleEfsrv::EFsNotifyChange1Return, MODULEUID); + } + + + + +EFSRV_EXPORT_C void RFs::NotifyChange(TNotifyType aType,TRequestStatus& aStat,const TDesC& aPathName) +/** +Requests a notification of change to files or directories, allowing +a directory/file path to be specified. + +Changes are notified either: + +1. following any change in the file system + +or + +2. only following the addition or deletion of a directory entry, or after + a disk has been formatted or changed. + +Such notification is useful for programs that maintain displays +of file lists which must be dynamically updated. The alternative is to do +no updating, or to perform periodic monitoring for change, which +is inefficient. + +This is an asynchronous request and, as such, results in precisely one signal +to the request status passed as a parameter. To avoid missing any change, this +request should be issued before the first file list is constructed. When +the request completes, a new request should be issued before the next file +list is constructed. When the file server session is +closed, this request is implicitly cancelled. + +Call NotifyChangeCancel() to explicitly cancel a notification request. + +@param aType Indicates the kind of change that should result in + notification. For example: + ENotifyEntry causes notification only when an entry is added + or deleted, or when a disk is formatted or changed; + ENotifyAll causes notification following any type of change, + such as when a file is written to, or when a file's attributes + are changed. +@param aStat The request status. + This is set to KErrNone on completion, otherwise one of + the other system-wide error codes. +@param aPathName The directory or file for which notification is required. By + specifying a drive as a wildcard, for example + "?:\\Resource\\apps\\", or + "*:\\Resource\\apps\\", a client can ask to be notified of changes + to a given directory on any drive. + As with all directory paths aPathName must be terminated with '\\', + Please refer to "Structure of paths and filenames" section in the + Symbian OS Library. + +@capability Dependent If aName is /Sys then AllFiles capability is required. +@capability Dependent If aName begins with /Private and does not match this process' SID + then AllFiles capability is required. + +*/ + { + TRACEMULT4(UTF::EBorder, UTraceModuleEfsrv::EFsNotifyChange2, MODULEUID, Handle(), (TUint) aType, (TUint) &aStat, aPathName); + aStat=KRequestPending; + // for backward compatibility + TNotifyType type = (aType == 0 ? ENotifyEntry : aType); + RSessionBase::SendReceive(EFsNotifyChangeEx,TIpcArgs(type,&aPathName,&aStat),aStat); + //This call is to synchronise with the file server when this functions stack varibles can go out of scope + SendReceive(EFsSynchroniseDriveThread, TIpcArgs(-1)); + + TRACE0(UTF::EBorder, UTraceModuleEfsrv::EFsNotifyChange2Return, MODULEUID); + } + + + + +EFSRV_EXPORT_C void RFs::NotifyChangeCancel() +/** +Cancels all outstanding requests for notification of change +to files or directories. + +All outstanding requests complete with KErrCancel. + +Note that this is a synchronous function. + +*/ + { + TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsNotifyChangeCancel1, MODULEUID, Handle()); + RSessionBase::SendReceive(EFsNotifyChangeCancel); + + TRACE0(UTF::EBorder, UTraceModuleEfsrv::EFsNotifyChangeCancel1Return, MODULEUID); + } + + + + +EFSRV_EXPORT_C void RFs::NotifyChangeCancel(TRequestStatus& aStat) +/** +Cancels the specific request for notification of change +to files or directories. + +The outstanding request completes with KErrCancel. + +Note that this is an asynchronous function. + +@param aStat The request status object associated with the request + to be cancelled. Note that the function does not change + this parameter. + +*/ + { + TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFsNotifyChangeCancel2, MODULEUID, Handle(), &aStat); + if (aStat==KRequestPending) // May be better to ASSERT this? + SendReceive(EFsNotifyChangeCancelEx,TIpcArgs(&aStat)); + + TRACE0(UTF::EBorder, UTraceModuleEfsrv::EFsNotifyChangeCancel2Return, MODULEUID); + } + + + + +EFSRV_EXPORT_C void RFs::NotifyDiskSpace(TInt64 aThreshold,TInt aDrive,TRequestStatus& aStat) +/** +Requests notification when the free disk space on the specified +drive crosses the specified threshold value. + +The threshold is crossed if free disk space increases to a value above +the threshold value or decreases to a value below the threshold value. + +This is an asynchronous request that completes if any of the +following events occur: + +1. the threshold is crossed + +2. any drive is formatted + +3. there is a media change on any socket + +4. power up + +5. the scandrive utility is run on any drive + +5. the specified threshold value is outside its limits + +7. the outstanding request is cancelled. + +Note that free disk space notification is not supported for +drives using remote file systems. + +@param aThreshold The threshold value. This must be greater than zero and less + than the total size of the disk. +@param aDrive The drive number. This is an explicit drive defined by one of + the TDriveNumber enum values or the value + KDefaultDrive. If KDefaultDrive is specified, then + the drive monitored is the session path drive. +@param aStat The request status object. On request completion, contains: + KErrNone, if the threshold value is crossed, if any drive is + formatted, if there is a media change on any socket, if there is a power up or + if the scandrive utility is run on any drive; + KErrCancel, if the outstanding request is cancelled by a call to + NotifyDiskSpaceCancel(); + KErrArgument, if the threshold value is outside its limits. + +@see TDriveNumber +*/ + { + TRACE5(UTF::EBorder, UTraceModuleEfsrv::EFsNotifyDiskSpace, MODULEUID, + Handle(), I64LOW(aThreshold),I64HIGH(aThreshold), aDrive,(TUint) &aStat); + aStat=KRequestPending; + TPtrC8 tBuf((TUint8*)&aThreshold,sizeof(TInt64)); + RSessionBase::SendReceive(EFsNotifyDiskSpace,TIpcArgs(&tBuf,aDrive,&aStat), aStat); + //This call is to synchronise with the driver thread as corresponding cancel function (NotifyDiskSpaceCancel) + //is synchronous, so it can complete before this notify request has even been added to TDiskSpaceQue. + //This call guarantees that the notify request has been added to queue. + SendReceive(EFsSynchroniseDriveThread, TIpcArgs(aDrive)); + + + TRACE0(UTF::EBorder, UTraceModuleEfsrv::EFsNotifyDiskSpaceReturn, MODULEUID); + } + + + + +EFSRV_EXPORT_C void RFs::NotifyDiskSpaceCancel(TRequestStatus& aStat) +/** +Cancels a specific outstanding request for free disk space +notification. + +The outstanding request completes with KErrCancel. + +@param aStat The request status object identified with the original + notification request. +*/ + { + TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFsNotifyDiskSpaceCancel1, MODULEUID, Handle(), &aStat); + + if(aStat==KRequestPending) + SendReceive(EFsNotifyDiskSpaceCancel,TIpcArgs(&aStat)); + + TRACE0(UTF::EBorder, UTraceModuleEfsrv::EFsNotifyDiskSpaceCancel1Return, MODULEUID); + } + + + + +EFSRV_EXPORT_C void RFs::NotifyDiskSpaceCancel() +/** +Cancels all outstanding requests for free disk space +notification. + +Outstanding requests complete with KErrCancel. +*/ + { + TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsNotifyDiskSpaceCancel2, MODULEUID, Handle()); + SendReceive(EFsNotifyDiskSpaceCancel,TIpcArgs(NULL)); + + TRACE0(UTF::EBorder, UTraceModuleEfsrv::EFsNotifyDiskSpaceCancel2Return, MODULEUID); + } + + + + +EFSRV_EXPORT_C TInt RFs::DriveList(TDriveList& aList) const +/** +Gets a list of the available (not remote and non hidden) drives. + +The drive list consists of an array of 26 bytes. Array index zero corresponds +to drive A, index one equals B etc. + +Each byte with a non zero value signifies that the corresponding drive is available +to the system. In the case of removable media, RFs::Drive should be used to determine +whether the media is inserted or not. + +The local file system always reserves drive letters A through I. +Drive letter Z is always used for the ROM which means that letters J through Y +are available to be used by SetSubst() or for redirecting. + +@param aList On return, contains a list of drive attributes (only the first 8 bits) for the available non-remote and non-hidden drives. + +@return KErrNone, successful, otherwise one of the other system-wide error codes. +*/ + { + TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsDriveList1, MODULEUID, Handle()); + TInt r = SendReceive(EFsDriveList,TIpcArgs(&aList, KDriveAttExclude|KDriveAttRemote|KDriveAttHidden)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsDriveList1Return, MODULEUID, r); + return r; + } + + + +EFSRV_EXPORT_C TInt RFs::DriveList(TDriveList& aList, TUint aFlags) const +/** +Gets a list of the available drives that match a combination of drive attributes,specified in aFlags. +This combination may include,exclude or exclusively specify the attributes that that drives to be returned +should match. + +The drive list consists of an array of 26 bytes. Array index zero corresponds +to drive A, index one equals B etc. + +Each byte with a non zero value signifies that the corresponding drive is available +to the system. In the case of removable media, RFs::Drive should be used to determine +whether the media is inserted or not. + +The local file system always reserves drive letters A through I. +Drive letter Z is always used for the ROM which means that letters J through Y +are available to be used by SetSubst() or for redirecting. + +@param aList On return, contains a list of available drives that qualify aFlags. + +@param aFlags A combination of drive attributes that drives to be returned must qualify. + +@return KErrNone, successful, otherwise one of the other system-wide error codes; + KErrArgument, If aFlags contains an invalid attribute combination. +*/ + { + TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFsDriveList2, MODULEUID, Handle(), aFlags); + TInt r = SendReceive(EFsDriveList,TIpcArgs(&aList,aFlags)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsDriveList2Return, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::Drive(TDriveInfo& anInfo,TInt aDrive) const +/** +Gets information about a drive and the medium mounted on it. + +Note that Volume() can also be used to give information about the drive and +the volume mounted on it. These two functions are separate because, while +the characteristics of a drive cannot change, those of a +volume can, by mounting different media, reformatting etc. + +@param anInfo On return, contains information describing the drive + and the medium mounted on it. The value of TDriveInfo::iType + shows whether the drive contains media. +@param aDrive The drive for which information is requested. + Specify KDefaultDrive for the session default drive. + 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. + +@see RFs::Volume +*/ + { + TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFsDrive, MODULEUID, Handle(), aDrive); + + TPckg m(anInfo); + TInt r = SendReceive(EFsDrive,TIpcArgs(&m,aDrive)); + + TRACERET4(UTF::EBorder, UTraceModuleEfsrv::EFsDriveReturn, MODULEUID, r, anInfo.iDriveAtt, anInfo.iMediaAtt, anInfo.iType); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::Volume(TVolumeInfo& aVol,TInt aDrive) const +/** +Gets volume information for a formatted device. + +This function provides additional information to that given by Drive(), +including the volume label, if set, and the amount of free space on the +disk. + +Note, use Drive() to get information about the drive without reference to +a volume. These two functions are separate because, while the characteristics +of a drive cannot change, those of a volume can, by mounting different media, +reformatting etc. A volume may not even be present if the media is removable. + +@param aVol On return, contains the volume information. +@param aDrive The drive which contains the media for which volume information is to be displayed. + Specify a drive in the range EDriveA to EDriveZ for drives A to Z respectively. + The default drive is the session default drive KDefaultDrive. + +@return KErrNone, if successful; + KErrNotReady, if the drive contains no media; + otherwise one of the other system-wide error codes. + +@see RFs::Drive +*/ + { + TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFsVolume1, MODULEUID, Handle(), aDrive); + TPckg v(aVol); + TInt r = SendReceive(EFsVolume,TIpcArgs(&v,aDrive,NULL)); + + TRACE7(UTF::EBorder, UTraceModuleEfsrv::EFsVolume1Return, MODULEUID, + r, aVol.iUniqueID, I64LOW(aVol.iSize), I64HIGH(aVol.iSize), + I64LOW(aVol.iFree), I64HIGH(aVol.iFree), aVol.iFileCacheFlags); + return r; + } + +/** +Gets volume information for a formatted device asynchronously. +@see TInt RFs::Volume(TVolumeInfo& aVol,TInt aDrive) for the synchronous version. + +"Asynchronously" corresponds to the amount of free space on the volume in TVolumeInfo::iFree. +I.e. this function returns the _current_ amount of free space on the volume, which can be changing due to some +filesystems' activities. For example, some filesystems can be performing free space calculations in the background. +Comparing to the RFs::Volume(TVolumeInfo& aVol,TInt aDrive), this method doesn't block the client until background filesystem +activity finishes, which can be useful in some situations. + +@param aVol On return, contains the volume information with the _current_ value in the TVolumeInfo::iFree. +@param aDrive Drive number to query. Specify a drive in the range EDriveA to EDriveZ for drives A to Z respectively. +@param aStat request status. At present is used just for indication of the asynchronous version and gets immediately completed, so there is no reason to analyse its value. + +@publishedPartner +@prototype +*/ +EFSRV_EXPORT_C void RFs::Volume(TVolumeInfo& aVol,TInt aDrive, TRequestStatus& aStat) const + { + TRACE3(UTF::EBorder, UTraceModuleEfsrv::EFsVolume2, MODULEUID, Handle(), aDrive, &aStat); + TPckg v(aVol); + aStat=KRequestPending; + RSessionBase::SendReceive(EFsVolume,TIpcArgs(&v,aDrive,&aStat), aStat); + + TRACE0(UTF::EBorder, UTraceModuleEfsrv::EFsVolume2Return, MODULEUID); + } + + +EFSRV_EXPORT_C TInt RFs::SetVolumeLabel(const TDesC& aName,TInt aDrive) +/** +Sets the label for a volume. + +Note that similar to file names, volume labels can be set with unicode characters. +However it may not be recognized properly if correct code page is not +loaded or it is mounted onto a system that does not support DBCS volume +labels + +@param aName The volume label. +@param aDrive The drive containing the media whose label is to be set. + Specify a drive in the range EDriveA to EDriveZ for + drives A to Z. + The default drive is the session default drive KDefaultDrive. + +@return KErrNone, if successful; + KErrNotReady, if the drive contains no media; + otherwise one of the other system-wide error codes. + +@capability DiskAdmin + +@see TDriveNumber +@see TVolumeInfo::iName +@see RFs::Volume +*/ + { + TRACEMULT3(UTF::EBorder, UTraceModuleEfsrv::EFsSetVolumeLabel, MODULEUID, + Handle(), aName, aDrive); + + TInt r = SendReceive(EFsSetVolume,TIpcArgs(&aName,aDrive)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsSetVolumeLabelReturn, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::Subst(TDes& aPath,TInt aDrive) const +/** +Gets the path assigned to a drive letter by an earlier call to SetSubst(). + +To find out whether a drive letter has been substituted, first get the drive +information, using Drive(), and then test the value of the KDriveAttSubsted bit +provided by TDriveInfo::iDriveAtt. + +@param aPath On return, contains the path which has been assigned to the + drive. If the drive letter has not been substituted, this argument + returns an empty descriptor. +@param aDrive The drive which is the subject of the enquiry. Specify a number + in the range 0 (EDriveA) to 25 (>EDriveZ) for drives + A to Z. The default drive is the session default + drive KDefaultDrive. + +@return KErrNone, if successful, otherwise one of the other + system-wide error codes. + +@see RFs::SetSubst +@see TDriveInfo +@see RFs::Drive +*/ + { + TRACEMULT3(UTF::EBorder, UTraceModuleEfsrv::EFsSubst, MODULEUID, Handle(), aPath, aDrive); + TInt r = SendReceive(EFsSubst,TIpcArgs(&aPath,aDrive)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsSubstReturn, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::SetSubst(const TDesC& aPath,TInt aDrive) +/** +Assigns a path to a drive letter. + +Whenever that drive letter is used, it will be translated into a reference +to the path specified here. To clear a drive substitution, specify an empty +descriptor for aPath. + +Note that the substituted path is text-only. Its components need not +be syntactically correct, nor must they be valid at the time the substitution +is set. Any component may be deleted, removed or unmounted while the +substitution is set. + +@param aPath The path to be assigned to the drive letter. If a drive letter + is specified in the path, it must not itself be substituted or + redirected, or the function will return an error. If no drive is + specified, the drive contained in the default session path is + used, and if no path is specified, the default session path is + used. If a filename or extension is included in the path, + the function will return an error. Therefore, the final component + in the path must have a trailing backslash to indicate that it is + a directory. + +@param aDrive The drive to which a path is to be assigned. Specify a number + in the range 0 (EDriveA) to 25 (EDriveZ) for drives + A to Z. Must not be local, ROM, or redirected, otherwise an + error is returned. May be substituted, but only if the function + is being used to clear the substitution. If the same drive is + specified in the path, the function will return an error. + The default drive is the session default drive + KDefaultDrive. + +@return KErrNone, if successful; otherwise one of the other system-wide + error codes. + +@capability DiskAdmin +@capability Dependent If aPath is /Sys then Tcb capability is required. +@capability Dependent If aPath begins with /Private and does not match this process' SID + then AllFiles capability is required. +@capability Dependent If aPath is /Resource then Tcb capability is required. +*/ + { + TRACEMULT3(UTF::EBorder, UTraceModuleEfsrv::EFsSetSubst, MODULEUID, Handle(), aPath, aDrive); + TInt r = SendReceive(EFsSetSubst,TIpcArgs(&aPath,aDrive)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsSetSubstReturn, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::RealName(const TDesC& aName,TDes& aResult) const +/** +Gets the real name of a file. + +This is used in circumstances where a file system needs to +mangle Symbian OS natural names so that it can store them on that file +system. + +@param aName Contains the name by which the file is normally referred. +@param aResult On return, contains the real name of the file, comprising the + full path, including the drive letter. + +@return KErrNone if successful, otherwise one of the other + system-wide error codes. + +@capability Dependent If aName is /Sys then AllFiles capability is required. +@capability Dependent If aName begins with /Private and does not match this process' SID + then AllFiles capability is required. + +*/ + { + TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsRealName, MODULEUID, Handle(), aName); + TInt r = SendReceive(EFsRealName,TIpcArgs(&aName,&aResult)); + + TRACERETMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsRealNameReturn, MODULEUID, r, aResult); + return r; + } + + + + +/** +Gets the serial number of media. + +Only local drive is allowed. Substed drive number will return KErrNotSupported. + +@param aSerialNum Contains serial number on successful return. +@param aDrive Drive number. + +@return KErrNone if successful; + KErrNotSupported if media doesn't support serial number (e.g. substed drives); + KErrBadName if drive number is invalid; + otherwise one of system-wide error codes. + +@see TMediaSerialNumber +*/ +EFSRV_EXPORT_C TInt RFs::GetMediaSerialNumber(TMediaSerialNumber& aSerialNum, TInt aDrive) + { + TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFsGetMediaSerialNumber, MODULEUID, Handle(), aDrive); + TInt r = SendReceive(EFsGetMediaSerialNumber, TIpcArgs(&aSerialNum, aDrive)); + + TRACERETMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsGetMediaSerialNumberReturn, MODULEUID, r, aSerialNum); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::SessionPath(TDes& aPath) const +/** +Gets the session path. + +When a client connects to the file server, its session path is initialised to +the system default path. The session path of an existing client can only be +changed by this function. + +@param aPath On return, contains the session path, including a trailing + backslash. + +@return KErrNone if successful, otherwise one of the other + system-wide error codes. +*/ + { + TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsSessionPath, MODULEUID, Handle()); + TInt r = SendReceive(EFsSessionPath,TIpcArgs(&aPath)); + + TRACERETMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsSessionPathReturn, MODULEUID, r, aPath); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::SetSessionPath(const TDesC& aPath) +/** +Sets the session path for the current file server client. + +When the client first connects to the file server, its session path +is initialised to the system default path. + +Note that the session path is text-only. It does not cause any locking. +Thus, although the path must be syntactically correct, its components +do not need to be valid at the time the path is set, and any component may be +deleted, removed or unmounted while the path is set. + +@param aPath The new session path. Consists of a drive and path. Normally, a + drive should be specified, but if not, the drive specified in + the existing session path is preserved. If a file is specified, + then the function fails and returns an error code. Therefore, + the final component in the path must have a trailing backslash + to indicate that it is a directory. All components of the + path must be syntactically correct, for example, wildcard + characters and double backslashes are not allowed in any + part of it. + +@return KErrNone if successful, otherwise one of the other + system-wide error codes. + +@capability Dependent If aPath is /Sys then AllFiles capability is required. +@capability Dependent If aPath begins with /Private and does not match this process' SID + then AllFiles capability is required. + +*/ + { + TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsSetSessionPath, MODULEUID, Handle(), aPath); + TInt r = SendReceive(EFsSetSessionPath,TIpcArgs(&aPath)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsSetSessionPathReturn, MODULEUID, r); + return r; + } + + + + + +/** +Makes a directory. + +It should be a sub-directory of an existing directory and its name should be +unique within its parent directory, otherwise the function returns error code KErrAlreadyExists. + +Note that if a filename is specified in the argument, it is ignored. +Therefore, there should be a trailing backslash after the final +directory name in the argument to indicate that it is a directory, not a filename. + +For example, following code will create directory "C:\\DIR1\\" + +@code +fs.MkDir(_L("C:\\DIR1\\")); +@endcode + +The last line in the following example will result in KErrAlreadyExists because "DIR2" doesn't have a trailing backslash, +therefore is considered as a file name and discarded. Directory "C:\\DIR1\\" has already been created. + +@code +fs.MkDir(_L("C:\\DIR1\\")); // shall create DIR1 in the root directory +fs.MkDir(_L("C:\\DIR1\\DIR2")); // No trailing backslash, fails with KErrAlreadyExists +@endcode + +This example will always fail because "DIR1" doesn't have a trailing backslash and discarded while the root +directory always exists. + +@code +fs.MkDir(_L("C:\\DIR1")); // No trailing backslash, will always fail with KErrAlreadyExists +@endcode + +Note, the following case + +@code +fs.MkDir(_L("C:\\example.txt\\")); // would normally create a directory "c:\\example.txt\\" with KErrNone +@endcode + +But if there is a file named "example.txt", which exists at the same location, KErrAccessDenied is returned. + +Note also that because this method can return an error code (eg. because +the disk is full) before checking whether the path already exists, it +is not appropriate to use it just to work out whether a path exists or not. + +See MkDirAll(), which may also create intermediate directories. + +@param aPath The name of the new directory. Any path components which are + not specified here will be taken from the session path. + The directory name shall not contain wild cards ('?' or '*' characters) + and illegal characters like '<', '>', ':', '"', '/', '|' and '\000'. + The directory name containing only whilte space characters + (See TChar::IsSpace()) is also illegal. + +@return KErrNone if successful, otherwise one of the other + system-wide error codes. Even if another error code is returned, + (for example, if the disk is full) it is still possible that the + path may already exist. + +@capability Dependent If aPath is /Sys then Tcb capability is required. +@capability Dependent If aPath begins with /Private and does not match this process' SID + then AllFiles capability is required. +@capability Dependent If aPath is /Resource then Tcb capability is required. + +@see RFs::MkDirAll +*/ +EFSRV_EXPORT_C TInt RFs::MkDir(const TDesC& aPath) + { + TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsMkDir, MODULEUID, Handle(), aPath); + TInt r = SendReceive(EFsMkDir,TIpcArgs(&aPath,NULL)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsMkDirReturn, MODULEUID, r); + return r; + } + + + + + +/** +Makes one or more directories. + +Any valid path component specified in aPath which does not already exist is +created as a directory. + +Note that if a filename is specified in the argument, it is ignored. +Therefore, there should be a trailing backslash after the final +directory name in the argument to indicate that it is a directory, not a +filename. + +See also notes on RFs::MkDir() about trailing backslashes in directory names. + +Note also that because this method can return an error code (eg. because +the disk is full) before checking whether the path already exists, it +is not appropriate to use it just to work out whether a path exists or not. + +See MkDir(), which creates only a single new directory. + +@param aPath The path name specifiying the directory or directories to + create. If the function completes successfully, this path + identifies a valid directory. Any path components which are not + specified here are taken from the session path. + +@return KErrNone if successful, otherwise one of the other + system-wide error codes. Even if another error code is returned, + (for example, if the disk is full) it is still possible that the + path may already exist. + + +@capability Dependent If aPath is /Sys then Tcb capability is required. +@capability Dependent If aPath begins with /Private and does not match this process' SID + then AllFiles capability is required. +@capability Dependent If aPath is /Resource then Tcb capability is required. + +@see RFs::MkDir +*/ +EFSRV_EXPORT_C TInt RFs::MkDirAll(const TDesC& aPath) + { + TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsMkDirAll, MODULEUID, Handle(), aPath); + TInt r = SendReceive(EFsMkDir,TIpcArgs(&aPath,TRUE)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsMkDirAllReturn, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::RmDir(const TDesC& aPath) +/** +Removes a directory. + +The directory must be empty and cannot be the root directory. + +Note that if a filename is specified in the argument, it is +ignored. + +For example, following code will result in directory "C:\\SRC\\" being removed as long as +it is empty, the existance of "ENTRY" will not be checked: + +@code +fs.RmDir(_L("C:\\SRC\\ENTRY")); +@endcode + +Similarly, following code will try to remove "C:\\SRC\\" instead of "C:\\SRC\DIR\\": +@code +fs.RmDir(_L("C:\\SRC\\DIR")); +@endcode + +Therefore, there should be a trailing backslash after the final +directory name in the argument to indicate that it is a directory, not a +filename. + +See class CFileMan for information on deleting a +non-empty directory and all of its contents. + +@param aPath The path name of the directory to be removed. Any path components + which are not specified here are taken from the session path. Only + the lowest-level directory identified is removed. + +@return KErrNone, if successful; + KErrInUse, if trying to remove a non-empty directory or root directory; + otherwise, one of the other system-wide error codes. + +@capability Dependent If aPath is /Sys then Tcb capability is required. +@capability Dependent If aPath begins with /Private and does not match this process' SID + then AllFiles capability is required. +@capability Dependent If aPath is /Resource then Tcb capability is required. + +@see CFileMan +*/ + { + TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsRmDir, MODULEUID, Handle(), aPath); + TInt r = SendReceive(EFsRmDir,TIpcArgs(&aPath)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsRmDirReturn, MODULEUID, r); + return r; + } + + + + +void RFs::GetDirL(const TDesC& aName,const TUidType& aUidType,TUint aKey,CDir*& aFileList,RDir& aDir) const +// +// Create a dir array. Leave on any error. +// + { + aFileList=NULL; + User::LeaveIfError(aDir.Open((RFs& )*this,aName,aUidType)); + DoGetDirL(aKey,aFileList,aDir); + } + +void RFs::GetDirL(const TDesC& aName,TUint anAttMask,TUint aKey,CDir*& aFileList,RDir& aDir) const +// +// Create a dir array. Leave on any error. +// + { + + aFileList=NULL; + User::LeaveIfError(aDir.Open((RFs& )*this,aName,anAttMask)); + DoGetDirL(aKey,aFileList,aDir); + } + +void RFs::GetDirL(const TDesC& aName,TUint anAttMask,TUint aKey,CDir*& aFileList,CDir*& aDirList,RDir& aDir) const +// +// Create a dir array. Leave on any error. +// + { + + aDirList=NULL; + GetDirL(aName,anAttMask|KEntryAttDir,aKey,aFileList,aDir); + aFileList->ExtractL(!(anAttMask&KEntryAttDir),aDirList); + } + +void RFs::DoGetDirL(TUint aKey,CDir*& aFileList,RDir& aDir) const +// +// Create a dir array. Leave on any error. +// + { + + aFileList=CDir::NewL(); + TInt r; + TEntryArray* pArray=new(ELeave) TEntryArray; + CleanupStack::PushL(pArray); + + TEntryArray& array=*pArray; + do + { + r=aDir.Read(array); + if (r==KErrNone || r==KErrEof) + { + TInt count=array.Count(); + if (count==0) + break; + TInt i=0; + while (iAddL(array[i++]); + } + }while (r==KErrNone); + + CleanupStack::PopAndDestroy(); + if (!(r==KErrNone || r==KErrEof)) + User::Leave(r); + aFileList->Compress(); + if (aKey==ESortNone) + return; + + r=aFileList->Sort(aKey); + if (r!=KErrNone) + User::Leave(r); + } + + + + +EFSRV_EXPORT_C TInt RFs::GetDir(const TDesC& aName,const TUidType& aUidType,TUint aKey,CDir*& aFileList) const +/** +Gets a filtered list of a directory's contents by UID type. + +The aUidType parameter determines which file entry types should be listed. +The sort key determines the order in which they are listed. + +Notes: + +1. The function sets aFileList to NULL, and then allocates memory for it before + appending entries to the list. Therefore, aFileList should have no memory + allocated to it before this function is called, otherwise this memory + will become orphaned. + +2. The caller of this function is responsible for deleting aFileList after + the function has returned. + +@param aName The name of the directory for which a listing is required. + Wildcards may be used to specify particular files. +@param aUidType Only those files whose UIDs match those specified within this + UID type will be included in the file list. Any, or all, of + the three UIDs within the UID type may be omitted. + Any UID which is omitted acts in a similar manner to + a wildcard character, matching to all UIDs. +@param aKey The sort key. This is a set of flags indicating the order in + which the entries are to be sorted. These flags are defined + by TEntryKey. +@param aFileList On return contains a filtered list of directory and file entries. + +@return KErrNone if successful, otherwise one of the other + system-wide error codes. + +@see TEntryKey +*/ + { + TRACEMULT6(UTF::EBorder, UTraceModuleEfsrv::EFsGetDir1, MODULEUID, + Handle(), aName, aUidType[0].iUid, aUidType[1].iUid, aUidType[2].iUid, aKey); + + RDir d; + TRAPD(r,GetDirL(aName,aUidType,aKey,aFileList,d)) + d.Close(); + if (r!=KErrNone) + { + delete aFileList; + aFileList=NULL; + } + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsGetDir1Return, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::GetDir(const TDesC& aName,TUint anAttMask,TUint aKey,CDir*& aFileList) const +/** +Gets a filtered list of a directory's contents. + +The bitmask determines which file and directory entry types should be listed. +The sort key determines the order in which they are listed. + +Notes: + +1. If sorting by UID (as indicated when the ESortByUid bit is OR'ed with + the sort key), then UID information will be included in the listing + whether or not KEntryAttAllowUid is specified in anAttMask. + +2. The function sets aFileList to NULL, and then allocates memory for it before + appending entries to the list. Therefore, aFileList should have no memory + allocated to it before this function is called, otherwise this memory will + become orphaned. + +3. The caller of this function is responsible for deleting aFileList after + the function has returned. + +@param aName The name of the directory for which a listing is required. + Wildcards may be used to specify particular files. +@param anAttMask Bitmask indicating the attributes of interest. Only files and + directories whose attributes match those specified here can be + included in the listing. For more information, + see KEntryAttMatchMask and the other directory entry details. + Also see KEntryAttNormal and the other file or directory attributes. +@param aKey The sort key. This is a set of flags indicating the order in + which the entries are to be sorted. These flags are defined + by TEntryKey. +@param aFileList On return contains a filtered list of directory and file entries. + +@return KErrNone if successful, otherwise one of the other + system-wide error codes. + +@see TEntryKey +*/ + { + TRACEMULT4(UTF::EBorder, UTraceModuleEfsrv::EFsGetDir2, MODULEUID, Handle(), aName, anAttMask, aKey); + + RDir d; + if ((aKey&0xff)==ESortByUid) + anAttMask|=KEntryAttAllowUid; + TRAPD(r,GetDirL(aName,anAttMask,aKey,aFileList,d)) + d.Close(); + if (r!=KErrNone) + { + delete aFileList; + aFileList=NULL; + } + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsGetDir2Return, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::GetDir(const TDesC& aName,TUint anAttMask,TUint aKey,CDir*& aFileList,CDir*& aDirList) const +/** +Gets a filtered list of the directory and file entries contained in +a directory, and a list of the directory entries only. + +The bitmask determines which file and directory entry types should be listed in +aFileList. The contents of the second list, aDirList are not affected by the bitmask; it +returns all directory entries contained in directory aName. The +sort key determines the order in which both lists are sorted. + +Notes: + +1. If sorting by UID (as indicated when the ESortByUid bit is OR'ed with + the sort key), then UID information will be included in the listing + whether or not KEntryAttAllowUid is specified in anAttMask. + +2. The function sets both aFileList and aDirList to NULL, and then allocates + memory to them before appending entries to the lists. Therefore, aFileList + and aDirList should have no memory allocated to them before this + function is called, otherwise the allocated memory will become orphaned. + +3. The caller of this function is responsible for deleting aFileList + and aDirList after the function has returned. + +@param aName The name of the directory for which a listing is required. + Wildcards may be used to specify particular files. +@param anAttMask Bitmask indicating the attributes of interest. Only files and + directories whose attributes match those specified here can be + included in aFileList. aDirList is unaffected by this mask. + For more information, see KEntryAttMatchMask and the other + directory entry details. + Also see KEntryAttNormal and the other file or directory + attributes. +@param aKey The sort key. This is a set of flags indicating the order in + which the entries in both lists are to be sorted. These flags + are defined by TEntryKey. +@param aFileList On return contains a filtered list of directory and + file entries. +@param aDirList On return contains a filtered list of directory entries only. + +@return KErrNone if successful, otherwise one of the other + system-wide error codes. + +@see TEntryKey +*/ + { + TRACEMULT4(UTF::EBorder, UTraceModuleEfsrv::EFsGetDir3, MODULEUID, Handle(), aName, anAttMask, aKey); + + RDir d; + if (aKey&ESortByUid) + anAttMask|=KEntryAttAllowUid; + TRAPD(r,GetDirL(aName,anAttMask,aKey,aFileList,aDirList,d)) + d.Close(); + if (r!=KErrNone) + { + delete aFileList; + aFileList=NULL; + delete aDirList; + aDirList=NULL; + } + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsGetDir3Return, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::Parse(const TDesC& aName,TParse& aParse) const +/** +Parses a filename specification. + +Parsing is done with wildcard resolution, using the session path as +the default. You can then use TParse's getter functions to extract individual +components of the resulting name. All the path components that are included +in aName are put into the resulting filename. Any components that are still +missing are taken from the session path. + +Specifying: + +@code +TParse fp; +@endcode +@code +fs.Parse(name,fp); +@endcode + +is equivalent to + +@code +TParse fp; +@endcode +@code +fp.Set(name,NULL,&fs.SessionPath()); +@endcode + +Note that the function does not check for illegal characters, or for +illegal path components in either of the paths specified. + +@param aName The file name to be parsed, using the session path to provide + the missing components. +@param aParse A TParse objct that provides functions for + extracting individual components of the resulting file name. + +@return KErrNone if successful, otherwise one of the other + system-wide error codes. +*/ + { + TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsParse1, MODULEUID, Handle(), aName); + TFileName session_path; + TInt r = SessionPath(session_path); + if (r==KErrNone) + r = aParse.Set(aName, NULL, &session_path); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsParse1Return, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::Parse(const TDesC& aName,const TDesC& aRelated,TParse& aParse) const +/** +Parses a filename specification, specifying related file path components. + +Parsing is done with wildcard resolution, using the session path as +the default. You can then use TParse's getter functions to extract individual +components of the resulting name. All the path components that are included +in aName are put into the resulting filename. Any missing components are taken +from the optional aRelated argument, which has the next order of precedence. +Finally, any components that are still missing are taken from the session path. + +Specifying: + +@code +TParse fp; +@endcode +@code +fs.Parse(name,related,fp); +@endcode + +is equivalent to + +@code +TParse fp; +@endcode +@code +fp.Set(name,related,&fs.SessionPath()); +@endcode + +Note that the function does not check for illegal characters, or for +illegal path components in any of the paths specified. + +@param aName The file name to be parsed, using the session path and the + related path to provide the missing components. +@param aRelated The related file specification. +@param aParse A TParse objct that provides functions for + extracting individual components of the resulting file name. + +@return KErrNone if successful, otherwise one of the other + system-wide error codes. +*/ + { + TRACEMULT3(UTF::EBorder, UTraceModuleEfsrv::EFsParse2, MODULEUID, Handle(), aName, aRelated); + TFileName session_path; + TInt r = SessionPath(session_path); + if (r==KErrNone) + r = aParse.Set(aName, &aRelated, &session_path); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsParse2Return, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::Delete(const TDesC& aName) +/** +Deletes a single file. + +Wildcards are not allowed in either the file name or the extension, +otherwise an error is returned. + +Note that the file must be closed and must not be read-only. +Hidden files can be deleted but system files cannot. + +See class CFileMan for information on deleting multiple files. + +@param aName The name of the file to be deleted. Any path components which + are not specified here will be taken from the session path. + +@return KErrNone if successful, otherwise one of the other + system-wide error codes. + +@capability Dependent If aName is /Sys then Tcb capability is required. +@capability Dependent If aName begins with /Private and does not match this process' SID + then AllFiles capability is required. +@capability Dependent If aName is /Resource then Tcb capability is required. + +@see CFileMan +*/ + { + TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsDelete, MODULEUID, Handle(), aName); + TInt r = SendReceive(EFsDelete,TIpcArgs(&aName)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsDeleteReturn, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::Rename(const TDesC& anOldName,const TDesC& aNewName) +/** +Renames a single file or directory. + +It can also be used to move a file or directory by specifying different +destination and source directories. If so, the destination and source +directories must be on the same drive. If a directory is moved, then +the directory structure beneath it is also moved. + +If a directory specified by aNewName is different from one specified +by anOldName, then the file or directory is moved to the new directory. +The file or directory cannot be moved to another device by this means, +either explicitly (by another drive specified in the name) or implicitly +(because the directory has been mapped to another device with SetSubst(). + +The function fails and returns an error code in the following +circumstances: + +1. If either the old or new name includes wildcards. + +2. If a file or directory with the new name already exists in + the target directory. Overwriting is not permitted. + +3. If file anOldName does not exist, or is open. + +Read-only, system and hidden files may be renamed. The renamed +file's attributes are preserved. + +Note that when this function is operating on directories, a trailing backslash +is not required after the final directory name in either anOldName or aNewName. + +See class CFileMan for information on renaming multiple files. + +@param anOldName File or directory to be renamed. Any path components which are + not specified here will be taken from the session path. +@param aNewName Path specifying the new name for the file or directory and/or + its new parent directory. All directories specified in this path + must exist. + Any path components which are not specified here will be taken + from the session path. + +@return KErrNone if successful, otherwise one of the other + system-wide error codes. + +@capability Dependent If either anOldName or aNewName is /Sys then Tcb capability is required. +@capability Dependent If either anOldName or aNewName begins with /Private and does not match + this process' SID then AllFiles capability is required. +@capability Dependent If either anOldName or aNewName is /Resource then Tcb capability is required. + +@see CFileMan +*/ + { + TRACEMULT3(UTF::EBorder, UTraceModuleEfsrv::EFsRename, MODULEUID, Handle(), anOldName, aNewName); + + TInt r; + if (anOldName.Length() <= 0 || aNewName.Length() <= 0 ) + r = KErrBadName; + else + r = SendReceive(EFsRename,TIpcArgs(&anOldName,&aNewName)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsRenameReturn, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::Replace(const TDesC& anOldName,const TDesC& aNewName) +/** +Replaces a single file with another. + +This function does not support the use of wildcards. Unlike Rename(), it only +applies to files. + +This function operates as follows: + +1. if the aNewName file does not exist, it is created. + +2. anOldName's contents, attributes and the date and time of its last + modification are copied to file aNewName, overwriting any existing contents + and attribute details. + +3. anOldName is deleted. + +anOldName may be hidden, read-only or a system file. However, +neither anOldName, nor, if it exists, aNewName, can be open; +aNewName must not be read-only. +Both files must be on the same drive. + +@param anOldName The file to be replaced. Must exist and must be closed. It is + deleted by this function. +@param aNewName The file to replace anOldName. Does not need to exist, but if + it does exist, it must be closed. If it exists, its name + remains unchanged but its contents, attributes and the date + and time of its last modification are replaced by those + of anOldName. + If it does not exist, it will be created and is assigned + the contents and attributes of anOldName. Must not be followed + by a trailing backslash. + +@return KErrNone, if successful; + KErrAccessDenied, if an attempt is made to replace a directory; + otherwise one of the other system-wide error codes. + +@capability Dependent If either anOldName or aNewName is /Sys then Tcb capability is required. +@capability Dependent If either anOldName or aNewName begins with /Private and does not match + this process' SID then AllFiles capability is required. +@capability Dependent If either anOldName or aNewName is /Resource then Tcb capability is required. + +*/ + { + TRACEMULT3(UTF::EBorder, UTraceModuleEfsrv::EFsReplace, MODULEUID, Handle(), anOldName, aNewName); + TInt r = SendReceive(EFsReplace,TIpcArgs(&anOldName,&aNewName)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsReplaceReturn, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::Att(const TDesC& aName,TUint& aVal) const +/** +Gets a file's attributes. + +@param aName The filename. Any path components which are not specified here + will be taken from the session path. +@param aVal On return, the individual bits within the byte indicate which + attributes have been set. For more information see KEntryAttNormal + and the other file/directory attributes. + +@return KErrNone if successful, otherwise one of the other + system-wide error codes. + +@capability Dependent If aName contains /sys/ then AllFiles capability is required. +@capability Dependent If aName contains /Private/ and does not match + this process' SID then AllFiles capability is required. + +@see KEntryAttNormal +*/ + { + TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsAtt, MODULEUID, Handle(), aName); + + TEntry e; + TInt r=Entry(aName,e); + if (r==KErrNone) + aVal=e.iAtt; + + TRACERET2(UTF::EBorder, UTraceModuleEfsrv::EFsAttReturn, MODULEUID, r, aVal); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::SetAtt(const TDesC& aName,TUint aSetAttMask,TUint aClearAttMask) +/** +Sets or clears the attributes of a single file or directory. + +The function uses two bitmasks. The first bitmask specifies the attributes +to be set; the second specifies the attributes to be cleared. + +An attempt to set or clear the KEntryAttDir, KEntryAttVolume or KEntryAttRemote +attributes have no effect. + +@param aName File or directory name. Any path components which are not + specified here will be taken from the session path. Must + not include wildcard characters. The file must be closed. +@param aSetAttMask Bitmask indicating the attributes to be set. +@param aClearAttMask Bitmask indicating the attributes to be cleared. For more + information, see KEntryAttNormal and the other file or + directory attributes. + +@return KErrNone if successful, otherwise one of the other + system-wide error codes. + +@panic FSCLIENT 21 if any attribute appears in both bitmasks. + + +@capability Dependent If aName is /Sys then Tcb capability is required. +@capability Dependent If aName begins with /Private and does not match + this process' SID then AllFiles capability is required. +@capability Dependent If aName is /Resource then Tcb capability is required. + +@see RFs::SetEntry + +*/ + { + TRACEMULT4(UTF::EBorder, UTraceModuleEfsrv::EFsSetAtt, MODULEUID, + Handle(), aName, aSetAttMask, aClearAttMask); + + TInt r = SetEntry(aName,TTime(0),aSetAttMask,aClearAttMask); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsSetAttReturn, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::Modified(const TDesC& aName,TTime& aTime) const +/** +Gets the last modification date and time of a file or a directory, +in UTC. + +If there has been no modification, the function gets the date and +time of the file or directory's creation. + +@param aName File or directory name. +@param aTime On return, contains the date and time of the file or + directory's last modification in universal time. + +@return KErrNone if successful, otherwise one of the other + system-wide error codes. + +@capability Dependent If aName contains /sys/ then AllFiles capability is required. +@capability Dependent If aName contains /Private/ and does not match + this process' SID then AllFiles capability is required. + +*/ + { + TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsModified, MODULEUID, Handle(), aName); + + TEntry e; + TInt r=Entry(aName,e); + if (r==KErrNone) + aTime=e.iModified; + + TRACERET3(UTF::EBorder, UTraceModuleEfsrv::EFsModifiedReturn, MODULEUID, r, I64LOW(aTime.Int64()), I64HIGH(aTime.Int64())); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::SetModified(const TDesC& aName,const TTime& aTime) +/** +Sets the date and time that the contents of a file or directory +were modified, in UTC. + +@param aName File or directory name. +@param aTime The new date and time that the file or directory was modified + in universal time. + +@return KErrNone if successful; + KErrInUse, if the file is open; + otherwise one of the other system-wide error codes. + +@capability Dependent If aName is /Sys then Tcb capability is required. +@capability Dependent If aName begins with /Private and does not match + this process' SID then AllFiles capability is required. +@capability Dependent If aName is /Resource then Tcb capability is required. + +*/ + { + TRACEMULT4(UTF::EBorder, UTraceModuleEfsrv::EFsSetModified, MODULEUID, Handle(), aName, I64LOW(aTime.Int64()), I64HIGH(aTime.Int64()) ); + + TInt r = SetEntry(aName,aTime,KEntryAttModified,0); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsSetModifiedReturn, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::Entry(const TDesC& aName,TEntry& anEntry) const +/** +Gets the entry details for a file or directory. + +This information includes UID information. + +@param aName Name of file or directory. +@param anEntry On return, contains the entry details for the file or directory. TEntry::iModified contains UTC date and time. + +@return KErrNone if successful, otherwise one of the other + system-wide error codes. + +@capability Dependent If aName contains "\\Sys\\" and includes an additional file or directory then AllFiles capability + is required. For example, the paths "c:\\sys" and "c:\\sys\\" will always be readable, whereas + the path "c:\\sys\\abc\\" will only be readable with AllFiles capability. + +@capability Dependent If aName contains \\Private\\ and includes an additional file, or a directory which does not match + this process' SID, then AllFiles capability is required. For example, the paths "c:\\private" and + "c:\\private\\" will always be readable, whereas the path "c:\\private\\\\" will only be + readable with AllFiles capability or if matches the process' SID. +*/ + { + TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsEntry, MODULEUID, Handle(), aName); + TPckg e(anEntry); + TInt r = SendReceive(EFsEntry,TIpcArgs(&aName,&e)); + + TRACE5(UTF::EBorder, UTraceModuleEfsrv::EFsEntryReturn, MODULEUID, + r, anEntry.iAtt, + I64LOW(anEntry.iModified.Int64()), I64HIGH(anEntry.iModified.Int64()), + anEntry.iSize); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::SetEntry(const TDesC& aName,const TTime& aTime,TUint aSetAttMask,TUint aClearAttMask) +/** +Sets both the attributes and the last modified date and time for a file or directory. + +The function uses two bitmasks. The first bitmask determines +which attributes should be set. The second bitmask determines which should be cleared. + +An attempt to set or clear the KEntryAttDir, KEntryAttVolume or KEntryAttRemote +attributes have no effect. + +@param aName File or directory name. +@param aTime New date and time. UTC date and time should be used. +@param aSetAttMask Bitmask indicating which attributes are to be set. +@param aClearAttMask Bitmask indicating which attributes are cleared. For more + information, see KEntryAttNormal, and the other file + or directory attributes. + +@return KErrNone, if successful; + KErrInUse, if the file is open; + otherwise one of the other system-wide error codes. + +@panic FSCLIENT 21 if any attribute appears in both bitmasks. + +@capability Dependent If aName is /Sys then Tcb capability is required. +@capability Dependent If aName begins with /Private and does not match + this process' SID then AllFiles capability is required. +@capability Dependent If aName is /Resource then Tcb capability is required. + +@see KEntryAttNormal +@see KEntryAttDir +@see KEntryAttVolume +*/ + { + TRACEMULT6(UTF::EBorder, UTraceModuleEfsrv::EFsSetEntry, MODULEUID, + Handle(), aName, + I64LOW(aTime.Int64()), I64HIGH(aTime.Int64()), + aSetAttMask, aClearAttMask); + + __ASSERT_ALWAYS((aSetAttMask&aClearAttMask)==0,Panic(EAttributesIllegal)); + TPtrC8 timeBuf((TUint8*)&aTime,sizeof(TTime)); + TInt r = SendReceive(EFsSetEntry,TIpcArgs(&aName,&timeBuf,aSetAttMask,aClearAttMask)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsSetEntryReturn, MODULEUID, r); + return r; + } + +/** +Reads data from a file without opening it. + +The contents of the file can be accessed regardless of the file's lock state. + +The file may be open by any number of other clients for reading or writing. +In allowing such access to a file, the fileserver makes no guarantees as to +the validity of the data it returns. + +@param aName Name of the file to be accessed. +@param aPos The offset, in bytes, from the start of the file where + reading is to start. +@param aDes On return, contains the data read from the file. The length of + the descriptor is set to the number of bytes read. If the + specified offset lies beyond the end of the file, no data is + read and the length of this descriptor is set to zero. +@param aLength The number of bytes to be read from the file. + +@return KErrNone if successful, + KErrArgument if aLength is negative, + otherwise one of the other system-wide error codes. + +@panic FSCLIENT 19 if aPos negative. +@panic FSCLIENT 27 if aLength is greater than the maximum length of + the target descriptor. + +@capability Dependent If the path for aName starts with /Sys capability AllFiles is required +@capability Dependent If the path for aName starts with /Private and this process does not have + the relevant SID capability AllFiles is required + +*/ +EFSRV_EXPORT_C TInt RFs::ReadFileSection(const TDesC& aName,TInt64 aPos,TDes8& aDes,TInt aLength) const + { + TRACEMULT5(UTF::EBorder, UTraceModuleEfsrv::EFsReadFileSection, MODULEUID, + Handle(), aName, I64LOW(aPos), I64HIGH(aPos), aLength); + + __ASSERT_ALWAYS(aPos>=0,Panic(EPosNegative)); + +#ifndef SYMBIAN_ENABLE_64_BIT_FILE_SERVER_API + if(aPos > KMaxTInt) + { + TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsReadFileSectionReturn, MODULEUID, KErrTooBig); + return KErrTooBig; + } + if((aPos + aLength) > KMaxTInt) + aLength = KMaxTInt - (TInt)aPos; +#endif + if (aLength) // Number of characters to read + { + __ASSERT_ALWAYS(aDes.MaxLength()>=aLength,Panic(EBadLength)); + } + else + { + aDes.Zero(); + TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsReadFileSectionReturn, MODULEUID, KErrNone); + return(KErrNone); + } + + __ASSERT_ALWAYS(aDes.MaxLength()>=aLength,Panic(EBadLength)); + + TInt r; + if(!(I64HIGH(aPos))) + { + r = SendReceive(EFsReadFileSection,TIpcArgs(&aDes,&aName,I64LOW(aPos),aLength)); + } + else + { + TPckgC pkPos(aPos); + r = SendReceive(EFsReadFileSection|KIpcArgSlot2Desc,TIpcArgs(&aDes,&aName,&pkPos,aLength)); + } + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsReadFileSectionReturn, MODULEUID, r); + return r; + } +/** +Maintained for BC + +@internalTechnology +*/ +EFSRV_EXPORT_C TInt RFs::ReadFileSection_RESERVED(const TDesC& aName,TInt aPos,TDes8& aDes,TInt aLength) const + { + TRACEMULT5(UTF::EBorder, UTraceModuleEfsrv::EFsReadFileSection, MODULEUID, + Handle(), aName, aPos, 0, aLength); + + __ASSERT_ALWAYS(aPos>=0,Panic(EPosNegative)); + + if (aLength) // Number of characters to read + { + __ASSERT_ALWAYS(aDes.MaxLength()>=aLength,Panic(EBadLength)); + } + else + { + aDes.Zero(); + TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsReadFileSectionReturn, MODULEUID, KErrNone); + return(KErrNone); + } + + __ASSERT_ALWAYS(aDes.MaxLength()>=aLength,Panic(EBadLength)); + + TInt r = SendReceive(EFsReadFileSection,TIpcArgs(&aDes,&aName,aPos,aLength)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsReadFileSectionReturn, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C void RFs::ResourceCountMarkStart() const +/** +Marks the start of resource count checking. + +Typically, this function is called immediately after a client is connected +to the file server, and before any resources are opened. +*/ + { + TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsResourceCountMarkStart, MODULEUID, Handle()); + + RSessionBase::SendReceive(EFsResourceCountMarkStart); + + TRACE0(UTF::EBorder, UTraceModuleEfsrv::EFsResourceCountMarkStartReturn, MODULEUID); + } + + + + +EFSRV_EXPORT_C void RFs::ResourceCountMarkEnd() const +/** +Ends resource count checking. Typically, this function is called immediately +before closing a session with the file server. + +@panic CSessionFs 2 if the number of resources opened since the start of resource + count checking is not equal to the number of resources closed. +*/ + { + TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsResourceCountMarkEnd, MODULEUID, Handle()); + + RSessionBase::SendReceive(EFsResourceCountMarkEnd); + + TRACE0(UTF::EBorder, UTraceModuleEfsrv::EFsResourceCountMarkEndReturn, MODULEUID); + } + + + + +EFSRV_EXPORT_C TInt RFs::ResourceCount() const +/** +Gets the number of currently open resources. + +The resource count is incremented by one: when a file or directory +is opened, when a device is opened in preparation for formatting, when a direct access channel +to a disk is opened. + +@return The number of resources currently open. +*/ + { + TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsResourceCount, MODULEUID, Handle()); + + TInt count; + TPckg pckg(count); + SendReceive(EFsResourceCount,TIpcArgs(&pckg)); + TInt r = *(TInt*)pckg.Ptr(); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsResourceCountReturn, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::CheckDisk(const TDesC& aDrive) const +/** +Checks the integrity of the disk on the specified drive. +On FAT, this checks if a cluster number is invalid, if a cluster is allocated to +more than one file entry, if an unallocated cluster is not set free, and if size +of an entry is invalid. + +@param aDrive Path indicating the drive which contains the disk to be checked. If the drive + information is not specified the current session drive is taken by default. + Checkdisk is performed on the requested drive irrespective of the correctness or + existance of the given path. + +@return KErrNone, if successful; + 1, if successful but a file cluster contains a bad value; + 2, if successful but two files are linked to the same cluster; + 3, if successful but an unallocated cluster contains a value; + 4, if successful but the size of a file is not equal to the number of clusters in chain; + KErrNotReady, if the specified drive is empty; + KErrNotSupported, if the drive cannot handle this request; + KErrPermissionDenied, if the caller doesn't have DiskAdmin capability; + KErrTooBig, if the drives folder depth exceeds maximum allowed. For the current FAT file system implementation this limit is 50. + Other system wide error codes may also be returned. + +@capability DiskAdmin +*/ + { + TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsCheckDisk, MODULEUID, Handle(), aDrive); + TInt r = SendReceive(EFsCheckDisk,TIpcArgs(&aDrive)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsCheckDiskReturn, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::ScanDrive(const TDesC& aDrive) const +/** +Checks the specified drive for errors and corrects them. Specifically, it +checks if long file name entries' IDs are in sequence and short name is valid, +and file's allocated clusters are not used by other files. + +This does not run on the internal RAM drive, and only applies to a +FAT file system. + +@param aDrive Path indicating the drive which contains the disk to be checked. If the drive + information is not specified the current session drive is taken by default. + ScanDrive is performed on the requested drive irrespective of the correctness or + existance of the given path. + +@return KErrNone if successful, + KErrPermissionDenied if caller doesn't have capability DiskAdmin, + KErrInUse if drive is in use, + otherwise one of the other system-wide error codes + +@capability DiskAdmin +*/ + { + TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsScanDrive, MODULEUID, Handle(), aDrive); + TInt r = SendReceive(EFsScanDrive,TIpcArgs(&aDrive)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsScanDriveReturn, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::GetShortName(const TDesC& aLongName,TDes& aShortName) const +/** +Gets the short filename associated with a VFAT long filename. + +The short filename has a limit of eight characters for the file name and three +characters for the extension. + +@param aLongName The long filename. Any path components which are not + specified here will be taken from the session path. + If the path specifies a directory, it may or may not be + followed by a trailing backslash. +@param aShortName On return, contains the short filename associated with the file + or directory specified in aLongName. + +@return KErrNone if successful, otherwise one of the other + system-wide error codes. + +@capability Dependent If the path for aLongName starts with /Sys capability AllFiles is required +@capability Dependent If the path for aLongName starts with /Private and this process does not + have the relevant SID capability AllFiles is required +*/ + { + TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsGetShortName, MODULEUID, Handle(), aLongName); + TInt r = SendReceive(EFsGetShortName,TIpcArgs(&aLongName,&aShortName)); + + TRACERETMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsGetShortNameReturn, MODULEUID, r, aShortName); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::GetLongName(const TDesC& aShortName,TDes& aLongName) const +/** +Gets the long filename associated with a short (8.3) filename. + +A long filename has a limit of 256 characters for each component, as well as a +limit of 256 characters for the entire path. + +@param aShortName The short file name. Any path components which are not + specified here will be taken from the session path. If + the path specifies a directory, it may or may not be followed + by a trailing backslash. +@param aLongName On return, contains the long version of the name. + +@return KErrNone if successful, otherwise one of the other + system-wide error codes. + +@capability Dependent If the path for aShortName starts with /Sys capability AllFiles is required +@capability Dependent If the path for aShortName starts with /Private and this process does not + have the relevant SID capability AllFiles is required + +*/ + { + TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsGetLongName, MODULEUID, Handle(), aShortName); + TInt r = SendReceive(EFsGetLongName,TIpcArgs(&aShortName,&aLongName)); + + TRACERETMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsGetLongNameReturn, MODULEUID, r, aLongName); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::IsFileOpen(const TDesC& aFileName,TBool& anAnswer) const +/** +Tests whether a file is open. + +This function is useful because several file based operations provided by +the RFs class, for example: Delete(), Replace() and Rename(), require that +the file be closed. + +@param aFileName The name of the file to test. Any path components which are + not specified here will be taken from the session path. If a + directory is specified instead of a file then KErrNone will be + returned and anAnswer will be set to EFalse. +@param anAnswer On return, true if the file is open, false if closed. + +@return KErrNone if successful, otherwise one of the other + system-wide error codes. + +@capability Dependent If the path for aFileName starts with /Sys capability AllFiles is required +@capability Dependent If the path for aFileName starts with /Private and this process does not + have the relevant SID capability AllFiles is required + +@see RFs::Delete +@see RFs::Rename +@see RFs::Replace +*/ + { + TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsIsFileOpen, MODULEUID, Handle(), aFileName); + TPckg b(anAnswer); + TInt r = SendReceive(EFsIsFileOpen,TIpcArgs(&aFileName,&b)); + + TRACERET2(UTF::EBorder, UTraceModuleEfsrv::EFsIsFileOpenReturn, MODULEUID, r, anAnswer); + return r; + } + + + + +TInt RFs::GetOpenFileList(TInt& aSessionNumber,TInt& aLocalPos,TThreadId& aThreadId,TEntryArray& anArray) const +// +// Private function to get a list of open files +// + { + TOpenFileListPos s(aSessionNumber,aLocalPos); + TPckg pS(s); + TPckg threadId(aThreadId); + anArray.iCount=KCountNeeded; + TInt r=SendReceive(EFsListOpenFiles,TIpcArgs(&pS,&threadId,&anArray.iBuf)); + aSessionNumber=s.iSession; + aLocalPos=s.iEntryListPos; + return r; + } + + + + +EFSRV_EXPORT_C TBool RFs::GetNotifyUser() +/** +Tests whether user notification of file read or write failure is in effect. + +@return True if notification in effect, false if not. +*/ + { + TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsGetNotifyUser, MODULEUID, Handle()); + + TInt notifyUser; + TPckg pckgNotify(notifyUser); + SendReceive(EFsGetNotifyUser,TIpcArgs(&pckgNotify)); + TBool r = notifyUser; + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsGetNotifyUserReturn, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C void RFs::SetNotifyUser(TBool aValue) +/** +Sets whether the user should be notified of file read or write failure. +Note that if some drive is mounted as synchronous (see RFs::MountFileSystem), the user won't be +notified about read/write failures on it. + +@param aValue ETrue, if user is to be notified of read or write failures; + EFalse, for no notification. +*/ + { + TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFsSetNotifyUser, MODULEUID, Handle(), aValue); + SendReceive(EFsSetNotifyUser,TIpcArgs(aValue)); + + TRACE0(UTF::EBorder, UTraceModuleEfsrv::EFsSetNotifyUserReturn, MODULEUID); + } + + + + +EFSRV_EXPORT_C TUint8* RFs::IsFileInRom(const TDesC& aFileName) const +/** +Gets a pointer to the specified file, if it is in ROM. + +Note that this is not a test of whether the file is on the Z: drive, as +the Z: drive may consist of a ROM and another file system, using the composite +file system. For example, the file system may be ROFS, and the underlying media +NAND flash. + +@param aFileName The filename whose address is sought. Cannot include wildcards. + Any path components which are not specified here will be taken + from the session path. + +@return Address of the start of the file, if it is in ROM. This is NULL, if + the file is not in ROM. Note that for the composite file system, the file + might be on the Z: drive but in a non-ROM file system (i.e. ROFS), in + which case the function still returns NULL. + +@capability Dependent If the path for aFileName starts with /Sys capability AllFiles is required +@capability Dependent If the path for aFileName starts with /Private and this process does not + have the relevant SID capability AllFiles is required + +*/ + { + TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsIsFileInRom, MODULEUID, Handle(), aFileName); + + TPckgBuf start; + + TUint8* r; + if (SendReceive(EFsIsFileInRom,TIpcArgs(&aFileName,&start))!=KErrNone) + r = NULL; + else + r = start(); + + TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsIsFileInRomReturn, MODULEUID, r); + return r; + } + + + + +/** +Tests whether a filename and path are syntactically correct. + +The following restrictions apply to the path and to its components: + +1. Wildcards are not allowed in any path component, including the filename and extension. +2. Double backslashes are not allowed anywhere in the path +3. The following 6 characters cannot appear in the path: < > : " / | +4. Either or both of a filename or extension must be present. This means that a valid aFileName can not + end with backslash (like "c:\\SomeName\\"), because it will mean that "SomeName" is a directory. + +5. The entire component following the final backslash (the filename and extension) cannot consist solely of space characters, + or of a single or double dot. + +6. Spaces between the drive, if specified, and the first directory in the path are illegal, although there may be + spaces between other path components, for example, between directories. + +7. If the path in aFileName is not fully specified, i.e. doesn't look like "c:\\Dir1\\File1.bin", all missing + parts of the full path will be taken from the session path, @see RFs::SetSessionPath, @see RFs::SessionPath. + In this case the session path must be set, otherwise this method will return EFalse. + For example: for the case "\\file1.txt" only the drive letter will be taken from the session path; + for the case "file1.txt" whole session path will be internally prepended to the "file1.txt" and whole path checked. + Note that in this case total length of the name in the aFileName parameter and the session path shall not exceed KMaxFileName characters. + + +@param aFileName The path to be checked for validity. + May specify a filename alone, or an entire path specification, including drive letter. + If a path is specified, all components are checked for validity. + +@return ETrue, if the name is valid (conforms to the mentioned above criteria); EFalse otherwise. +*/ +EFSRV_EXPORT_C TBool RFs::IsValidName(const TDesC& aFileName) const + { + TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsIsValidName1, MODULEUID, Handle(), aFileName); + TBool returnInvalidChar=EFalse; + TPckg bPckg(returnInvalidChar); + TBool b; + if (SendReceive(EFsIsValidName,TIpcArgs(&aFileName,&bPckg,NULL,NULL))!=KErrNone) + b = EFalse; + else + b = ETrue; + TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsIsValidName1Return, MODULEUID, b); + return b; + } + + + + +/** +The following restrictions apply to the path and to its components: + +1. Wildcards are not allowed in any path component, including the filename and extension. +2. Double backslashes are not allowed anywhere in the path +3. The following 6 characters cannot appear in the path: < > : " / | +4. Either or both of a filename or extension must be present. This means that a valid aFileName can not + end with backslash (like "c:\\SomeName\\"), because it will mean that "SomeName" is a directory. + +5. The entire component following the final backslash (the filename and extension) cannot consist solely of space characters, + or of a single or double dot. + +6. Spaces between the drive, if specified, and the first directory in the path are illegal, although there may be + spaces between other path components, for example, between directories. + +7. If the path in aFileName is not fully specified, i.e. doesn't look like "c:\\Dir1\\File1.bin", all missing + parts of the full path will be taken from the session path, @see RFs::SetSessionPath, @see RFs::SessionPath. + In this case the session path must be set, otherwise this method will return EFalse. + For example: for the case "\\file1.txt" only the drive letter will be taken from the session path; + for the case "file1.txt" whole session path will be internally prepended to the "file1.txt" and whole path checked. + Note that in this case total length of the name in the aFileName parameter and the session path shall not exceed KMaxFileName characters. + +@param aFileName The path to be checked for validity. + May specify a filename alone, or an entire path specification, including drive letter. + If a path is specified, all components are checked for validity. + +@param aBadChar reference to the variable that on return can contain illegal character from aFileName. + 1. if the filename and optional path in aFileName are valid, this method will return ETrue and aBadChar will be set to 0x00. + 2. if there is an illegal character in aFileName, this method will return EFalse and aBadChar will contain this illegal character. + 3. if there is no illegal characters in aFileName, but this is still not a valid filename (like "\\SomeName\\") + this method will return EFalse and aBadChar will contain space ' ' or code 0x20. + +@return ETrue, if the name is valid (conforms to the mentioned above criteria); EFalse otherwise. +*/ +EFSRV_EXPORT_C TBool RFs::IsValidName(const TDesC& aFileName,TText& aBadChar) const + { + TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsIsValidName2, MODULEUID, Handle(), aFileName); + TBool returnInvalidChar=ETrue; + TPckg boolPckg(returnInvalidChar); + TPckg textPckg(aBadChar); + TBool b; + if (SendReceive(EFsIsValidName,TIpcArgs(&aFileName,&boolPckg,&textPckg,NULL))!=KErrNone) + b = EFalse; + else + b = ETrue; + TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFsIsValidName2Return, MODULEUID, b, aBadChar); + return b; + } +/** +This API can be used to validate both directory and file names. +If the name ends with a trailing backslash '\\' then it is considered to be a directory +else a filename. +For example: "C:\\test\\" would mean a directory, whereas + "C:\\test" would mean a file, both of which would be returned as a Valid Name. +However a name such as "C:\\test\\\\" would be returned as an Invalid name with error code TError::ErrBadName + +The following restrictions apply to the path and to its components: + +1. Wildcards are not allowed in any path component, including the name and extension. +2. Double backslashes are not allowed anywhere in the path +3. The following 6 characters cannot appear in the path: < > : " / | +4. The entire component following the final backslash (the filename and extension) cannot consist solely of space characters, + or of a single or double dot. +5. Spaces between the drive, if specified, and the first directory in the path are illegal, although there may be + spaces between other path components, for example, between directories. +6. If TNameValidParam::iUseSesssionPath is set to ETrue, and if the path in aName is not fully specified, + i.e. doesn't look like "c:\\Dir1\\File1.bin", all missing parts of the full path will be taken from the session path, + @see RFs::SetSessionPath, @see RFs::SessionPath. + In this case the session path must be set, otherwise this method will return EFalse. + For example: for the case "\\file1.txt" only the drive letter will be taken from the session path; + for the case "file1.txt" whole session path will be internally prepended to the "file1.txt" and whole path checked. + Note that in this case total length of the name in the aName parameter and the session path shall not exceed KMaxFileName characters. +7. If TNameValidParam::iUseSesssionPath is set to EFalse, which is the default value, then + the session path is not used to fill in the missing parts of the name as stated above. + For example: for the case "file1.txt", session path will not be used to check the validity of the name. +@param aName The path to be checked for validity. + May specify a name alone, or an entire path specification, including drive letter. + If a path is specified, all components are checked for validity. + +@param aParam reference to the variable that on return can contain details of the error if any. + While constructing an object of this type one could specify whether one wants to use the sessionPath for filling up missing parts of aName, + or one would want to test aName as it is without prepending the sessionPath. + By default the sessionPath is NOT used. + 1. if the name and optional path in aName are valid, this method will return ETrue and TError::iError will contain ErrNone. + 2. if there is an illegal character in aName, this method will return EFalse and TError::iError will contain KErrBadCharacter. + Also TError::iInvalidCharPos will indicate the position of the rightmost invalid character. + 3. if there is no illegal characters in aName, but this is still not a valid name (like "") + this method will return EFalse and TError::iError will contain KErrBadCharacter, while iInvalidCharPos will be set to 0 + 4. if length of the name exceeds 256 characters, this method will return EFalse and TError::iError will contain KErrTooLong. + if the optional sessionPath is used, then the length of the sessionPath is also used to determine whether the length exceeds 256 characters. +@return ETrue, if the name is valid (conforms to the mentioned above criteria); EFalse otherwise. +*/ +EFSRV_EXPORT_C TBool RFs::IsValidName(const TDesC& aName, TNameValidParam& aParam ) + { + TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsIsValidName3, MODULEUID, Handle(), aName); + TPckg paramPckg(aParam); + TBool b; + if (SendReceive(EFsIsValidName,TIpcArgs(&aName,NULL,NULL,¶mPckg))!=KErrNone) + b = EFalse; + else + b = ETrue; + TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFsIsValidName3Return, MODULEUID, b, aParam.ErrorCode()); + return b; + } + + + + +EFSRV_EXPORT_C TInt RFs::GetDriveName(TInt aDrive,TDes& aDriveName) const +/** +Gets the name of a drive. + +Drive naming is optional. If the drive specified has not been assigned a name, +this function returns a descriptor whose length is zero. + +@param aDrive The drive number. Specify a drive in the range + EDriveA to EDriveZ for drives A to Z, respectively. + The default drive is the session default drive represented + by KDefaultDrive. +@param aDriveName On return, the drive name. + +@return KErrNone if successful, otherwise one of the other + system-wide error codes. + +@see TDriveNumber +*/ + { + TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFsGetDriveName, MODULEUID, Handle(), aDrive); + TInt r = SendReceive(EFsGetDriveName,TIpcArgs(aDrive,&aDriveName)); + + TRACERETMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsGetDriveNameReturn, MODULEUID, r, aDriveName); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::SetDriveName(TInt aDrive,const TDesC& aDriveName) +/** +Sets the name of a drive. + +Drive naming is optional. Any drive can be assigned a name, and more than +one drive can share the same name. + +@param aDrive The drive number. Specify a drive in the range + EDriveA to EDriveZ for drives A to Z, respectively. + Specify KDefaultDrive for the session default drive. +@param aDriveName The name of the drive, with a maximum of 256 characters. + The name cannot contain the 6 characters < > : " / | + +@return KErrNone if successful; + KErrBadName, if the name contains illegal characters; + otherwise one of the other system-wide error codes. + +@capability DiskAdmin + +*/ + { + TRACEMULT3(UTF::EBorder, UTraceModuleEfsrv::EFsSetDriveName, MODULEUID, Handle(), aDrive, aDriveName); + TInt r = SendReceive(EFsSetDriveName,TIpcArgs(aDrive,&aDriveName)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsSetDriveNameReturn, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::LockDrive(TInt aDrv, const TMediaPassword &aOld, const TMediaPassword &aNew, TBool aStore) +/** +Sets the password for the media in the specified drive. + +The media is not necessarily locked afterwards. Accessibility is determined +by the following rules: + + - The media may not become locked until power is removed (such as with MMC cards) + - If the password is added to the password store (the aStore parameter is ETrue), the + media will be automatically unlocked on the next access. + +@param aDrv The drive. +@param aOld The existing password. If no password is set, this must be a zero-length descriptor. +@param aNew The new password. +@param aStore ETrue if the new password is to be saved to the controller password store; + EFalse if not. + +@return KErrNone if successful; + KErrNotSupported if the media does not support password locking. + +@capability DiskAdmin + +*/ + { + TRACE3(UTF::EBorder, UTraceModuleEfsrv::EFsLockDrive, MODULEUID, Handle(), aDrv, aStore); + TInt r = SendReceive(EFsLockDrive,TIpcArgs(aDrv,&aOld,&aNew,aStore)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsLockDriveReturn, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::UnlockDrive(TInt aDrive, const TMediaPassword &aPassword, TBool aStore) +/** +Unlocks the media in the specified drive. + +The password must be added to the MultiMedia card controller's password store +so that the controller can subsequently issue the password without the user +having to be prompted for it again. + +@param aDrive The drive. +@param aPassword The password. +@param aStore Specify ETrue to add the password to the + controller's password store. + +@return KErrNone, if successful; + KErrAccessDenied, if the password is incorrect; + KErrAlreadyExists, if the card has already been unlocked; + KErrNotSupported, if the media does not support password locking. + +@capability DiskAdmin + +*/ + { + TRACE3(UTF::EBorder, UTraceModuleEfsrv::EFsUnlockDrive, MODULEUID, Handle(), aDrive, aStore); + TInt r = SendReceive(EFsUnlockDrive,TIpcArgs(aDrive,&aPassword,aStore)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsUnlockDriveReturn, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::ClearPassword(TInt aDrv, const TMediaPassword &aPswd) +/** +Clears the password from the locked MultiMedia card in the specified drive. + +Clearing the password causes the MultiMedia card controller to set +the password to null. + +@param aDrv The drive. +@param aPswd The current password, which is required to perform this + operation. + +@return KErrNone, if successful; + KErrAccessDenied, if the password is wrong or the card is still locked; + otherwise one of the other system-wide error codes. + +@capability DiskAdmin + +*/ + { + TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFsClearPassword, MODULEUID, Handle(), aDrv); + TInt r = SendReceive(EFsClearPassword,TIpcArgs(aDrv,&aPswd)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsClearPasswordReturn, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C TInt RFs::ErasePassword(TInt aDrv) +/** +Erase the password from the locked MultiMedia card in the specified drive. + +Used when the password is unknown, and may result in the media being erased. + +Successful execution of this call may result in leaving the media in unformatted state. +Hence, it is recommended to format the Multimedia card after calling RFs::ErasePassword(). + +@param aDrv The drive. + +@return KErrNone, if successful; + otherwise one of the other system-wide error codes. + +@capability DiskAdmin + +*/ + { + TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFsErasePassword, MODULEUID, Handle(), aDrv); + TInt r = SendReceive(EFsErasePassword,TIpcArgs(aDrv)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsErasePasswordReturn, MODULEUID, r); + return r; + } + + + + +EFSRV_EXPORT_C void RFs::StartupInitComplete(TRequestStatus& aStat) +/** +Noifies the file server that startup initialisation is complete. + +@param aStat Request status object. +*/ +// +// Notify file server that startup initialisation has been completed +// + { + TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFsStartupInitComplete, MODULEUID, Handle(), &aStat); + aStat=KRequestPending; + RSessionBase::SendReceive(EFsStartupInitComplete,aStat); + + TRACE0(UTF::EBorder, UTraceModuleEfsrv::EFsStartupInitCompleteReturn, MODULEUID); + } + + + + +EFSRV_EXPORT_C TInt RFs::SetLocalDriveMapping(const TDesC8& aMapping) +// +// Set the local drive mapping +// + { + TRACEMULT2(UTF::EBorder, UTraceModuleEfsrv::EFsSetLocalDriveMapping, MODULEUID, Handle(), aMapping); + + TInt r = SendReceive(EFsSetLocalDriveMapping,TIpcArgs(&aMapping)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsSetLocalDriveMappingReturn, MODULEUID, r); + return r; + } + + +/** + Finalise the given drive. This operation is intended to put the drive into the consistent state when it is + safe to remove it physically or switch the power off. + + @param aDriveNo drive number + @param aMode describes the finalisation operation, see RFs::TFinaliseDrvMode enum + + @return KErrNone on success, + KErrArgument if the function arguments are invalid + KErrInUse if the drive has opened objects (files, directories etc.) and therefore can not be finalised + KErrCorrupt if the drive is corrupt. + System wide error codes otherwise. + + @capability DiskAdmin +*/ +EFSRV_EXPORT_C TInt RFs::FinaliseDrive(TInt aDriveNo, TFinaliseDrvMode aMode) const + { + TRACE3(UTF::EBorder, UTraceModuleEfsrv::EFsFinaliseDrive, MODULEUID, Handle(), aDriveNo, aMode); + TInt r = SendReceive(EFsFinaliseDrive,TIpcArgs(aDriveNo, (TInt)aMode)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsFinaliseDriveReturn, MODULEUID, r); + return r; + } + + +/** + Makes the best effort to finalise all drives in the system. + Effectively calls RFs::FinaliseDrive(..., EFinal_RW) to all present drives in the system. This makes impossible to + analyse the error code if the finalisation of some fails. + It is much better to use RFs::FinaliseDrive(...) specifying concrete drive number and desired finalisation mode. + + @return KErrNone, if successful; otherwise one of the other system-wide error codes. + @capability DiskAdmin +*/ +EFSRV_EXPORT_C TInt RFs::FinaliseDrives() + { + TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsFinaliseDrives, MODULEUID, Handle()); + TInt nRes; + TDriveList driveList; + TDriveInfo driveInfo; + + nRes=DriveList(driveList); + if(nRes != KErrNone) + { + TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsFinaliseDrivesReturn, MODULEUID, nRes); + return nRes; //-- unable to obtain drives list + } + + //-- walk through all drives in the system sending them "Finalise" request + for (TInt i=0; i pkHandle(aHandle); + return SendReceive(EFsUnclamp, TIpcArgs(& pkHandle)); + } + +EFSRV_EXPORT_C TInt RFs::InitialisePropertiesFile(const TPtrC8& aPtr) const +/** +Sets the F32 properties file - Can only be called from the ESTART process + +@param aPtr A descriptor pointing to an INI file in ROM. + +@return KErrNone if successful. + +@capability KDiskAdmin +*/ + { + TRACE3(UTF::EBorder, UTraceModuleEfsrv::EFsInitialisePropertiesFile, MODULEUID, Handle(), aPtr.Ptr(), aPtr.Length()); + TInt r = SendReceive(EFsInitialisePropertiesFile, TIpcArgs(aPtr.Ptr(), aPtr.Length(), ETrue)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsInitialisePropertiesFileReturn, MODULEUID, r); + return r; + } + +EFSRV_EXPORT_C TInt RFs::QueryVolumeInfoExt(TInt aDrive, TQueryVolumeInfoExtCmd aCommand, TDes8& aInfo) const +/** +@internalTechnology +Queries specific information on volumes by commands. Available commands is defined by TQueryVolumeInfoExtCmd. + +@param aDriveNo The drive on which to query information. +@param aCommand A command to specify which information is under query +@param aInfo A TPckgBuf<> to carry returned results. + +@return KErrNone if successful; otherwise another system-wide error code is returned. + +@see TQueryVolumeInfoExtCmd +@see TVolumeIOParamInfo + */ + { + TRACE3(UTF::EBorder, UTraceModuleEfsrv::EFsQueryVolumeInfoExt, MODULEUID, Handle(), aDrive, aCommand); + TInt r = SendReceive(EFsQueryVolumeInfoExt, TIpcArgs(aDrive, aCommand, &aInfo)); + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsQueryVolumeInfoExtReturn, MODULEUID, r); + return r; + } + + +EFSRV_EXPORT_C TInt RFs::VolumeIOParam(TInt aDrive, TVolumeIOParamInfo& aParamInfo) const +/** +This function queries a set of I/O parameters on the specified volume, this includes the block size of underlying media, +cluster size of the mounted file system and the recommended read/write buffer sizes. + +The volume information is retuned through aParamInfo. Even if VolumeIOParam() returns successful, errors +can effect the return value of each field within aParamInfo. + +@param aDrive A drive number, specifies which volume to query. +@param aParamInfo A TVolumeIOParamInfo containing the volume parameters. + +@return KErrNone if successful; otherwise, another system wide error code is returned. +*/ + { + TRACE2(UTF::EBorder, UTraceModuleEfsrv::EFsVolumeIOParam, MODULEUID, Handle(), aDrive); + + TInt r = KErrNone; + + if (!IsValidDrive(aDrive)) + r = KErrArgument; + + if (r == KErrNone) + { + TPckgBuf infoPckg; + r = QueryVolumeInfoExt(aDrive, EIOParamInfo, infoPckg); + if (r == KErrNone) + aParamInfo = infoPckg(); + } + + TRACE5(UTF::EBorder, UTraceModuleEfsrv::EFsVolumeIOParamReturn, MODULEUID, + r, aParamInfo.iBlockSize, aParamInfo.iClusterSize, aParamInfo.iRecReadBufSize, aParamInfo.iRecWriteBufSize); + return r; + } + + +EFSRV_EXPORT_C TInt RFs::FileSystemSubType(TInt aDrive, TDes& aName) const +/** +This function queries the sub type of the file system mounted on the specified volume. For example, 'FAT16' +of the Fat file system. + +TFSName is recommended as the type for aName when using this function. + +NOTE: File systems without a sub type (For example, a ROM file system), the name of the file system is +returned (For example, 'Rom'). + +@param aDrive A drive number, specifies which volume to query. +@param aName A descriptor containing the returned sub type name or file system name. + +@return KErrNone if successful; KErrNotSuppoted if sub type is not supported; + otherwise another system-wide error code is returned. + +@see TFSName +*/ + { + TRACEMULT3(UTF::EBorder, UTraceModuleEfsrv::EFsFileSystemSubType, MODULEUID, Handle(), aDrive, aName); + + TInt r = KErrNone; + + if (!IsValidDrive(aDrive)) + r = KErrArgument; + + if (r == KErrNone) + { + TPckgBuf namePckg; + r = QueryVolumeInfoExt(aDrive, EFileSystemSubType, namePckg); + if (r == KErrNone || r == KErrNotSupported) + aName = namePckg(); + } + + TRACERET1(UTF::EBorder, UTraceModuleEfsrv::EFsFileSystemSubTypeReturn, MODULEUID, r); + return r; + } + +EXPORT_C TInt RFs::AddProxyDrive(const TDesC& aFileName) +/** +Loads the specified extension. + +@param aFileName The file name of the extension + +@return KErrNone, if successful; otherwise one of the other system wide error codes. +*/ + { + RLoader loader; + TInt r = loader.Connect(); + if (r==KErrNone) + { + r = loader.SendReceive(ELoadFSProxyDrive, TIpcArgs(0, &aFileName, 0)); + loader.Close(); + } + return r; + } + + +EXPORT_C TInt RFs::RemoveProxyDrive(const TDesC& aExtensionName) +/** +Removes the specified extension. + +@param aExtensionName The fullname of the extension, as returned from + a call to ExtensionName(). + +@return KErrNone, if successful; + KErrInUse if there are still drives mounted that are using it + KErrNotFound, if aExtensionName is not found; + otherwise one of the other system-wide error codes. +*/ + { + return(SendReceive(EFsRemoveProxyDrive,TIpcArgs(&aExtensionName))); + } + +/** +Initialises a proxy drive. + +@param aProxyDriveNumber drive number that will be used to mount the proxy drive +@param aName name of the proxy drive extension +@param anInfo initialisation information to be passed to the proxy drive extension to initialise the drive + +@return If succesful the internal drive number used to represent the drive (equivalent to a local drive + number for normal drives) This number is obtained dynmically. The number will range between KMaxLocalDrives + and KMaxDrives. + KErrInUse if aProxyDriveNumber is in use or if there are not proxy drive numbers left + KErrArgument if aProxyDriveNumber or aName are invalid + Any other system wide error code. + + +*/ +EXPORT_C TInt RFs::DoMountProxyDrive(const TIpcArgs& ipcArgs) + { + return SendReceive(EFsMountProxyDrive, ipcArgs); + } + + +EXPORT_C TInt RFs::DismountProxyDrive(const TUint aProxyDriveNumber) +/** +Dismounts a proxy drive. + +@param aProxyDriveNumber drive number that will be used to mount the proxy drive +@param aName name of the proxy drive extension +@param anInfo initialisation information to be passed to the proxy drive extension to initialise the drive + +@return If succesful the internal drive number used to represent the drive (equivalent to a local drive + number for normal drives) This number is obtained dynmically. The number will range between KMaxLocalDrives + and KMaxDrives. + KErrInUse if aProxyDriveNumber is in use or if there are not proxy drive numbers left + KErrArgument if aProxyDriveNumber or aName are invalid + Any other system wide error code. + + +*/ + { + return SendReceive(EFsDismountProxyDrive,TIpcArgs(aProxyDriveNumber)); + } + +EFSRV_EXPORT_C void RFs::Close() + { + TRACE1(UTF::EBorder, UTraceModuleEfsrv::EFsClose, MODULEUID, Handle()); + RFTRACE_CLOSE; + + RSessionBase::Close(); + + TRACE0(UTF::EBorder, UTraceModuleEfsrv::EFsCloseReturn, MODULEUID); + } + +