Adds a local drive to the composite filesystem. This can only be used before the composite filesystem is mounted. The local drive is mounted with the filesystem provided. If any local drive added is marked to be asynchronous, then the whole composite drive will be treated asynchronous.

Loads the specified extension.

Adds a file system to the file server.

After calling this function, use MountFileSystem() to mount the file system on a drive.

Loads a specified Plugin.

Loads the specified extension.

Used by a client to indicate that it is safe to dismount the file system. This should be called after receiving a pending media removal notification.

Not calling this does not guarantee that the dismount will not occur as the application requesting the dismount may decide to forcibly dismount after a given timeout period.

RFs::NotifyDismount

Gets a file's attributes.

Maps a drive character to a drive number.

The drive character must be in the range A to Z or a to z. For example, drive A (or a) corresponds to zero, drive B (or b) corresponds to 1 etc. For the drive number enumeration, see TDriveNumber.

TDriveNumber

Checks the integrity of the File System mounted on the specified drive. The behaviour of this API and return codes are File System specific, dependent on how the File System implements its CheckDisk functionality. Note that CheckDisk does not fix any errors that may be found, it just reports the first problem it has found.

CheckDisk checks for a limited amount of possible corruption cases such as invalid cluster numbers in the FAT table, lost and cross-linked cluster chains, various errors within the directory entry etc.

If CheckDisk returns KErrNone, this means that there are no errors that CheckDisk on FAT is aware of.

Error codes returned by the FAT version of CheckDisk include: 1 Bad cluster value in FAT table detected. 2 Cross-linked cluster chain detected. 3 Lost cluster chain detected. 4 File size does not correspond to the number of clusters reported in the FAT table.

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.

Connects a client to the file server.

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

General purpose test interface - file system specific.

This function can only be used in debug builds or if _USE_CONTROLIO, _DEBUG or _DEBUG_RELEASE is defined. In release build, this method is not implemented and it always returns KErrNotSupported.

There are drive specific and non-drive specific commands. Following are non-drive specific commands

RFs::TDriveNumber()

General purpose test interface - file system specific.

This function can only be used in debug builds or if _USE_CONTROLIO, _DEBUG or _DEBUG_RELEASE is defined. In release build, this method is not implemented and it always returns KErrNotSupported.

RFs::TDriveNumber()

General purpose test interface - file system specific.

This function can only be used in debug builds or if _USE_CONTROLIO, _DEBUG or _DEBUG_RELEASE is defined. In release build, this method is not implemented and it always returns KErrNotSupported.

RFs::TDriveNumber()

General purpose test interface - file system specific.

This function can only be used in debug builds or if _USE_CONTROLIO, _DEBUG or _DEBUG_RELEASE is defined. In release build, this method is not implemented and it always returns KErrNotSupported.

RFs::TDriveNumber()

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.

Request notification of a file server event - file system specific.

This function can only be used in debug builds or if _DEBUG or _DEBUG_RELEASE is defined. In release build, this method is not implemented and it always returns KErrNotSupported.

RFs::TDriveNumber() TRequestStatus

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.

Dismounts the specified extension.

RFs::ExtensionName

Dismounts the file system from the specified drive.

Dismounts the specified plugin from all drives on which it is mounted.

Dismounts the specified plugin.

Dismounts the specified plugin.

Dismounts a proxy drive.

Initialises a proxy drive.

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.

RFs::Volume

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.

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.

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.

Gets the entry details for a file or directory.

This information includes UID information.

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() .

Gets the name of the extension on the specified drive at the specified position in the extension hierarchy.

Gets the name of the file system mounted on the specified drive. The function can be called before calling DismountFileSystem() .

Note that the file system name, returned in the aName descriptor shall be threated as case-insensitive string. I.e. "fileSystem" and "FILESYSTEM" mean absolutely the same. Therefore, case-insensitive string methods (like TDesC::FindF() , TDesC::CompareF() ) shall be used to deal with the names.

