1 // Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // f32\inc\f32fsys.h

    15 // 

    16 //

    17 

    18 

    19 

    20 /**

    21  @file

    22  @publishedPartner

    23  @released

    24 */

    25 

    26 #if !defined(__F32FSYS_H__)

    27 #define __F32FSYS_H__

    28 #if !defined(__F32FILE_H__)

    29 #include <f32file.h>

    30 #endif

    31 //

    32 #if defined(_UNICODE)

    33 #define KFileSystemUidValue KFileSystemUidValue16

    34 #define KFileServerUidValue KFileServerUidValue16

    35 #define KFileServerDllUidValue KFileServerDllUidValue16

    36 #else

    37 #define KFileSystemUidValue KFileSystemUidValue8

    38 #define KFileServerUidValueKFileServerUidValue8

    39 #define KFileServerDllUidValueKFileServerDllUidValue8

    40 #endif

    41 

    42 

    43 /**

    44 Filesystem error code 1 : indicates an item cannot be found,

    45 because it has been hidden.

    46 */

    47 const TInt KErrHidden=(1);

    48 

    49 /**

    50 Filesystem error code 2 : in the context of file operations, a path

    51 was not found, because it has been hidden.

    52 */

    53 const TInt KErrPathHidden=(2);

    54 

    55 

    56 const TInt KFileShareLockGranularity=2;

    57 const TInt KAsyncRequestArrayGranularity=2;

    58 

    59 /**

    60 @publishedPartner

    61 @released

    62 

    63 File system UID value 16.

    64 */

    65 const TInt KFileSystemUidValue16=0x100039df;

    66 

    67 

    68 

    69 

    70 /**

    71 @publishedPartner

    72 @released

    73 

    74 File system UID value 8.

    75 */

    76 const TInt KFileSystemUidValue8=0x1000008f;

    77 

    78 

    79 

    80 

    81 /**

    82 @publishedPartner

    83 @released

    84 

    85 File server UID value 16.

    86 */

    87 const TInt KFileServerUidValue16=0x100039e3;

    88 

    89 

    90 

    91 

    92 /**

    93 @publishedPartner

    94 @released

    95 

    96 File server UID value 8.

    97 */

    98 const TInt KFileServerUidValue8=0x100000bb;

    99 

   100 

   101 

   102 

   103 /**

   104 @publishedPartner

   105 @released

   106 

   107 File server DLL UID value 16.

   108 */

   109 const TInt KFileServerDllUidValue16=0x100039e4;

   110 

   111 

   112 

   113 

   114 /**

   115 @publishedPartner

   116 @released

   117 

   118 File server DLL UID value 8.

   119 */

   120 const TInt KFileServerDllUidValue8=0x100000bd;

   121 

   122 

   123 

   124 

   125 /**

   126 @publishedPartner

   127 @released

   128 

   129 Local file system UID value.

   130 */

   131 const TInt KLocalFileSystemUidValue=0x100000d6;

   132 

   133 

   134 

   135 

   136 /**

   137 @publishedPartner

   138 @released

   139 

   140 Estart component UID value.

   141 */

   142 const TInt KEstartUidValue=0x10272C04;

   143 

   144 

   145 

   146 /**

   147 @publishedPartner

   148 @released

   149 Maximum length of a volume name.

   150 */

   151 const TInt KMaxVolumeNameLength=11;

   152 

   153 

   154 

   155 

   156 /**

   157 @publishedPartner

   158 @released

   159 

   160 First local drive indicator.

   161 */

   162 const TInt KFirstLocalDrive=EDriveC;

   163 

   164 

   165 const TInt KMaxExtensionCount=2;

   166 //

   167 const TInt KDriveInvalid=-1;

   168 //

   169 _LIT(KMediaPWrdFile, "?:\\sys\\data\\mmcstore");

   170 //

   171 

   172 /** 

   173 @internalTechnology

   174 */

   175 const TUint KSystemDriveKey = 0x10283049;

   176 

   177 

   178 /**

   179 @publishedPartner

   180 @released

   181 

   182 Enumeration that specifies whether, on opening a file:

   183 - an existing file is opened

   184 - a new file is created 

   185 - an existing file is replaced.

   186 */

   187 enum TFileOpen {EFileOpen,EFileCreate,EFileReplace};

   188 

   189 

   190 

   191 

   192 /**

   193 @publishedPartner

   194 @released

   195 

   196 The file share mode.

   197 */

   198 typedef TFileMode TShare;

   199 

   200 

   201 

   202 

   203 class CMountCB;

   204 class CFileSystem;

   205 class CFileCB;

   206 class CDirCB;

   207 class CFileShare;

   208 class CSessionFs;

   209 class CFsPlugin;

   210 class CFileBody;

   211 class CMountBody;

   212 class CFsMessageRequest;

   213 

   214 //

   215 class CFsObjectCon;

   216 class CFileCache;

   217 

   218 /**

   219 @publishedPartner

   220 @released

   221 

   222 Implements reference counting to track concurrent references to itself.

   223  

   224 An object of this type arranges automatic destruction of itself when the final 

   225 reference is removed.

   226 

   227 A reference counting object is any object which has CFsObject as its base class. 

   228 Constructing a CFsObject derived type or calling its Open() member function 

   229 adds a reference to that object by adding one to the reference count; calling 

   230 its Close() member function removes a reference by subtracting one from the 

   231 reference count; when the last user of the object calls Close(), the reference 

   232 count becomes zero and the object is automatically destroyed.

   233 */

   234 class CFsObject : public CBase

   235 

   236 	{

   237 public:

   238 	IMPORT_C CFsObject();

   239 	IMPORT_C virtual TInt Open();

   240 	IMPORT_C virtual void Close();

   241 	IMPORT_C TInt SetName(const TDesC* aName);

   242 	IMPORT_C TName Name() const;

   243 	IMPORT_C virtual TBool IsCorrectThread();

   244 	inline CFsObjectCon* Container() const;

   245 protected:

   246 	void DoClose();

   247 	TInt UniqueID() const;

   248 	inline TInt Inc();

   249 	inline TInt Dec();

   250 	IMPORT_C ~CFsObject();

   251 private:

   252 	TInt iAccessCount;

   253 	CFsObjectCon* iContainer;

   254 	HBufC* iName;   

   255 friend class CFsObjectCon;

   256 friend class CFsObjectIx;

   257 	};

   258 

   259 

   260 

   261 

   262 class CFsRequest;

   263 class CFsInternalRequest;

   264 

   265 /**

   266 Implements a request dispatcher.

   267  

   268 Base class for file server resources.

   269 for example subsessions that are opened, such as RFile etc, that need closing are closed by 

   270 issuing a subsession close request, handled by this object.

   271 

   272 @publishedPartner

   273 @released

   274 */

   275 class CFsDispatchObject : public CFsObject

   276 	{

   277 public:

   278 	CFsDispatchObject();

   279 	/**

   280 	Returns the drive number.

   281 	@return Drive number.

   282 	*/

   283 	TInt DriveNumber() const {return(iDriveNumber);}

   284 	IMPORT_C void Close();

   285 	IMPORT_C virtual TBool IsCorrectThread();

   286 protected:

   287 	void DoInitL(TInt aDrvNumber);

   288 	void Dispatch();

   289 	~CFsDispatchObject();

   290 private:

   291 	CFsInternalRequest* iRequest;

   292 	TInt iDriveNumber;

   293 friend class TFsCloseObject;

   294 friend class CFileShare;	// needed to override the close operation so that the file cache can be flushed on a close

   295 	};

   296 

   297 

   298 

   299 

   300 /**

   301 Notifier class must be unique to each thread so one per drive or threaded plugin should be used

   302 allocated in the file system. No longer global

   303 

   304 @publishedPartner

   305 @released

   306 */

   307 NONSHARABLE_CLASS(CAsyncNotifier) : public CBase

   308 	{

   309 public:

   310 	IMPORT_C static CAsyncNotifier* New();

   311 	IMPORT_C ~CAsyncNotifier();

   312 	IMPORT_C TInt Notify(const TDesC& aLine1,const TDesC& aLine2,const TDesC& aButton1,const TDesC& aButton2,TInt& aButtonVal);

   313 	inline void SetMount(CMountCB* aMount) { iMount = aMount; };

   314 protected:

   315 	CAsyncNotifier();

   316 	TInt Connect(); 

   317 private:

   318 	RNotifier iNotifier;

   319 	CMountCB* iMount;

   320 	};

   321 

   322 

   323 

   324 

   325 class CProxyDriveFactory;

   326 

   327 /**

   328 @publishedPartner

   329 @released

   330 

   331 Structure containing information related to a single drive extension.

   332 */

   333 struct TExtensionInfo

   334 	{

   335 	TBool iIsPrimary;            	///< Is the primary drive extension for a given drive  

   336 	CProxyDriveFactory* iFactory;  	///< Pointer to the drive extension's object factory

   337 	};

   338 

   339 

   340 

   341 

   342 /**

   343 @publishedPartner

   344 @released

   345 

   346 Represents information related to the Drive extension(s) in use for a given drive.

   347 */

   348 struct TDriveExtInfo

   349 	{

   350 	TDriveExtInfo();

   351 	

   352 	TInt iCount; 								///< Number of drive extensions in use                               

   353 

   354 	TExtensionInfo iInfo[KMaxExtensionCount]; 	///< Drive extension related information    

   355 	};

   356 

   357 

   358 

   359 

   360 /**

   361 @publishedPartner

   362 @released

   363 

   364 Represents a drive in the file server.

   365 

   366 Note that drives may act as substitutes for paths on other drives,

   367 in which case any access to this drive letter will be translated into

   368 a reference to the assigned path. In this way drives can act as short

   369 cuts to paths on other drives.

   370 */

   371 class TDrive

   372 	{

   373 public:

   374 	TDrive();

   375 	void CreateL(TInt aDriveNumber);

   376 	TInt CheckMount();

   377 	TInt CheckMountAndEntryName(const TDesC& aName);

   378     TInt FinaliseMount();

   379     TInt FinaliseMount(TInt aOperation, TAny* aParam1=NULL, TAny* aParam2=NULL);

   380     TInt MountControl(TInt aLevel, TInt aOption, TAny* aParam);

   381 

   382     void MountMedia(TBool aForceMount);

   383 	void FlushCachedFileInfoL();

   384 	TInt FlushCachedFileInfo(TBool aPurgeCache = EFalse);

   385 	void PurgeDirty(CMountCB& aMount);

   386 	void DriveInfo(TDriveInfo& anInfo);

   387 	TInt Volume(TVolumeInfo& aVolume);

   388 	TInt SetVolume(const TDesC& aName);

   389 	TInt MkDir(const TDesC& aName);

   390 	TInt RmDir(const TDesC& aName);

   391 	TInt Delete(const TDesC& aName);

   392 	TInt Rename(const TDesC& anOldName,const TDesC& aNewName);

   393 	TInt Replace(const TDesC& anOldName,const TDesC& aNewName);

   394 	TInt Entry(const TDesC& aName,TEntry& anEntry);

   395 	TInt SetEntry(const TDesC& aName,const TTime& aTime,TUint aMask,TUint aVal);

   396 	TInt FileTemp(CFsRequest* aRequest,TInt& aHandle,const TDesC& aPath,TDes& aName,TUint aMode);

   397 	TInt FileOpen(CFsRequest* aRequest,TInt& aHandle,const TDesC& aName,TUint aMode,TFileOpen anOpen);

   398 	TInt DirOpen(CSessionFs* aSession,TInt& aHandle,const TDesC& aName,TUint anAtt,const TUidType& aUidType);

   399 	

   400     TInt CheckDisk(); 

   401     TInt CheckDisk(TInt aOperation, TAny* aParam1=NULL, TAny* aParam2=NULL);

   402 	

   403     TInt ScanDrive(); 

   404 	TInt ScanDrive(TInt aOperation, TAny* aParam1=NULL, TAny* aParam2=NULL);

   405 

   406     TInt ReadFileSection(const TDesC& aName,TInt aPos,TAny* aTrg,TInt aLength,const RMessagePtr2& aMessage);

   407 	TInt GetShortName(const TDesC& aLongName,TDes& aShortName);

   408 	TInt GetLongName(const TDesC& aShortName,TDes& aLongName);

   409 	TInt IsFileOpen(const TDesC& aFileName,CFileCB*& aFileCB);

   410 	TInt IsFileInRom(const TDesC& aFileName,TUint8*& aFileStart);

   411 	TInt LockDevice(TMediaPassword& aOld,TMediaPassword& aNew,TBool aStore);

   412 	TInt UnlockDevice(TMediaPassword& aPassword,TBool aStore);

   413 	TInt ClearDevicePassword(TMediaPassword& aPassword);

   414 	TInt EraseDevicePassword();

   415 	TInt FreeDiskSpace(TInt64& aFreeDiskSpace);

   416 	TInt ForceRemountDrive(const TDesC8* aMountInfo,TInt aMountInfoMessageHandle,TUint aFlags);

   417 	TBool IsWriteProtected();

   418 	TInt MountExtension(CProxyDriveFactory* aFactory,TBool aIsPrimary);

   419 	TInt DismountExtension(CProxyDriveFactory* aFactory,TBool aIsPrimary);

   420 	TInt ExtensionName(TDes& aExtensionName,TInt aPos);

   421 	TInt ControlIO(const RMessagePtr2& aMessage,TInt aCommand,TAny* aParam1,TAny* aParam2);	

   422 	void SetAtt(TUint aValue);

   423 	IMPORT_C TUint Att();

   424 	IMPORT_C TBool GetNotifyUser();		

   425 	IMPORT_C void Dismount();		

   426 	IMPORT_C TBool IsWriteableResource() const;	

   427 	IMPORT_C TBool IsCurrentWriteFunction() const; 

   428 	inline TInt GetReason() const;	

   429 	inline void SetChanged(TBool aValue);	

   430 	inline TBool IsChanged() const;

   431 	inline TInt DriveNumber() const;

   432 	inline TBool IsMounted() const;

   433 	inline TBool IsLocal()	const;			

   434 	inline TBool IsRom()	const;			

   435 	inline TBool IsRemovable()	const;		

   436 	inline TBool IsSubsted() 	const;		

   437 	inline CMountCB& CurrentMount() const;

   438 	inline TDrive& SubstedDrive() const;

   439 	inline void SetSubstedDrive(TDrive* aDrive);

   440 	inline HBufC& Subst() const;

   441 	inline void SetSubst(HBufC* aSubst);

   442 	inline CFsObjectCon& Mount() const;	

   443 	inline CFileSystem& FSys();			

   444 	inline CFileSystem*& GetFSys();

   445 	inline TDriveExtInfo& ExtInfo();	

   446 	inline void SetNotifyOn();			

   447 	inline void SetNotifyOff();	

   448 	inline TInt ReservedSpace() const;

   449 	inline void SetReservedSpace(const TInt aReservedSpace);

   450 	

   451 	inline void SetRugged(TBool aIsRugged);

   452 	inline TBool IsRugged() const;

   453 

   454     inline TBool IsSynchronous() const;

   455     inline void SetSynchronous(TBool aIsSynch);

   456 

   457 public:

   458 	void DismountLock();

   459 	TInt DismountUnlock();

   460 	TInt DismountLocked() const;

   461 	void SetDismountPending(TBool aPending);

   462 	TBool DismountPending() const;

   463 	void ForceDismount();

   464 	TInt ActiveMounts() const;

   465 	void ReactivateMounts();

   466 	TInt ClampFile(const TDesC& aName,TAny* aHandle);

   467 	TInt UnclampFile(CMountCB* aMount, RFileClamp* aHandle);

   468 	TInt ClampsOnDrive(TBool aRequestDismount=EFalse, TInt (*aFunc)(TAny*)=NULL,TAny* aParamList=NULL);

   469 	TInt SetCallbackRequired(TInt (*aFunc)(TAny*),TAny* aParamList);

   470 	IMPORT_C void FlushOutstandingDismount(TBool *aDismountRequired);

   471 	TInt ClearDeferredDismount();

   472 	IMPORT_C void SetClampFlag(TBool aClamped);

   473 	IMPORT_C TBool ClampFlag();

   474 	inline void Lock();

   475 	inline void UnLock();

   476 	TBool ReMount(CMountCB& aMount);

   477 

   478     TBool RequestFreeSpaceOnMount(TUint64 aFreeSpaceRequired); 

   479     TInt  MountedVolumeSize(TUint64& aSize); 

   480 

   481 private:

   482 	void MountMediaL(TBool aForceMount,CMountCB*& aMount);

   483 	void SetVolumeL(const TDesC& aName,HBufC*& aBuf);

   484 	void DirOpenL(CSessionFs* aSession,TInt& aHandle,const TDesC& aName,TUint anAtt,const TUidType& aUidType,CDirCB*& aDir);

   485 	void FileOpenL(CFsRequest* aRequest,TInt& aHandle,const TDesC& aName,TUint aMode,TFileOpen anOpen,CFileCB*& aFileCB,CFileShare*& aFileShare);

   486 	TInt CheckMountAndEntryNames(const TDesC& anOldName,const TDesC& aNewName);

   487 	CFileCB* LocateFileByPath(const TDesC& aPath);

   488 	TInt CheckDirectories(const TDesC& anOldName,const TDesC& aNewName);

   489 	void DoEntryL(const TDesC& aName,TEntry& anEntry);

   490 	void ReadSectionL(const TDesC& aName,TInt aPos,TAny* aTrg,TInt aLength,const RMessagePtr2& aMessage);

   491 	TInt ValidateShare(CFileCB& aFile,TShare aReqShare);

   492 	TInt CheckAttributes(const TDesC& aName,TUint& aSetAttMask,TUint& aClearAttMask);

   493 	TBool IsExtensionMounted(CProxyDriveFactory* aFactory);

   494 	CFileCB* LocateFile(const TDesC& aName);

   495 	CFileCache* LocateClosedFile(const TDesC& aName, TBool aResurrect = ETrue);

   496 	TBool ReMount();

   497 	IMPORT_C TBool IsDriveThread() const;

   498 	IMPORT_C TBool IsMainThread() const;

   499 	IMPORT_C void DriveFault(TBool aDriveError) const;

   500     void DoDismount();

   501 

   502 private:

   503 	

   504     //-- intrinsic TDrive flags. Used in iDriveFlags.

   505     enum 

   506     { 

   507         ENotifyOff       = 0x01, 

   508         EDismountPending = 0x02, 

   509         ENotRugged       = 0x04, 

   510         EClampPresent    = 0x08,

   511         EDriveIsSynch    = 0x10, //-- is set on mount when the drive is synchronous (doesn't have its own thread)

   512     };	

   513 

   514 private:

   515 	TInt iDriveNumber;

   516 	TUint iAtt;

   517 	TBool iChanged;

   518 	TInt iReason;

   519 	TInt iMountNumber;

   520 	CFileSystem* iFSys;

   521 	CMountCB* iCurrentMount;

   522 	TDrive* iSubstedDrive;

   523 	HBufC* iSubst;

   524 	CFsObjectCon* iMount;

   525 	RFastLock iLock;

   526 	TDriveExtInfo iExtInfo;	

   527 	TInt iDriveFlags;   ///< intrinsic TDrive flags

   528 	TInt iReservedSpace;

   529 	TInt iDismountLock;

   530 	TInt iMountFailures;		// number of times the mount has failed

   531 	TInt iLastMountError;

   532 friend class LocalDrives;		// for access to iChanged flag

   533 	};

   534 

   535 class CFileCB;

   536 class CDirCB;

   537 

   538 

   539 

   540 

   541 /**

   542 @publishedPartner

   543 @released

   544 

   545 A file server interface class representing a mount.

   546 

   547 An instance of this object is referred to as a mount control block.

   548 

   549 A mount control block needs to be created for a specific volume (partition) on

   550 a drive in order to be able to access that volume. Volumes may be permanent

   551 or represent removable media. Note that removable media may also be mounted directly onto

   552 a device with no drive. Volumes can be formatted, unlike drives.

   553 

   554 The volume represented is either a currently mounted volume in the system or,

   555 in the case of removable volumes, a volume that has been removed but still has

   556 subsession objects open.

   557 

   558 A plug-in file system implements this class.

   559 */

   560 class CMountCB : public CFsDispatchObject

   561 	{

   562 public:

   563 	IMPORT_C CMountCB();

   564 	IMPORT_C ~CMountCB();

   565 	IMPORT_C TBool operator!=(const CMountCB& aMount) const;

   566 	IMPORT_C TBool MatchEntryAtt(TUint anAtt,TUint aMatt) const;

   567 	IMPORT_C void SetDiskSpaceChange(TInt64 aFreeDiskSpace);

   568 	inline TDrive& Drive() const;

   569 	inline void SetDrive(TDrive* aDrive);

   570 	inline HBufC& VolumeName() const; 

   571 	inline void SetVolumeName(HBufC* aName);

   572 	inline TBool GetNotifyUser() const;

   573 	inline void SetNotifyOn();

   574 	inline void SetNotifyOff();

   575 	inline void IncLock();

   576 	inline void DecLock();

   577 	inline TInt LockStatus() const; 

   578 	inline TBool IsCurrentMount() const; 

   579 	inline TBool Locked() const;

   580 	inline TInt64 Size() const; 

   581 	inline TInt LocalDrive(TBusLocalDrive*& aLocalDrive);

   582 	inline TInt LocalBufferSupport(CFileCB* aFile = NULL);

   583 	inline TInt AddToCompositeMount(TInt aMountIndex);

   584 	

   585 // Pure virtual

   586 

   587     /**

   588     Attempts to set the mount control block properties using

   589     the current mount (i.e. volume) on the associated drive.

   590 

   591     The function should set the volume name (iVolumeName),

   592     the unique ID (iUniqueID) and the volume size (iSize)

   593     by reading and processing the current mount.

   594 

   595     When aForceMount is set to ETrue, the properties of a corrupt volume should

   596     be forcibly stored. The classic case of when this is desirable is when

   597     a corrupt volume needs to be formatted.

   598 

   599     The function should leave, on error detection, with an appropriate error code.

   600 

   601     @param aForceMount Indicates whether the properties of a corrupt

   602                        volume should be stored.

   603                        

   604     @leave KErrCorrupt The properties of the current mount on the drive were

   605            not successfully mounted due to corruption of volume information,

   606            assuming that aForceMount is not set.

   607     */

   608 	virtual void MountL(TBool aForceMount) =0;

   609 

   610 

   611     /**

   612     Checks whether the mount control block represents the current mount on

   613     the associated drive.

   614 

   615     The function should read mount information from the current volume,

   616     and check it against the mount information from this mount - typically

   617     iVolumeName and iUniqueID. If the mount information matches, the function

   618     should return KErrNone, otherwise it should return KErrGeneral.

   619 

   620     Called by the associated TDrive object when the drive has no current mounts,

   621     which is the case on first access to the drive and following a volume

   622     change on a drive associated with removable media. In this circumstance,

   623     this function is called systematically on every mount control block owned

   624     by the drive. If ReMount() calls for all existing mount

   625     control blocks fail, the drive creates a new mount control block and calls

   626     CMountCB::MountL() on that object; the new object is added to the list of

   627     mount control blocks owned by the drive.

   628 

   629     @return KErrNone if the mount represented by this object is found to be

   630             the current mount;

   631             KErrGeneral if this object is found not to represent

   632             the current mount;

   633             otherwise one of the other sytem wide error codes.

   634     */

   635 	virtual TInt ReMount() =0;

   636 

   637 

   638     /**

   639     Carries out any clean-up necessary for a volume dismount. 

   640 

   641     Dismounting a volume will always succeed, so the function does not need

   642     to return an error value. Any cached information should be discarded and no

   643     attempt should be made to access the volume. For removable media it may be

   644     that the media has already been removed. This function is called when

   645     a media change is detected.

   646     */

   647 	virtual void Dismounted() =0;

   648 

   649 

   650     /**

   651     Gets volume information.

   652 

   653     The only information that the function has to supply is the free space,

   654     TVolumeInfo::iFree, since the remaining members have already been set by

   655     the calling function.

   656 

   657     The function should leave, on error detection, with

   658     an appropriate error code.

   659 

   660     @param aVolume On return, a reference to the filled volume

   661                    information object.

   662     */

   663 	virtual void VolumeL(TVolumeInfo& aVolume) const =0;

   664 

   665 

   666     /**

   667     Sets the volume name for the mount, thus writing the new volume name

   668     to the corresponding volume.

   669 

   670     This function should leave on error detection.

   671 

   672     @param aName A reference to a descriptor containing the new volume name.

   673 

   674     @leave KErrBadName If the specified volume name is longer than the maximum

   675            allowed length for a volume name

   676     */

   677 	virtual void SetVolumeL(TDes& aName) =0;

   678 

   679 

   680     /**

   681     Creates a new directory on the mount.

   682 

   683     The directory to be created is identified through its full name in aName.

   684     The full name is in the form:

   685     @code

   686     \\dirA\\dirB\\dirC\\dirD

   687     @endcode

   688     where dirD is the new directory to be created in \\dirA\\dirB\\dirC\\.

   689     This means that dirC is the leaf directory in which dirD will be created.

   690 

   691     The function should leave, on error detection, with an appropriate

   692     error code.

   693 

   694     @param aName A reference to a descriptor containing the full name of

   695                  the directory to be created.

   696                  

   697     @leave  KErrPathNotFound Part of the path in aName does not exist.

   698     @leave  KErrAlreadyExists dirD already exists in \\dirA\\dirB\\dirC\\

   699     @leave  KErrAccessDenied dirD already exists but is not a directory.

   700     @leave  KErrDirFull There is no room in \\dirA\\dirB\\dirC\\ for the new entry,

   701             which is especially applicable to the root directory.

   702     */

   703 	virtual void MkDirL(const TDesC& aName) =0;

   704 

   705 

   706     /**

   707     Removes the directory specified by aName (its full name) from the volume.

   708 

   709     The directory specified by aName is in the form:

   710     @code

   711     \\dirA\\dirB\\dirC\\dirD

   712     @endcode

   713     where dirD is the directory to be removed from \\dirA\\dirB\\dirC\\.

   714     This means that dirC is the leaf directory from which dirD should be removed.

   715 

   716     The function can assume that the directory exists and is not read-only. 

   717 

   718     The function should leave with a suitable error code if it cannot complete

   719     successfully for any reason. 

   720     

   721     @param aName A reference to a descriptor containing the full name of

   722                  the directory to be removed.

   723     

   724     @leave KErrInUse dirD contains entries other than the parent (..)

   725            and current (.) entries.

   726     */

   727 	virtual void RmDirL(const TDesC& aName) =0;

   728 

   729 

   730     /**

   731     Deletes the specified file from the mount.

   732 

   733     The function can assume that the file is closed.

   734 

   735     The file name specified by aName is of the form:

   736     @code

   737     \\dirA\\dirB\\dirC\\file.ext

   738     @endcode

   739     

   740     The extension is optional.

   741 

   742     The function should leave on error detection, with

   743     an appropriate error code.

   744 

   745 	@param aName A reference to a descriptor containing the full path name

   746 	             of the file that will be removed.

   747 	

   748 	@leave KErrAccessDenied aName specifies a file whose attributes state that

   749 	       the file is read-only or aName specifies a directory.

   750     */

   751 	virtual void DeleteL(const TDesC& aName) =0;

   752 

   753 

   754     /**

   755     Renames or moves a single file or directory on the mount.

   756 

   757     It can be used to move a file or directory since both

   758     anOldName and anNewName specify the respective entries with full names;

   759     for example,

   760     @code

   761     \\dirA\\dirB\\dirC\\oldEntryName

   762     @endcode

   763     

   764     and

   765     

   766     @code

   767     \\dirE\\dirF\\dirG\\newEntryName

   768     @endcode

   769 

   770     If oldEntryName is a file, it can be assumed that it is closed.

   771     If oldEntryName is a directory, it can be assumed that there are no

   772     open files in this directory. Furthermore, if newEntryName specifies

   773     a directory, it can be assumed that it is not a subdirectory of oldEntryName.

   774 

   775     The function should leave with an appropriate error code if it cannot

   776     complete successfully for any reason. 

   777 

   778 	@param anOldName A reference to a descriptor containing the full entry

   779 	                 name of the entry to be renamed.

   780 

   781 	@param anNewName A reference to a descriptor containing the new full entry

   782 	                 name for the entry to be renamed.

   783  

   784     @leave KErrAlreadyExists The new entry already exists.

   785     */

   786 	virtual void RenameL(const TDesC& anOldName,const TDesC& anNewName) =0;

   787 

   788 

   789     /**

   790     Replaces one file on the mount with another.

   791 

   792     The function can assume that both anOldName and, if it exists, anNewName

   793     contain the full file names of files, and that these files are not open.

   794 

   795     If the file aNewName does not exist it should be created.

   796 

   797     The file anOldName should have its contents, attributes, and the universal

   798     date and time of its last modification, copied to the file aNewName,

   799     overwriting any existing contents and attribute details.

   800     Finally anOldName should be deleted.

   801 

   802     The function should leave with an appropriate error code if it cannot

   803     complete successfully for any reason.

   804 

   805     @param anOldName A reference to a descriptor containing the full file name

   806                      of the file to replace the file specified by anNewName

   807     @param anNewName A reference to a descriptor containing the new full file

   808                      name for the entry to be replaced.

   809     */

   810 	virtual void ReplaceL(const TDesC& anOldName,const TDesC& anNewName) =0;

   811 

   812 

   813     /**

   814     Gets the entry details for the specified file or directory.

   815 

   816     anEntry should be filled with details from the file or directory with the

   817     full name aName. aName is of the form

   818     @code

   819     \\dirA\\dirB\\dirC\\entry.

   820     @endcode

   821     

   822     Note that anEntry.iType (the entry UID) should only be set for a file whose

   823     size is greater than or equal to sizeof(TCheckedUid).

   824 

   825     The function should leave with an appropriate error code if it cannot

   826     complete successfully for any reason.

   827 

   828     @param aName   A reference to a descriptor containing the full name of

   829                    the entry whose details are required.

   830     @param anEntry On return, a reference to the filled entry object.

   831     

   832     @leave KErrPathNotFound The entry, aName, cannot be found.

   833     */

   834 	virtual void EntryL(const TDesC& aName,TEntry& anEntry) const =0;

   835 

   836 

   837     /**

   838     Sets entry details for a specified file or directory.

   839 

   840     The entry identfied by the full name descriptor aName should have

   841     its modification time and its attributes mask updated as required.

   842 

   843     The entry receives a new universal modified time from aTime.

   844     The entry attributes are set with aSetAttMask and cleared

   845     with aClearAttMask:

   846     the bits that are set in aSetAttMask should be set

   847     in the entry attribute mask;

   848     the bits that are set in aClearAttMask

   849     should be cleared from the entry attribute mask.

   850 

   851     The function can assume that aSetAttMask and aClearAttMask do not change

   852     the type of attribute (i.e. volume or directory). Furthermore, if aName

   853     specifies a file, it can be assumed that this file is closed.

   854 

   855     The function should leave with an appropriate error code on error detection.

   856     

   857     @param aName         A reference to a descriptor containing the full name of

   858                          the entry to be updated.

   859     @param aTime         A reference to the time object holding the new universal

   860                          modified time for aName.

   861     @param aSetAttMask   Attribute mask for setting the entry's attributes.

   862     @param aClearAttMask Attribute mask for clearing the entry's attributes.

   863     */

   864 	virtual void SetEntryL(const TDesC& aName,const TTime& aTime,TUint aSetAttMask,TUint aClearAttMask) =0;

   865 

   866 

   867     /**

   868     Customises the opening of a new or existing file on the mount.

   869 

   870     The function is called internally (via TDrive::FileOpen()) as a result of

   871     a call by the client, and the file is created, if necessary, and opened by

   872     the calling function. However this function implements any replacement

   873     functionality, as well as any other behaviour particular to the file system.

   874 

   875     If anOpen specifies EFileReplace (rather than EFileCreate or EFileOpen) then,

   876     if replacement functionality is required, the data contained in the file

   877     should be discarded, the archive attribute should be set, and the size of

   878     the file should be set to zero. Note that it can be assumed that if anOpen

   879     specifies EFileReplace then the file already exists.

   880 

   881     After successful completion of the function, the file control block pointer

   882     will be added to the file server's global files container.

   883 

   884     The function should leave with a suitable error code if it cannot be completed

   885     successfully.

   886 

   887     @param aName  The full name of the file that will be opened.

   888     @param aMode  The file share mode. The following share modes are available:

   889                   EFileShareExclusive;

   890                   EFileShareReadersOnly;

   891                   EFileShareAny;

   892                   EFileShareReadersOrWriters;

   893                   EFileStream;

   894                   EFileStreamText;

   895                   EFileRead;

   896                   EFileWrite.

   897     @param anOpen IndicatES how the file will be opened. It can be one of

   898                   the following:

   899                   EFileOpen;

   900                   EFileCreate;

   901                   EFileReplace.

   902     @param aFile  Pointer to the file control block which will, on success,

   903                   represent the open file.

   904                   

   905     @leave KErrAccessDenied aName may specify a directory, or the function may

   906            be attempting to open a file on a ROM drive.

   907     */

   908 	virtual void FileOpenL(const TDesC& aName,TUint aMode,TFileOpen anOpen,CFileCB* aFile) =0;

   909 

   910 

   911     /**

   912     Customises the opening of a directory on the mount.

   913 

   914     The function is called internally, and the directory will have been created

   915     and initialised by the calling function. Any customisation specific to

   916     a file system should be implemented in this function.

   917 

   918     Note that aName is of the form

   919     @code

   920     \\dirA\\dirB\\dirC\\file.ext

   921     @endcode

   922     

   923     where \\dirA\\dirB\\dirC\\ is the directory to be opened and file.ext is

   924     an optional entry name and extension.

   925 

   926     After successful completion of the function, the directory control block

   927     pointer will be added to the file server global directories container.

   928 

   929     The function should leave with a suitable error code if it cannot complete

   930     successfully for any reason.

   931 

   932     @param aName A reference to a descriptor containing the full name of

   933                  the directory that will be opened.

   934     @param aDir  Points to a directory control block which will, on success,

   935                  represent the open directory.

   936     */

   937 	virtual void DirOpenL(const TDesC& aName,CDirCB* aDir) =0;

   938 

   939 

   940     /**

   941     Reads the specified length of data from the specified position on

   942     the volume directly into the client thread.

   943 

   944     It can be assumed that if this function is called,

   945     then there has been a successful mount.

   946 

   947     This function should leave with an appropriate error code when

   948     an error is detected.

   949 

   950     @param aPos     Start position in the volume for the read operation,

   951                     in bytes.

   952     @param aLength  The number of bytes to be read.

   953     @param aTrg     A pointer to the buffer into which data is to be read.

   954     @param anOffset The offset at which to start adding data to the read buffer.

   955     @param aMessage

   956     */

   957 	virtual void RawReadL(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt anOffset,const RMessagePtr2& aMessage) const = 0;

   958 

   959 

   960     /**

   961     Writes a specified length of data from the client thread to the volume

   962     at the specified position.

   963 

   964     It can be assumed that if this function is called, then there has been

   965     a successful mount.

   966 

   967     This function should leave with an appropriate error code when

   968     an error is detected.

   969 

   970     @param aPos     Start position in the volume for the write operation,

   971                     in bytes.

   972     @param aLength  The number of bytes to be written.

   973     @param aSrc     Pointer to the buffer from which data will be written.

   974     @param anOffset The offset in the buffer at which to start writing data.

   975     @param aMessage

   976     */

   977 	virtual void RawWriteL(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt anOffset,const RMessagePtr2& aMessage) = 0;

   978 

   979 

   980     /**

   981     Gets the short name of the file or directory with the given full name.

   982 

   983     This function is used in circumstances where a file system mangles

   984     Symbian OS natural names, in order to be able to store them on

   985     a file system that is not entirely compatible.

   986 

   987     The function should leave with a suitable error code if it cannot complete

   988     successfully for any reason.

   989 

   990 	@param aLongName  A reference to a descriptor containing the full name

   991 	                  of the entry.

   992 	@param aShortName On return, a reference to a descriptor containing

   993 	                  the short name of the entry.

   994     

   995     @leave KErrNotFound The entry specified by its long name cannot be found.

   996     */

   997 	virtual void GetShortNameL(const TDesC& aLongName,TDes& aShortName) = 0;

   998 

   999 

  1000     /**

  1001     Gets the long name of the file or directory associated with

  1002     the given short name.

  1003 

  1004     This function is used in circumstances where a file system mangles

  1005     Symbian OS natural names in order to be able to store them on

  1006     a file system that is not entirely compatible. 

  1007 

  1008     The function should leave with a suitable error code if it cannot complete

  1009     successfully for any reason.

  1010 

  1011 	@param aShorName  A reference to a descriptor containing the short name

  1012 	                  of the entry.

  1013 

  1014     @param aLongName  On return, a reference to a descriptor containing

  1015                       the long name of the entry.

  1016 

  1017     @leave KErrNotFound The entry specified by its short name cannot be found.

  1018     */

  1019 	virtual void GetLongNameL(const TDesC& aShorName,TDes& aLongName) = 0;

  1020 

  1021 

  1022     /**

  1023     Reads a specified section of the file, regardless of the file's lock state.

  1024 

  1025     The function should leave with a suitable error code if it cannot complete

  1026     successfully for any reason.

  1027     

  1028     @param aName   A reference to a descriptor containing the full name of

  1029                    the file to be read from

  1030     @param aPos    The byte position to start reading from.

  1031     @param aTrg    A pointer to the buffer into which data is to be read.

  1032     @param aLength The length of data to be read, in bytes.

  1033     @param aMessage

  1034 

  1035 	@leave KErrEof aPos is past the end of the file.

  1036     */

  1037 	virtual void ReadSectionL(const TDesC& aName,TInt aPos,TAny* aTrg,TInt aLength,const RMessagePtr2& aMessage)=0;

  1038 

  1039 

  1040     /**

  1041     Checks the integrity of the file system on the volume and returns an appropriate error value. 

  1042     The default implementation must be overridden by a derived class.

  1043     

  1044     @return KErrNone if the file system is stable; otherwise one of the other system wide error codes.

  1045             The default implementation returns KErrNotSupported.

  1046     */

  1047     virtual TInt CheckDisk() {return(KErrNotSupported);}

  1048     

  1049     /**

  1050     The same as original CheckDisk(), but with some parameters.

  1051     @prototype

  1052     */

  1053     virtual TInt CheckDisk(TInt aOperation, TAny* aParam1=NULL, TAny* aParam2=NULL);

  1054 

  1055 	

  1056 	/**

  1057     Scans through and corrects errors found in the volume.

  1058 

  1059     The default implementation must be overridden by a derived class.

  1060     

  1061     @return KErrNone if no errors are found or all errors are corrected; otherwise one of the other system wide error codes.

  1062             The default implementation returns KErrNotSupported.

  1063     */

  1064 	virtual TInt ScanDrive() {return(KErrNotSupported);}

  1065 

  1066     /**

  1067     The same as original ScanDrive(), but with some parameters.

  1068     @prototype

  1069     */

  1070     virtual TInt ScanDrive(TInt aOperation, TAny* aParam1=NULL, TAny* aParam2=NULL);

  1071     

  1072     IMPORT_C virtual void IsFileInRom(const TDesC& aFileName,TUint8*& aFileStart);

  1073 	

  1074 	

  1075 	/**

  1076         Low-level control IO

  1077     */

  1078 	virtual TInt ControlIO( const RMessagePtr2& /*aMessage*/,TInt /*aCommand*/,TAny* /*aParam1*/,TAny* /*aParam2*/)  {return(KErrNotSupported);}

  1079 

  1080 

  1081 	/**

  1082 	Locks a media which supports password protection and replaces

  1083 	the old password with a new one. 

  1084 

  1085     If aStore is set to ETrue, then the new password should be saved to

  1086     the password store file, KMediaPWrdFile, using the exported file server

  1087     function WriteToDisk(). 

  1088 

  1089     The password file is used to initialise the password store on boot up,

  1090     so the user does not need to be prompted for the password again if

  1091     it is saved here.

  1092 

  1093     The default implementation must be overridden in a derived class.

  1094 

  1095     @param aOld   A reference to the old password.

  1096     @param aNew   A reference to the new password.

  1097     @param aStore ETrue if the new password is to be saved to 

  1098                   the password file store; EFalse if not.

  1099 

  1100     @return KErrNone if successful; otherwise another of the system wide

  1101             error codes. The default implementation returns KErrNotSupported.

  1102     */

  1103 	virtual TInt Lock(TMediaPassword& /*aOld*/,TMediaPassword& /*aNew*/,TBool /*aStore*/) {return(KErrNotSupported);}

  1104 

  1105 

  1106 	/**

  1107 	Unlocks a media which supports password protection.

  1108 

  1109     If aStore is set to ETrue then the password should be saved to

  1110     the password store file specified by KMediaPWrdFile using the exported file

  1111     server function WriteToDisk().

  1112 

  1113     The password file is used to initialise the password store on boot up,

  1114     so the user does not need to be prompted for the password again if

  1115     it is saved here.

  1116 

  1117     The default implementation must be overridden in a derived class.

  1118 

  1119     @param aPassword A reference to the password.

  1120     @param aStore    ETrue if the password is to be saved to

  1121                      the password store file; EFalse otherwise.

  1122                      

  1123     @return KErrNone if successful; otherwise another of the system wide

  1124             error codes. The default implementation returns KErrNotSupported.                     

  1125     */

  1126 	virtual TInt Unlock(TMediaPassword& /*aPassword*/,TBool /*aStore*/) {return(KErrNotSupported);}

  1127 

  1128 

  1129 	/**

  1130 	Clears a password from a media that supports write protection. 

  1131 

  1132     The default implementation must be overridden in a derived class.

  1133 

  1134     @param aPassword A reference to the password to be cleared.

  1135