--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/userlibandfileserver/fileserver/automounter/automounter.cpp Thu Dec 17 09:24:54 2009 +0200
@@ -0,0 +1,843 @@
+// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+
+/**
+@file
+@internalTechnology
+*/
+
+#include <e32cmn.h>
+#include <f32ver.h>
+#include <u32std.h>
+#include <f32file.h>
+
+
+
+#include "filesystem_automounter.h"
+#include "automounter.h"
+
+
+//-----------------------------------------------------------------------------
+
+void Fault(TFault aFault)
+ {
+ _LIT(KPanicName, "AutoMounter_fsy");
+ User::Panic(KPanicName, aFault);
+ }
+
+
+//-----------------------------------------------------------------------------
+
+/**
+ Factory function, Create a new object of this file system
+*/
+extern "C"
+{
+EXPORT_C CFileSystem* CreateFileSystem()
+ {
+ return CAutoMounterFileSystem::New();
+ }
+}
+
+
+//#######################################################################################################################################
+//# CAutoMounterFileSystem class implementation
+//#######################################################################################################################################
+
+/**
+ Factory method
+*/
+CAutoMounterFileSystem* CAutoMounterFileSystem::New()
+ {
+ CAutoMounterFileSystem* pThis = new CAutoMounterFileSystem();
+ return pThis;
+ }
+
+
+CAutoMounterFileSystem::CAutoMounterFileSystem()
+ {
+ __PRINT1(_L("#<<- CAutoMounterFileSystem::CAutoMounterFileSystem() [0x%x]"), this);
+
+ SetState(EInvalid);
+ }
+
+CAutoMounterFileSystem::~CAutoMounterFileSystem()
+ {
+ __PRINT1(_L("#<<- CAutoMounterFileSystem::~CAutoMounterFileSystem() [0x%x]"), this);
+ }
+
+//-----------------------------------------------------------------------------
+
+/**
+ Install iand initialise file system.
+*/
+TInt CAutoMounterFileSystem::Install()
+ {
+
+ SetState(ENotInitialised);
+
+ __PRINT1(_L("#<<- CAutoMounterFileSystem::Install() [0x%x]"), this);
+
+ iVersion=TVersion(KF32MajorVersionNumber,KF32MinorVersionNumber,KF32BuildVersionNumber);
+
+ InitialiseFileSystem();
+
+ return SetName(&KFileSystemName_AutoMounter);
+ }
+
+
+//-----------------------------------------------------------------------------
+/**
+ Create a new mount control block.
+ This method migh be called by the file server in some unusual cases, when the actual mount is needed only temporarily to get access to the
+ corresponding media driver. E.g. TDrive::ForceRemountDrive()
+ Produce the _default_ file system mount
+*/
+CMountCB* CAutoMounterFileSystem::NewMountL() const
+ {
+ __PRINT1(_L("#<<- CAutoMounterFileSystem::NewMountL() [0x%x]"), this);
+ ASSERT(State() == EInitialised);
+
+ __PRINT1(_L("#<<- producing the _default_ filesystem:%S"), &iFSNames[KDefaultFSNo]);
+
+ CFileSystem* pFS = GetChildFileSystem(KDefaultFSNo);
+ ASSERT(pFS);
+
+ return pFS->NewMountL();
+ }
+
+//-----------------------------------------------------------------------------
+/**
+ Create a new file.
+*/
+CFileCB* CAutoMounterFileSystem::NewFileL() const
+ {
+ __PRINT1(_L("#<<- CAutoMounterFileSystem::NewFileL() [0x%x]"), this);
+ Fault(EMustNotBeCalled);
+ return NULL;
+ }
+
+//-----------------------------------------------------------------------------
+/**
+ Create a new directory object
+*/
+CDirCB* CAutoMounterFileSystem::NewDirL() const
+ {
+ __PRINT1(_L("#<<- CAutoMounterFileSystem::NewDirL() [0x%x]"), this);
+ Fault(EMustNotBeCalled);
+ return NULL;
+ }
+
+//-----------------------------------------------------------------------------
+/**
+ Create a new media formatter
+*/
+CFormatCB* CAutoMounterFileSystem::NewFormatL() const
+ {
+ __PRINT1(_L("#<<- CAutoMounterFileSystem::NewFormatL() [0x%x]"), this);
+ Fault(EMustNotBeCalled);
+ return NULL;
+ }
+
+//-----------------------------------------------------------------------------
+/**
+ Return the drive info
+*/
+void CAutoMounterFileSystem::DriveInfo(TDriveInfo& anInfo,TInt aDriveNumber) const
+ {
+ //!!!!!!!!!!!! This method shall be made the same as FAT, exFAT etc.
+ //!! General idea: make all this code common for all filesystems and put it into the file server
+ //!! The problem: need to have another exported method. Actually, the generic code can be placed to CFileSystem::DriveInfo()
+ //!! despite it a pure virtual.
+
+ __PRINT1(_L("#<<- CAutoMounterFileSystem::DriveInfo() [0x%x]"), this);
+
+ if(!IsValidLocalDriveMapping(aDriveNumber))
+ return;
+
+ TLocalDriveCapsV2Buf localDriveCaps;
+
+ TInt r = KErrNone;
+
+ // is the drive local?
+ if (!IsProxyDrive(aDriveNumber))
+ {
+ // if not valid local drive, use default values in localDriveCaps
+ // if valid local drive and not locked, use TBusLocalDrive::Caps() values
+ // if valid drive and locked, hard-code attributes
+ r = GetLocalDrive(aDriveNumber).Caps(localDriveCaps);
+ }
+ else // this need to be made a bit nicer
+ {
+ CExtProxyDrive* pD = GetProxyDrive(aDriveNumber);
+ if(pD)
+ r = pD->Caps(localDriveCaps);
+ else
+ r = KErrNotReady; // What should the behaviour really be here?
+ }
+
+ if (r != KErrLocked )
+ {
+ anInfo.iMediaAtt=localDriveCaps().iMediaAtt;
+ }
+ else
+ {
+ anInfo.iMediaAtt = KMediaAttLocked | KMediaAttLockable | KMediaAttHasPassword;
+ }
+
+ anInfo.iType=localDriveCaps().iType;
+ anInfo.iDriveAtt=localDriveCaps().iDriveAtt;
+ }
+
+//-----------------------------------------------------------------------------
+
+#ifdef _DEBUG
+/**
+ Called by File Server before deleting File System object.
+*/
+TInt CAutoMounterFileSystem::Remove()
+ {
+ __PRINT1(_L("#<<- CAutoMounterFileSystem::Remove() [0x%x]"), this);
+ return CFileSystem::Remove();
+ }
+
+//-----------------------------------------------------------------------------
+
+/**
+*/
+TBool CAutoMounterFileSystem::QueryVersionSupported(const TVersion& aVer) const
+ {
+ __PRINT1(_L("#<<- CAutoMounterFileSystem::QueryVersionSupported() [0x%x]"), this);
+ return CFileSystem::QueryVersionSupported(aVer);
+ }
+
+#endif
+
+//-----------------------------------------------------------------------------
+
+/**
+ Find out if drive extensions are supported. In order to have consistent behaviour, _all_ child
+ file systems shall behave the same way.
+
+ @return ETrue if drive extensions are supported.
+*/
+TBool CAutoMounterFileSystem::IsExtensionSupported() const
+ {
+ __PRINT1(_L("#<<- CAutoMounterFileSystem::IsExtensionSupported() [0x%x]"), this);
+
+ ASSERT(State() == EInitialised && iFSNames.Count() > 1);
+
+
+ //-- in debug mode check file systems compatibility: ALL childs must support this feature
+ for(TUint i=0; i<iFSNames.Count(); ++i)
+ {
+ if( !(GetChildFileSystem(i)->IsExtensionSupported()))
+ {
+ DBG_STATEMENT(Fault(EIncompatibleFileSystems));
+ __PRINT(_L("#<<- ::IsExtensionSupported(): Incompatible file sytems!"));
+ return EFalse;
+ }
+ }
+
+
+ return ETrue;
+ }
+
+//-----------------------------------------------------------------------------
+
+/**
+ Return the initial default path.
+*/
+TInt CAutoMounterFileSystem::DefaultPath(TDes& aPath) const
+ {
+ __PRINT1(_L("#<<- CAutoMounterFileSystem::DefaultPath() [0x%x]"), this);
+
+ aPath=_L("?:\\");
+ aPath[0] = (TUint8) RFs::GetSystemDriveChar();
+ return KErrNone;
+ }
+
+
+//-----------------------------------------------------------------------------
+
+/**
+ Additional interfaces support.
+*/
+TInt CAutoMounterFileSystem::GetInterface(TInt aInterfaceId, TAny*& aInterface, TAny* aInput)
+ {
+
+ __PRINT2(_L("#<<- CAutoMounterFileSystem::GetInterface(id:%d) [0x%x]"), aInterfaceId, this);
+
+ switch(aInterfaceId)
+ {
+ //-- It is this filesystem private interface.
+ case EExtendedFunctionality:
+ aInterface = (CFileSystem::MFileSystemExtInterface*)this;
+ return KErrNone;
+
+ //-- a special case for child filesystems.
+ //-- ALL of them must respond to this interface query exactly the same way. I.e. It is impossible
+ //-- to have some of the child FS supporting it and some not.
+ case EProxyDriveSupport:
+ return DoProcessProxyDriveSupport();
+
+
+ default:
+ //-- This is the request to other (child file system) from the file server
+ //-- Actually, this part must never be called. File Server shall query the file system interfaces _after_ mounting the concrete FS
+ //-- calling TDrive::iCurrentMount->FileSystem().GetInterface()
+ ASSERT(0);
+ return CFileSystem::GetInterface(aInterfaceId, aInterface, aInput);
+
+ }
+ }
+
+//-----------------------------------------------------------------------------
+/**
+ @return Boolean exclusive OR between a1 and a2
+*/
+TBool BoolXOR(TBool a1, TBool a2)
+ {
+ if(!a1 && !a2)
+ return EFalse;
+ else if(a1 && a2)
+ return EFalse;
+ else
+ return ETrue;
+ }
+
+//-----------------------------------------------------------------------------
+
+/**
+ Find out if _all_ child file systems support the proxy drive. All childs shall behave exactly the same way.
+ @return KErrNone if all child file systems support proxy drives, or KErrNotSupported if all of them do not.
+*/
+TInt CAutoMounterFileSystem::DoProcessProxyDriveSupport()
+ {
+ __PRINT1(_L("#<<- CAutoMounterFileSystem::DoProcessProxyDriveSupport[0x%x]"), this);
+ ASSERT(State() == EInitialised);
+
+ const TUint cnt = iFSNames.Count();
+ ASSERT(cnt > 1);
+
+
+ //-- query the default filesystem #0
+ const TBool bRes = GetChildFileSystem(KDefaultFSNo)->IsProxyDriveSupported();
+
+ //-- query the rest of child filesystems
+ for(TUint i=1; i<cnt; ++i)
+ {
+ const TBool b = GetChildFileSystem(i)->IsProxyDriveSupported();
+
+ if(BoolXOR(b, bRes))
+ Fault(EIncompatibleFileSystems);
+ }
+
+
+ return bRes ? KErrNone : KErrNotSupported;
+ }
+
+//-----------------------------------------------------------------------------
+/**
+ Get the child file system name by its index (enumerator).
+
+ @param aFsNumber index of the child FS 0...KMaxTInt
+ @param aFsName on success the child file system name will be placed into this buffer
+
+ @return KErrNone if there is a child FS name with index 'aFsNumber' (child FS 'aFsNumber' is supported by automounter)
+ KErrNotFound if child FS 'aFsNumber' is not supported
+*/
+TInt CAutoMounterFileSystem::GetSupportedFileSystemName(TInt aFsNumber, TDes& aFsName) const
+ {
+ __PRINT2(_L("#<<- CAutoMounterFileSystem::GetSupportedFileSystemName[0x%x](%d)"), this, aFsNumber);
+
+ if(aFsNumber == RFs::KRootFileSystem)
+ {//-- this is a name query for "root filesystem" or automounter
+ aFsName = Name(); //-- ourselves
+ return KErrNone;
+ }
+
+ //-- this is a query for one of the child filesystems
+ if((TUint)aFsNumber < iFSNames.Count())
+ {
+ aFsName = iFSNames[aFsNumber];
+ return KErrNone;
+ }
+
+
+ return KErrNotFound;
+ }
+
+
+//-----------------------------------------------------------------------------
+/**
+ This is the only factory method that can be called by file server for this file system.
+ In this method the automounter sequentially tries to mount every child and on success produces the corresponding CMountCB object.
+
+ @param apDrive pointer to the TDrive, child FS will need this to access media.
+ @param apFileSystem on return will contain the pointer to the CFileSystem that has produced the proped CMountCB if
+ one of the child file system has recognised the volume.
+ @param aForceMount if ETrue the appropriate child FS (designated by aFsNameHash) will be forcedly mounted on the volume. for volume formatting purposes.
+ @param aFsNameHash if !=0 specifies the file system name, see TVolFormatParam::CalcFSNameHash(). 0 means "file system name is not specified"
+
+ @return pointer to the constructed CMountCB by one of the child file systems (and pointer to this child FS in apFileSystem)
+ NULL if it was impossible to produce proper CMountCB object.
+
+*/
+CMountCB* CAutoMounterFileSystem::NewMountExL(TDrive* apDrive, CFileSystem** apFileSystem, TBool aForceMount, TUint32 aFsNameHash)
+ {
+ __PRINT4(_L("#<<- CAutoMounterFileSystem::NewMountExL[0x%x] drv:%d, ForceMount:%d, FSNameHash:0x%x"), this, apDrive->DriveNumber(), aForceMount, aFsNameHash);
+
+ ASSERT(State() == EInitialised && apDrive);
+
+ //-- This method is usually called from the appropriate drive thread; this file system is intended to be bound to
+ //-- removable drives. Having removable drive runnind in the main file server thread means that something is terribly wrongly configured.
+ if(apDrive->IsSynchronous())
+ Fault(EWrongDriveAttributes);
+
+ if(iFSNames.Count() < 2)
+ Fault(EWrongConfiguration);
+
+
+ //-- if aForceMount is true, this means that the TDrive tries mount the filesystem by force for formatting because normal mounting has failed before.
+ //-- in our case it means that the file system on the volume hadn't been recognised by any child FS.
+ //-- aFsNameHash shall designate the file system to be forcedly mounted. Depending on this the appropriat CMounCB object will be produced.
+ //-- if aFsNameHash is 0, i.e. not provided, this method will fail with KErrNotFound because it is impossible to select appropriat child FS.
+ if(aForceMount)
+ {
+ if(aFsNameHash == 0)
+ {//-- the file system to mount forcedly is not specified
+ __PRINT(_L("#<<- Unable to select appropriate child FS for formatting!"));
+ User::Leave(KErrNotFound);
+ }
+ else
+ {//-- try to find appropriate child FS by its name hash
+ CFileSystem *pFS = GetChildFileSysteByNameHash(aFsNameHash);
+ if(!pFS)
+ {
+ __PRINT(_L("#<<- no child FS found by its name hash!"));
+ ASSERT(0);
+ User::Leave(KErrNotFound);
+ }
+
+ CMountCB* pMount = pFS->NewMountL();
+ ASSERT(pMount);
+
+ *apFileSystem = pFS;
+ return pMount;
+ }
+ }//if(aForceMount)
+
+
+
+ //-- try instantiate a new CMountCB depending on the file system on the media
+
+ CMountCB* pMatchedMount;
+ TInt nRes = TryMountFilesystem(apDrive, &pMatchedMount, apFileSystem);
+
+ if(nRes == KErrNone)
+ {
+ ASSERT(pMatchedMount);
+ return pMatchedMount;
+ }
+
+
+
+ User::Leave(nRes);
+ return NULL;
+ }
+
+//-----------------------------------------------------------------------------
+/**
+ Initialise this file system. Reads and processes configuration, fills in file system names container, etc.
+*/
+void CAutoMounterFileSystem::InitialiseFileSystem()
+ {
+ __PRINT1(_L("#<<- CAutoMounterFileSystem::InitialiseFileSystem() [0x%x]"), this);
+
+ ASSERT(State() == ENotInitialised);
+
+ TInt nRes;
+
+
+ //-- 1. initialise the array of file system names. These names shall be listed in a config string.
+ //-- the config string is taken from estart.txt usually and its format is like this:
+ //-- section: [AutoMounter] and property "FSNames fat,exfat"
+ //-- in debug version a special text property can override the config string. This allows controlling automounter from
+ //-- the test environment.
+
+ TBuf8<0x100> buf(0);
+ TBuf<0x100> fsName;
+
+
+#ifdef _DEBUG
+ const TUid KSID_Test1={0x10210EB3}; //-- SID of the test that will define and set test property to control volume mounting
+ const TUint KPropKey = 0; //-- property key
+
+ //-- in debug mode the property will override the estart.txt config
+ if(RProperty::Get(KSID_Test1, KPropKey, buf) == KErrNone)
+ {
+ __PRINT(_L("#<<- reading config from the debug propery..."));
+ }
+ else
+#endif
+ {
+ __PRINT(_L("#<<- reading config from estart.txt..."));
+ _LIT8(KSection, "AutoMounter");
+ _LIT8(KProperty, "FSNames");
+
+ nRes = F32Properties::GetString(KSection, KProperty, buf);
+ if(!nRes)
+ Fault(EPluginInitialise);
+ }
+
+
+ fsName.Copy(buf);
+ __PRINT1(_L("#<<- config:'%S'"), &fsName);
+
+ //-- parse CSV config line and fill in the file system names array
+ const TChar chDelim = ','; //-- token delimiter, comma
+ buf.Trim();
+ TPtrC8 ptrCurrLine(buf);
+ for(TInt i=0; ;++i)
+ {
+ const TInt delimPos = ptrCurrLine.Locate(chDelim);
+ if(delimPos <= 0)
+ {
+ fsName.Copy(ptrCurrLine);
+ }
+ else
+ {
+ TPtrC8 temp(ptrCurrLine.Ptr(), delimPos);
+ fsName.Copy(temp);
+ }
+
+ fsName.Trim();
+ __PRINT2(_L("#<<- child FS[%d]: '%S'"), i, &fsName);
+
+
+ if(fsName.Length() <= 0)
+ Fault(EPluginInitialise);
+
+ //-- check if the FS name being appended is unique
+ for(TUint j=0; j<iFSNames.Count(); ++j)
+ {
+ if(iFSNames[j] == fsName)
+ {
+ Fault(EPluginInitialise);
+ }
+ }
+
+
+ nRes = iFSNames.Append(fsName);
+ ASSERT(nRes ==KErrNone);
+
+ if(delimPos <=0 )
+ break;
+
+ ptrCurrLine.Set(ptrCurrLine.Ptr()+delimPos+1, ptrCurrLine.Length()-delimPos-1);
+ }
+
+
+ SetState(EInitialised);
+
+ //-- 2. check that the file server has all filesystems we need instantiated and stored in a global container
+ TUint cnt = iFSNames.Count();
+ if(cnt < 2)
+ {
+ __PRINT(_L("#<<- ::InitialiseFileSystem(): too few File Systems bound!"));
+ Fault(EPluginInitialise);
+ }
+
+ while(cnt--)
+ {
+ GetChildFileSystem(cnt);
+ }
+
+
+ }
+
+
+
+//-----------------------------------------------------------------------------
+/**
+ Tries to find out if some of the child file systems can be mounted on the given volume.
+
+ @param apDrive pointer to the TDrive, child FS will need this to access media.
+ @param on return will contain the pointer to the CMountCB object if some of the childs has decided that it can be mounted.
+ @param apFS on return will contain the pointer to the CFileSystem that has produced the proped CMountCB if
+
+ @return KErrNone on success, otherwise standard error code.
+
+*/
+TInt CAutoMounterFileSystem::TryMountFilesystem(TDrive* apDrive, CMountCB** apMount, CFileSystem** apFS)
+ {
+ __PRINT1(_L("#<<- CAutoMounterFileSystem::TryMountFilesystem()[0x%x]"), this);
+
+ const TInt KNumFS = iFSNames.Count();
+
+ ASSERT(State() == EInitialised && (KNumFS >1));
+
+
+ *apMount = NULL;
+ *apFS = NULL;
+
+
+ TInt nRes;
+ TInt cntFS;
+ CMountCB* pMountCB = NULL;
+ CFileSystem* pMatchedFS = NULL;
+
+ for(cntFS=0; cntFS < KNumFS; ++cntFS)
+ {
+
+ __PRINT2(_L("#<<-@@ trying FS[%d]:%S"), cntFS, &iFSNames[cntFS]);
+
+ CFileSystem* pFS = GetChildFileSystem(cntFS); //-- Find current filesystem object in the FileServer's global container
+
+ //-- 2. create CMountCB instance and set it up
+ pMountCB = NULL;
+
+ TRAP(nRes, pMountCB = pFS->NewMountL());
+ if(nRes != KErrNone)
+ {
+ return KErrNoMemory;
+ }
+
+ ASSERT(pMountCB);
+ pMountCB->SetDrive(apDrive);
+
+
+ //-- 2.1 Firstly try using special CMountCB interface to find out if current FS can be mounted on this media
+ nRes = pMountCB->CheckFileSystemMountable();
+ if(nRes == KErrNotSupported)
+ {
+ //-- file system doesn't support this feature,
+ //-- 2.2 try to check the file system by mounting and dismounting later. It can result in some long activity, like FAT scanning etc.
+ TRAP(nRes, pMountCB->MountL(EFalse));
+ pMountCB->Dismounted(); //-- dismount the mountCB, it will be required in dismounted state anyway
+ }
+
+ //-- 2.3 analyse the result of mounting
+ if(nRes != KErrNone)
+ {
+ if(nRes == KErrLocked)
+ {//-- this is a special case; The media (SD card for example) is locked.
+ //-- Pretend that everything is OK and return CMountCB instance that is produced by the _default_ file system.
+ //-- locked media case will be handled by the file server later.
+ ASSERT(cntFS == KDefaultFSNo); //-- the default FS is tried first and must detect the locked media
+ pMatchedFS = pFS;
+ __PRINT(_L("#<<-@@ The media is LOCKED !"));
+ break;
+ }
+
+ //-- failed to mount the file system, most likey it is not recognised
+ pMountCB->Close(); //-- this is a self-destructing object!
+ pMountCB = NULL;
+ __PRINT(_L("#<<-@@ Mount FAILED !"));
+ }
+ else
+ {
+ //-- mounted OK, the file system is recognised
+ __PRINT(_L("#<<-@@ Mount OK!"));
+
+ pMatchedFS = pFS;
+ break;
+ }
+
+ }//for(cntFS=0; cntFS<KNumFS; ++cntFS)
+
+ if(cntFS >= KNumFS)
+ {//-- no one from the FS factories recognised the file system
+ __PRINT1(_L("#<<- ::TryMountFilesystem()[0x%x] No file system recognised!"), this);
+
+ SetName(&KFileSystemName_AutoMounter);
+ return KErrCorrupt;
+ }
+
+ ASSERT(pMountCB && pMatchedFS);
+ *apMount = pMountCB;
+ *apFS = pMatchedFS;
+
+ //-- set this FS name to the name of recognised FS. In this case the automounter "pretends" to be one of the child file systems on
+ //-- successful mounting. This behaviour was considered to be incorrect.
+ //TPtrC fsName = pMatchedFS->Name();
+ //SetName(&fsName);
+
+ return KErrNone;
+
+ }
+
+//-----------------------------------------------------------------------------
+/**
+ get the child file system object by the index in file child system names container
+
+ @param aIndex index in the iFSNames
+ @return pointer to the FS object if it is found, NULL otherwise
+*/
+CFileSystem* CAutoMounterFileSystem::GetChildFileSystem(TUint aIndex) const
+ {
+ ASSERT(State() == EInitialised && (iFSNames.Count() >1) && aIndex < iFSNames.Count());
+
+ const TDesC& fsName = iFSNames[aIndex]; //-- registered child file system name
+ CFileSystem* pFS = GetFileSystem(fsName); //-- Find filesystem object in the FileServer's global container
+
+ if(!pFS)
+ {
+ __PRINT1(_L("#<<- CAutoMounterFileSystem::GetChildFileSystem() FileServer doesn't have FS:%S Added!"), &fsName);
+ Fault(EFileSysNotAdded);
+ }
+
+ return pFS;
+ }
+
+//-----------------------------------------------------------------------------
+/**
+ Find the child file system object by the file system name name hash.
+ @param aFsNameHash FS name hash
+ @return pointer to the FS object if it is found, NULL otherwise
+*/
+CFileSystem* CAutoMounterFileSystem::GetChildFileSysteByNameHash(TUint32 aFsNameHash) const
+ {
+ ASSERT(State() == EInitialised && (iFSNames.Count() >1) && aFsNameHash);
+
+ for(TUint i=0; i<iFSNames.Count(); ++i)
+ {
+ if(aFsNameHash == iFSNames.GetStringHash(i))
+ {
+ const TDesC& fsName = iFSNames[i]; //-- registered child file system name
+ __PRINT2(_L("#<<- ::GetChildFileSysteByNameHash() found FsName:%S by hash:0x%x"), &fsName, aFsNameHash);
+ CFileSystem* pFS = GetFileSystem(fsName); //-- Find filesystem object in the FileServer's global container
+ ASSERT(pFS);
+ return pFS;
+ }
+
+ }
+
+ __PRINT1(_L("#<<- ::GetChildFileSysteByNameHash() No FS name found by hash:0x%x"), aFsNameHash);
+
+ return NULL;
+ }
+
+
+
+
+//#######################################################################################################################################
+//# XStringArray implementation
+//#######################################################################################################################################
+
+XStringArray::XStringArray()
+ {
+ }
+
+XStringArray::~XStringArray()
+ {
+ Reset();
+ iStrings.Close();
+ }
+
+//-----------------------------------------------------------------------------
+void XStringArray::Reset()
+ {
+ iStrings.ResetAndDestroy();
+ }
+
+//-----------------------------------------------------------------------------
+const TDesC& XStringArray::operator[](TUint aIndex) const
+ {
+ if(aIndex >= (TUint)iStrings.Count())
+ Panic(EIndexOutOfRange);
+
+ HBufC* des=iStrings[aIndex];
+ return *des;
+ }
+
+//-----------------------------------------------------------------------------
+/**
+ Append file system name to the container. The name is converted to upper case.
+ @param aString name descriptor.
+ @return standard error code
+*/
+TInt XStringArray::Append(const TDesC& aString)
+ {
+ HBufC* pBuf = aString.Alloc();
+ if(!pBuf)
+ return KErrNoMemory;
+
+ //-- string being appended shall be unique
+ for(TUint i=0; i<Count(); ++i)
+ {
+ if(operator[](i).CompareF(aString) == 0)
+ {
+ ASSERT(0);
+ return KErrNone;
+ }
+ }
+
+ pBuf->Des().UpperCase(); //-- convert the FS name to upper-case in order to correctly calculate hash later
+ return iStrings.Append(pBuf);
+ }
+
+
+//-----------------------------------------------------------------------------
+/**
+ Get child FS name hash by index in the names container.
+ @param aIndex name index in the container
+ @return file system name hash (crc32)
+*/
+TUint32 XStringArray::GetStringHash(TUint aIndex) const
+ {
+ const TDesC& des = operator[](aIndex);
+ return TVolFormatParam::CalcFSNameHash(des);
+ }
+
+
+
+void XStringArray::Panic(TPanicCode aPanicCode) const
+ {
+ _LIT(KPanicCat,"XStringArray");
+ User::Panic(KPanicCat, aPanicCode);
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+