RFs::DismountFileSystem

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: For the file systems without a sub type (e.g. ROM file system), the the file system name is returned (For example, 'Rom'). Examples: "FAT" file system; the subtypes can be "fat12", "fat16" or "fat32" "ROFS" file system; the subtype will be "ROFS"

Note also that the file system name, returned in the aName descriptor shall be threated as case-insensitive string. I.e. "fileSystem" and "FILESYSTEM" mean absolutely the same. Therefore, case-insensitive string methods (like TDesC::FindF() , TDesC::CompareF() ) shall be used to deal with the names.

TFSName

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.

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.

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.

TEntryKey

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.

TEntryKey

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.

TEntryKey

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.

TDriveNumber

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.

Gets the serial number of media.

Only local drive is allowed. Substed drive number will return KErrNotSupported.

TMediaSerialNumber

Tests whether user notification of file read or write failure is in effect.

Get exclusive access for this session to overwrite a specific disk area, which has previously been reserved via RFs::ReserveDriveSpace

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.

Obtain the system drive number.

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

RFs::GetSystemDriveChar RFs::SetSystemDrive TDriveNumber

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

aDriveChar On return, contains the system drive character RFs::GetSystemDrive

Sets the F32 properties file - Can only be called from the ESTART process

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.

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.

Tests whether the specified address is in ROM.

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).

TDriveNumber

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, RFs::SetSessionPath , 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.

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, RFs::SetSessionPath , 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.

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, RFs::SetSessionPath , 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.

This member function is not implemented in this version of Symbian OS. It always returns KErrNotSupported.

Sets the password for the media in the specified drive.

The media is not necessarily locked afterwards. Accessibility is determined by the following rules:

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\\"

         fs.MkDir(_L("C:\\DIR1\\"));
        

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.

         fs.MkDir(_L("C:\\DIR1\\"));     // shall create DIR1 in the root directory
fs.MkDir(_L("C:\\DIR1\\DIR2")); // No trailing backslash, fails with KErrAlreadyExists
        

This example will always fail because "DIR1" doesn't have a trailing backslash and discarded while the root directory always exists.

         fs.MkDir(_L("C:\\DIR1"));  // No trailing backslash, will always fail with KErrAlreadyExists
        

Note, the following case

         fs.MkDir(_L("C:\\example.txt\\"));	// would normally create a directory "c:\\example.txt\\" with KErrNone
        

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.

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.

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.

Mounts the the specified extension.

The extension must first have been loaded using AddExtension() .

RFs::ExtensionName

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;

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.

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;

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.

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;

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.

Mounts a specified plugin.

Note that this API uses unique position of the plugin.

This overload passes KPluginAutoAttach for the drive parameter which mounts on all of the drives specified as supported by the plugin.

Note - Plugins cannot be mounted on demand paged drives. KErrNone is returned so long as it has been able to mount on at least one drive; otherwise KErrNotSupported.

Mounts a specified plugin specifying the drive plugin will support.

Plugins cannot be mounted on demand paged drives. If KPluginAutoAttach is passed in, it will return KErrNone so long as it has been able to mount on at least one drive; otherwise KErrNotSupported.

Mounts a specified plugin using absolute position and a specific drive

Plugins cannot be mounted on demand paged drives. If KPluginAutoAttach is passed in, it will return KErrNone so long as it has been able to mount on at least one drive; otherwise KErrNotSupported.

Plugins wishing to be mounted using their CFsPlugin::iUniquePos should use MountPlugin(TDesC&,TInt) or MountPlugin(TDesC&)

If there is already a plugin at aPos then this plugin is inserted into aPos and other plugins are shifted downwards.

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.

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.

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.

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.

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.

TDriveNumber

Cancels a specific outstanding request for free disk space notification.

The outstanding request completes with KErrCancel.

Cancels all outstanding requests for free disk space notification.

Outstanding requests complete with KErrCancel.

Controls file system dismounting on the specified drive, the way of control depends on the parameter TNotifyDismountMode.

This API allows interested parties to: 1. Subscribe for notification of file system dismounting events. This allows subscribers to commit their data to the media prior to the file system being dismounted. See TNotifyDismountMode::EFsDismountRegisterClient

2. Make a graceful attempt to dismount the file system by notifying the subscribers about a pending file system dismount and waiting until all subscribers have finished processing the notification and have signaled that they are ready. If all clients don't respond in a reasonable time, the dismount request may be cancelled, followed by a forced dismount. If some client does not subscribe for dismounting notification and keeps handles opened, then after the file system dismounting all these handles will become invalid, any subsequent attempts to use them will result in KErrDismounted, and they should be closed(e.g. RFile::Close() ). See TNotifyDismountMode::EFsDismountNotifyClients

3. Dismount the file system by force even if there are opened handles (files, directories) on the volume being dismounted. Any clients that kept handles opened, after forced file system dismounting will have them invalidated. And any further attempts to use these handles will result in KErrDismounted, and they should be closed(e.g. RFile::Close() ). See TNotifyDismountMode::EFsDismountForceDismount

If there are clamped files on the volume, the file system dismounting will not happen until these files are unclamped.

The use case scenario: A 'Master' application that wants to dismount the file system on some drive 'aDrive' 'Client1' and 'Client2' applications interested in file system dismount event notifications, because they need to commit their data before the file system is dismounted.

1. 'Client1' and 'Client2' subscribe to the FS dismount notification using EFsDismountRegisterClient and start waiting on the request status objects. 2. 'Master' decides to dismount the file system on the drive 'aDrive'. 2.1 Graceful attempt: 'Master' calls RFs::NotifyDismount() with EFsDismountNotifyClients and starts waiting on 'aStat' for some time until all 'Client1' and 'Client2' respond or timeout occurs.

3. 'Client1' and 'Client2' have their 'aStat' completed as the result of the 'Master' calling EFsDismountNotifyClients. 3.1 'Client1' and 'Client2' flush data and close file handles. 3.2 as soon as 'Client1' and 'Client2' decide that they are ready for the pending FS dismount, they signal the 'Master' that they are ready by calling RFs::AllowDismount()

4. As soon as _all_ subscribed clients ('Client1' and 'Client2') have called RFs::AllowDismount() , the file system on drive 'aDrive' is dismounted and 'Master' has 'aStat' completed.

If, for example, 'Client2' hasn't responded in a reasonable time by calling RFs::AllowDismount() , the 'Master' can cancel the pending 'aStat' and dismount the file system by force by calling this API with EFsDismountForceDismount. In this case all subsequent attempts by 'Client2' to use its opened handles will result in KErrDismounted; these handles should be closed.

Cancels the oustanding dismount notifier, completing with KErrCancel.

RFs::NotifyDismount

Cancels all oustanding dismount notifiers for this session, completing with KErrCancel.

RFs::NotifyDismount

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:

         TParse fp;
        

         fs.Parse(name,fp);
        

is equivalent to

         TParse fp;
        

         fp.Set(name,NULL,&fs.SessionPath());
        

Note that the function does not check for illegal characters, or for illegal path components in either of the paths specified.

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:

         TParse fp;
        

         fs.Parse(name,related,fp);
        

is equivalent to

         TParse fp;
        

         fp.Set(name,related,&fs.SessionPath());
        

Note that the function does not check for illegal characters, or for illegal path components in any of the paths specified.

Gets the name of the plugin on the specified drive at the specified position in the plugin hierarchy.

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.

Queries specific information on volumes by commands. Available commands is defined by TQueryVolumeInfoExtCmd.

TQueryVolumeInfoExtCmd TVolumeIOParamInfo

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.

Maintained for BC

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.

Release exclusive access for this session to overwrite a specific disk area.

Forces a remount of the specified drive.

Removes the specified extension.

Removes the specified file system.

Removes the specified plugin.

Removes the specified extension.

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.

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.

Reserves an area of a drive. It is intended that sensible (tm) apps will reserve a small area of disk for 'emergency' use in case of later out of disk situations. If the amount of reserved space later needs to be readjusted, this method should be called again with aSpace as the amount of extra space needed.

Once space has been reserved via this method, an application can use RFs::GetReserveAccess to gain access to the reserved area prior to executing disk space critical sections of code. After the section of code is complete, the application should release access to the reserved area.

For internal drives, reserved space will be lost if a reboot occurs. For removeable drives, reserved space may be lost if there is a media change.

Reserved space will be cleaned up automatically when the RFs is closed.

Each drive has a max amount of space available to be reserved, and individual sessions also have a max amount of space. These are defined in f32/sfile/sf_std.h as KMaxTotalDriveReserved and KMaxSessionDriveReserved respectively. Once space is reserved, it is only available to the reserving session until that session releases the reserved space.

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.

Ends resource count checking. Typically, this function is called immediately before closing a session with the file server.

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.

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:

         fs.RmDir(_L("C:\\SRC\\ENTRY"));
        

         fs.RmDir(_L("C:\\SRC\\DIR"));
        

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.

Checks the integrity of the File System mounted on the specified drive and attempts to correct some known File System errors. The behaviour of this API and return codes are File System specific, dependent on how the File System implements its ScanDrive functionality.

ScanDrive will not run on drives that have files or directories opened.

ScanDrive is intended to be run ONLY on "Rugged-FAT" file system which is applicable to internal non-removable drives. Internal RAM drives are not supported.

The "Rugged FAT" file system is designed in such a way that only a limited number of known cases of corruption can be caused by sudden power loss. All of these known cases can be corrected by ScanDrive. Hence, running ScanDrive on "Rugged FAT" file system will result in: KErrNone If there was no File System corruption or ScanDrive has successfully repaired the File System. KErrCorrupt If ScanDrive has found a File System error that it cannot repair. Other system-wide error codes, see above.

Running ScanDrive on removable media or media that has FAT file system not in "Rugged FAT" mode is not practical, because ScanDrive is not designed for this. Therefore, do not treat ScanDrive on removable media as a generic "disk repair utility".

Issues a synchronous request to the server with the specified function number and arguments.

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.

Fails an allocation after aAllocNum successes.

This function can only be used in debug builds or if _DEBUG or _DEBUG_RELEASE is defined. In release build, this method is not implemented and it always returns KErrNotSupported.

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.

Sets the debug register to the given value.

This function can only be used in debug builds or if _DEBUG or _DEBUG_RELEASE is defined. In release build, this method is not implemented and it always returns KErrNotSupported.

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.

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.

Sets the failure condition.

This function can only be used in debug builds or if _DEBUG or _DEBUG_RELEASE is defined. In release build, this method is not implemented and it always returns KErrNotSupported.

Sets the date and time that the contents of a file or directory were modified, in UTC.

Enables/Disables change notification on a per-session basis. Change notification is enabled by default, and can be disabled using this API. Disabling change notification will result in clients of the file server not being notified of events such as directory/file changes.

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.

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.

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.

Only can be called in estart. Licensees could use this function to configure file server at startup through their own version of estart.

Currently only loader thread priority can be specified.

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.

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

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

Noifies the file server that startup initialisation is complete.

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 .

RFs::SetSubst TDriveInfo RFs::Drive

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.

Note that the file system name, returned in the aName descriptor shall be threated as case-insensitive string. I.e. "fileSystem" and "FILESYSTEM" mean absolutely the same. Therefore, case-insensitive string methods (like TDesC::FindF() , TDesC::CompareF() ) shall be used to deal with the names.

FileSystemName() KRootFileSystem

Dismount aOldFileSystemName and mount aNewFileSystemName in an atomic operation

If swapping in the composite filesystem, and no mounts have been added to it, then ROFS is added to it by default. The synchronous state of the composite filesystem will be used in preference to that of the old filesystem when it is mounted.

Makes available for paging-out the media space occupied by the file identified by the supplied handle.

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.

Gets the client side version number.

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.

RFs::Drive

Gets volume information for a formatted device asynchronously. 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.

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.

Special enumerator values for the SupportedFileSystemName() API

specifies drive finalisation modes