Convert Kernelhwsrv package from SFL to EPL
kernel\eka\compsupp is subject to the ARM EABI LICENSE
userlibandfileserver\fatfilenameconversionplugins\unicodeTables is subject to the Unicode license
kernel\eka\kernel\zlib is subject to the zlib license
// Copyright (c) 2003-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://#include "sc_std.h"const TInt KMajorVersionNumber=1;const TInt KMinorVersionNumber=1;_LIT(KRofsName,"Rofs");#ifdef __WINS___LIT(KRomName,"Win32");#else_LIT(KRomName,"Rom");#endif_LIT(KCompositeName,"Composite");static void Fault(TCompFault aFault)//// Report a fault in the composite file system.// { User::Panic(_L("COMPFILESYS"),aFault); }CCompFileSystem::CCompFileSystem() { __PRINT1(_L("CCompFileSystem()[0x%x]"), this); }CCompFileSystem::~CCompFileSystem() { __PRINT1(_L("~CCompFileSystem()[0x%x]"),this); if (iMount) { iMount->NullCompFileSystem(); } }TInt CCompFileSystem::Install()//// Install the file system// { __PRINT1(_L("CCompFileSystem::Install()[0x%x]"), this); iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KF32BuildVersionNumber); return(SetName(&KCompositeName)); }CMountCB* CCompFileSystem::NewMountL() const//// Create a new mount control block// { __PRINT1(_L("CCompFileSystem::NewMountL()[0x%x]"), this); // Composite FS is a singleton, and can only have one mount. // If it already exists, just return the existin one. if (iMount == NULL) { ((CCompFileSystem*)this)->iMount = new(ELeave) CCompMountCB((CCompFileSystem *)this); TRAPD(err,iMount->NewRomMountL()); if(err!=KErrNone) { iMount->Close(); User::Leave(err); } } __PRINT1(_L(" created CCompMountCB:0x%x"),iMount); return (iMount); }CFileCB* CCompFileSystem::NewFileL() const//// Create a new file// { __PRINT(_L("CCompFileSystem::NewFileL()")); CFileCB* pFile=new(ELeave) CCompFileCB; __PRINT1(_L("file at 0x%x"),pFile); return(pFile); }CDirCB* CCompFileSystem::NewDirL() const//// create a new directory lister// { __PRINT(_L("CCompFileSystem::NewDirL()")); CCompDirCB* pDir=new (ELeave) CCompDirCB; CleanupStack::PushL(pDir); TInt count = iMount->iMounts.Count(); TInt r=KErrNone; for(TInt idx=0; idx<count; idx++) { TRAPD(err, r=pDir->iDirs.Append(iMount->iMounts[idx].iFs->NewDirL())); if(err!= KErrNone || r != KErrNone) { pDir->Close(); User::Leave(err == KErrNone ? r : err); } } CleanupStack::Pop(pDir); __PRINT1(_L("dir at 0x%x"),pDir); return(pDir); }CFormatCB* CCompFileSystem::NewFormatL() const//// Create a new media formatter// { User::Leave(KErrAccessDenied); return(NULL); }void CCompFileSystem::DriveInfo(TDriveInfo& anInfo,TInt /*aDriveNumber*/) const//// Return drive info// { __PRINT(_L("CCompFileSystem::DriveInfo()")); anInfo.iMediaAtt=KMediaAttWriteProtected; anInfo.iDriveAtt=KDriveAttRom|KDriveAttInternal; anInfo.iType=EMediaRom; }TInt CCompFileSystem::DefaultPath(TDes& /*aPath*/) const//// Return the initial default path.// { Fault(ECompFsDefaultPath); return(KErrNone); }CFileSystem* CCompFileSystem::NewL()////// { __PRINT(_L("CCompFileSystem::NewL()")); CCompFileSystem* pFs = new(ELeave) CCompFileSystem; __PRINT1(_L("CompFs=0x%x"),pFs); return (pFs); }CCompMountCB::~CCompMountCB()////// { __PRINT1(_L("~CCompMountCB() this=0x%x"),this); for(TInt mount=iMounts.Count(); mount--;) iMounts[mount].iMount->Close(); iMounts.Close(); if (iFileSystem) { iFileSystem->NullMount(); } }void CCompMountCB::NewRomMountL()//// Creates a new ROM mount, and adds it to the list.//{ CFileSystem* romFs= GetFileSystem(KRomName); if(!romFs) { User::Leave(KErrNotFound); } CMountCB* romMount = romFs->NewMountL(); User::LeaveIfError(iMounts.Append(TCompMount(romFs,romMount)));}void CCompMountCB::MountL(TBool aForceMount)//// Mount a media. Only allowed to leave with KErrNoMemory,KErrNotReady,KErrCorrupt,KErrUnknown.//// { __PRINT(_L("CCompMountCB::MountL()")); // First mount rom RomMount()->SetDrive(&Drive()); RomMount()->MountL(aForceMount); // Mounts count starts at 1, as ROMFS starts in slot one. // If its still 1 on mount, then no mounts have been added. // To maintain compatibility with the previous version of this API, // (where you couldn't specifically add mounts) in this case we mount // ROFS by default. // (There would be little point mounting it with only one FS) if (iMounts.Count()==1) { CFileSystem* rofsFs = GetFileSystem(KRofsName); if(!rofsFs) User::Leave(KErrUnknown); AddFsToCompositeMount(rofsFs); } SetVolumeName(_L("RomDrive").AllocL()); // combine sizes for(TInt mount=iMounts.Count(); mount--;) iSize+= iMounts[mount].iMount->Size(); // no need to update iUniqueID since 0 in both rom and rofs } TInt CCompMountCB::GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput) { // aInterfaceId : If EAddFsToCompositeMount, method mounts a media and adds to CompFS. // : Local drive mapping for this mount's drive (CompFS's) // should be alterd to indicate the local drive to be added. // aIntput : CFileSystem* for the mount to be added. // aInterFace : Unused. switch(aInterfaceId) { case CMountCB::EFileAccessor: ((CMountCB::MFileAccessor*&) aInterface) = this; return KErrNone; case EAddFsToCompositeMount: return(AddFsToCompositeMount((CFileSystem*) aInput)); case CMountCB::ELocalBufferSupport: { CCompFileCB* file = (CCompFileCB*) aInput; return file?file->TrueFile()->Mount().LocalBufferSupport():KErrNone; } default: return (CMountCB::GetInterface(aInterfaceId,aInterface,aInput)); } }/** Mounts a media with the provided filesystem and adds to the composite mount. Local drive mapping for this mount's drive (CompFS's) should be altered to indicate the local drive to be added.*/TInt CCompMountCB::AddFsToCompositeMount(CFileSystem* aFileSystem) { __PRINT1(_L("CCompMountCB::AddFsToCompositeMount(0x%x)"), aFileSystem); CMountCB* newMount=NULL; TRAPD(err,newMount = aFileSystem->NewMountL()); if (err==KErrNone) { newMount->InitL(Drive(), aFileSystem); TRAP(err,newMount->MountL(EFalse)); if (err==KErrNone) { err = iMounts.Append(TCompMount(aFileSystem,newMount)); if (err!=KErrNone) return err; TInt r = newMount->AddToCompositeMount(iMounts.Count()-1); if(r == KErrNotSupported) r = KErrNone; return r; } } return err; }TInt CCompMountCB::ReMount()//// Try and remount this media.// { return(0); }void CCompMountCB::Dismounted()//// Dummy implementation of pure virtual function// {}void CCompMountCB::VolumeL(TVolumeInfo& aVolume) const////// Return the volume info.// { __PRINT(_L("CCompMountCB::VolumeL()")); aVolume.iFree=0; }void CCompMountCB::SetVolumeL(TDes& /*aName*/)////// Set the volume label.// { User::Leave(KErrAccessDenied); }void CCompMountCB::MkDirL(const TDesC& /*aName*/)//// Make a directory.// { User::Leave(KErrAccessDenied); }void CCompMountCB::RmDirL(const TDesC& /*aName*/)//// Remove a directory.// { User::Leave(KErrAccessDenied); }void CCompMountCB::DeleteL(const TDesC& /*aName*/)//// Delete a file.// { User::Leave(KErrAccessDenied); }void CCompMountCB::RenameL(const TDesC& /*anOldName*/,const TDesC& /*anNewName*/)//// Rename a file or directory.// { User::Leave(KErrAccessDenied); }void CCompMountCB::ReplaceL(const TDesC& /*anOldName*/,const TDesC& /*anNewName*/)//// Atomic replace.// { User::Leave(KErrAccessDenied); }void CCompMountCB::EntryL(const TDesC& aName,TEntry& anEntry) const//// Get entry details.// { __PRINT(_L("CCompMountCB::EntryL()")); TInt lesserErr = KErrNone; TInt err = KErrPathNotFound; TInt idx = iMounts.Count(); // Look for entry on each mount, until it finds one, starting at the top. while(idx--) { TRAP(err, iMounts[idx].iMount->EntryL(aName,anEntry)); // There will often be more then one error encountered when trying // to find an entry. If the entry is not found on any mount, but it // did find its path, it should not return a path error. // To ensure this, the last non-path related error must be remembered. if ((err != KErrPathNotFound) && (err != KErrPathHidden)) lesserErr=err; // It can stop looking for the entry when it either finds it // or discovers its hidden. (ie An error other then NotFound) if((err != KErrNotFound) && (err != KErrPathNotFound)) break; } if (err!=KErrNone) User::Leave(lesserErr?lesserErr:err); }void CCompMountCB::SetEntryL(const TDesC& /*aName*/,const TTime& /*aTime*/,TUint /*aSetAttMask*/,TUint /*aClearAttMask*/)//// Set entry details.// { User::Leave(KErrAccessDenied); }static TInt InitFile(CFileCB* aCompFile, CFileCB* aTrueFile,CMountCB* aRealMount,TUint8 aQueOffset)//// Initialise the true file object with values set in the composite file object// by TDrive// { TRAPD(r,aTrueFile->InitL(&aCompFile->Drive(),&aCompFile->Drive(),aCompFile->FileName().Des().AllocL() ) ); if(r!=KErrNone) return(r); aTrueFile->SetMount(aRealMount); aTrueFile->SetShare(aCompFile->Share()); r=aTrueFile->Mount().Open(); if(r==KErrNone) { // destructor for CFileCB only calls close on the mount if iMountLink set TDblQue<CFileCB>* pQue=(TDblQue<CFileCB>*)((TUint8*)aRealMount+aQueOffset); pQue->AddLast(*aTrueFile); } return(r); }void CCompMountCB::FileOpenL(const TDesC& aName,TUint aMode,TFileOpen anOpen,CFileCB* aFile)//// Open a file on the current mount.// { __PRINT1(_L("CCompMountCB::FileOpenL() %S"), &aName); TInt err = KErrPathNotFound; TInt lesserErr = KErrNone; CFileCB* pTrueFile = NULL; TInt idx = iMounts.Count(); // Look for file on each mount, until it finds one, starting at the top. while(idx--) { CMountCB* mount = iMounts[idx].iMount; pTrueFile = iMounts[idx].iFs->NewFileL(); TUint8 offset=(TUint8)(((TUint8*)&iMountQ-(TUint8*)this)); err = InitFile(aFile,pTrueFile,mount,offset); if(err == KErrNone) TRAP(err, mount->FileOpenL(aName,aMode,anOpen,pTrueFile)); __PRINT2(_L("opening file on mount %d [err=%d]"),idx,err); // If success, stop looking. if (err == KErrNone) break; // Not opened, so use Close() to cause file object to be deleted pTrueFile->Close(); // If the file is not found on any mount, but it did find its path, // it should not return a path error. // To ensure this, the last non-path related error must be remembered. if ((err != KErrPathNotFound) && (err != KErrPathHidden)) lesserErr=err; // Stop search if error other than file cannot be found. // A common error for this will be one of the hidden errors. // Note that for these, the lesser error calculation above // is still needed for these. if(err != KErrNotFound && err != KErrPathNotFound) break; } if (err!=KErrNone) User::Leave(lesserErr?lesserErr:err); aFile->SetSize(pTrueFile->Size()); aFile->SetAtt(pTrueFile->Att()); aFile->SetModified(pTrueFile->Modified()); ((CCompFileCB*)aFile)->SetTrueFile(pTrueFile); }TInt CCompMountCB::GetFileUniqueId(const TDesC& /* aName */, TInt64& aUniqueId) { // Get unique identifier for the file - for Composite File System will just return zero aUniqueId = MAKE_TINT64(0,0); return KErrNone; }TInt CCompMountCB::Spare3(TInt /*aVal*/, TAny* /*aPtr1*/, TAny* /*aPtr2*/) { return KErrNotSupported; }TInt CCompMountCB::Spare2(TInt /*aVal*/, TAny* /*aPtr1*/, TAny* /*aPtr2*/) { return KErrNotSupported; }TInt CCompMountCB::Spare1(TInt /*aVal*/, TAny* /*aPtr1*/, TAny* /*aPtr2*/) { return KErrNotSupported; }static void SetAtt(CDirCB* aDir,TUint8 aOffset,TUint aValue)////// { TUint8* pA=(TUint8*)aDir+aOffset; *(TUint*)pA=aValue; }static void SetUid(CDirCB* aDir,TUint8 aOffset,TUidType aValue)////// { TUint8* pU=(TUint8*)aDir+aOffset; *(TUidType*)pU=aValue; }TInt CCompDirCB::InitDir(CDirCB* aTrg,CMountCB* aMount)////// { TRAPD(r,aTrg->InitL(&Drive())); if(r!=KErrNone) return(r); aTrg->SetMount(aMount); r=aTrg->Mount().Open(); if(r!=KErrNone) { aTrg->SetMount(NULL); return(r); } SetAtt(aTrg,(TUint8)((TUint8*)&iAtt-(TUint8*)this),iAtt); SetUid(aTrg,(TUint8)((TUint8*)&iUidType-(TUint8*)this),iUidType); aTrg->Mount().DecLock(); return(KErrNone); }void CCompMountCB::DirOpenL(const TDesC& aName,CDirCB* aDir)//// Open a directory on the current mount.// { __PRINT(_L("CCompMountCB::DirOpenL()")); CCompDirCB* pD=(CCompDirCB*)aDir; pD->iMatch=aName.AllocL(); TInt err = KErrPathNotFound; TInt idx = iMounts.Count(); TBool anyFound = EFalse; pD->iCurrentDir = -1; while(idx) // Open dir on every mount it exists. { idx--; CDirCB* theDir = pD->iDirs[idx]; CMountCB* theMount = iMounts[idx].iMount; err = pD->InitDir(theDir, theMount); if(err == KErrNone) TRAP(err, theMount->DirOpenL(aName,theDir)); if(err == KErrNone) { if(!anyFound) { anyFound = ETrue; pD->iCurrentDir = idx; } continue; } pD->iDirs[idx]->Close(); // deletes object pD->iDirs[idx] = NULL; if (err == KErrPathHidden) { // Dont look for anythng below this hidden dir. break; } else if (err != KErrPathNotFound) { // An unexpected error - make it report this to caller! anyFound = EFalse; break; } } // If we broke before bottom, close the remaining while (idx--) { pD->iDirs[idx]->Close(); pD->iDirs[idx] = NULL; } // If we didnt find anythng at all, or some other error, leave. if(!anyFound) User::Leave(err); }void CCompMountCB::RawReadL(TInt64 /*aPos*/,TInt /*aLength*/,const TAny* /*aTrg*/,TInt /*anOffset*/,const RMessagePtr2& /*aMessage*/) const//// Read up to aLength data directly// { User::Leave(KErrAccessDenied); }void CCompMountCB::RawWriteL(TInt64 /*aPos*/,TInt /*aLength*/,const TAny* /*aSrc*/,TInt /*anOffset*/,const RMessagePtr2& /*aMessage*/)//// Write aLength data// { User::Leave(KErrAccessDenied); }void CCompMountCB::GetShortNameL(const TDesC& /*aLongName*/,TDes& /*aShortName*/)//// Return the short name associated with aLongName// Assumes all rom names are 8.3// { User::Leave(KErrNotSupported); }void CCompMountCB::GetLongNameL(const TDesC& /*aShortName*/,TDes& /*aLongName*/)//// Return the short name associated with aLongName// Assumes all rom names are 8.3// { User::Leave(KErrNotSupported); } void CCompMountCB::IsFileInRom(const TDesC& aFileName,TUint8*& aFileStart)//// Return the address of the file if it is in rom// { __PRINT(_L("CCompMountCB::IsFileInRom()")); TEntry entry; aFileStart=NULL; TInt idx = iMounts.Count(); while(idx--) { TRAPD(r,iMounts[idx].iMount->EntryL(aFileName,entry)); if(r==KErrNone) { // File exists on mount, check whether it is rom-based iMounts[idx].iMount->IsFileInRom(aFileName,aFileStart); break; } else if(r != KErrNotFound && r != KErrPathNotFound) { break; } } }void CCompMountCB::ReadSectionL(const TDesC& aName,TInt aPos,TAny* aTrg,TInt aLength,const RMessagePtr2& aMessage)//// Starting from aPos, read aLength bytes of a file into a Trg, // regardless of lock state// { __PRINT(_L("CCompMountCB::ReadSectionL()")); TInt lesserErr = KErrNone; TInt err = KErrPathNotFound; TInt idx = iMounts.Count(); // Look for file on each mount, until it finds one, starting at the top. while(idx--) { TRAP(err, iMounts[idx].iMount->ReadSectionL(aName,aPos,aTrg,aLength,aMessage)); // If the file is not found on any mount, but it did find its path, // it should not return a path error. // To ensure this, the last non-path related error must be remembered. if ((err != KErrPathNotFound) && (err != KErrPathHidden)) lesserErr=err; // Break if file was found, it was hidden, or some unexpected error // (ie break if file or pathe not found) // Note: If hidden, lesserErr calulation above still needed. if ((err != KErrNotFound) && (err != KErrPathNotFound)) break; } if (err!=KErrNone) User::Leave(lesserErr?lesserErr:err); }CCompFileCB::CCompFileCB() {}CCompFileCB::~CCompFileCB() { __PRINT1(_L("~CCompFileCB()[0x%x]"),this); if(TrueFile()) TrueFile()->Close(); }void CCompFileCB::RenameL(const TDesC& /*aNewName*/)//// Rename the file.// { User::Leave(KErrAccessDenied); }void CCompFileCB::ReadL(TInt aPos,TInt& aLength,const TAny* aDes,const RMessagePtr2& aMessage)//// Read from the file.// { __PRINT(_L("CCompFileCB::ReadL()")); TrueFile()->ReadL(aPos,aLength,aDes,aMessage); }void CCompFileCB::WriteL(TInt /*aPos*/,TInt& /*aLength*/,const TAny* /*aDes*/,const RMessagePtr2& /*aMessage*/)//// Write to the file.// { User::Leave(KErrAccessDenied); }TInt CCompFileCB::Address(TInt& aPos) const//// Return address of the file at aPos// { __PRINT(_L("CCompFileCB::Address()")); return(TrueFile()->Address(aPos)); }void CCompFileCB::SetSizeL(TInt /*aSize*/)//// Set the file size.// { User::Leave(KErrAccessDenied); }void CCompFileCB::SetEntryL(const TTime& /*aTime*/,TUint /*aSetAttMask*/,TUint /*aClearAttMask*/)//// Set the entry's attributes and modified time.// { User::Leave(KErrAccessDenied); }void CCompFileCB::FlushDataL()//// Commit any buffered date to the media.// { User::Leave(KErrAccessDenied); }void CCompFileCB::FlushAllL()//// Commit any buffered date to the media.// { User::Leave(KErrAccessDenied); }TInt CCompFileCB::GetInterface(TInt aInterfaceId,TAny*& aInterface,TAny* aInput) { if (TrueFile()) return TrueFile()->GetInterface(aInterfaceId, aInterface, aInput); else return KErrNotSupported; }CCompDirCB::CCompDirCB()////// {}CCompDirCB::~CCompDirCB()////// { __PRINT1(_L("~CCompDirCB() [0x%x]"),this); for(TInt dir=iDirs.Count(); dir--;) { if (iDirs[dir]) iDirs[dir]->Close(); } iDirs.Close(); delete iMatch; }void CCompDirCB::ReadL(TEntry& anEntry)//// Reads the next directory entry.// { __PRINT(_L("CCompDirCB::ReadL()")); if(Pending()) { CDirCB* pDir = iDirs[iCurrentDir]; pDir->SetPending(ETrue); TRAPD(r,pDir->ReadL(anEntry)); __ASSERT_ALWAYS(r!=KErrEof,Fault(ECompDirReadPending)); SetPending(pDir->Pending()); User::LeaveIfError(r); return; } if(iCurrentDir < 0) User::Leave(KErrEof); TFileName match(*iMatch); TInt namePos=match.LocateReverse(KPathDelimiter)+1; // There is always a path delimiter TPtrC dirName=match.Left(namePos); TFileName filename; TInt err; do { CDirCB* theDir = iDirs[iCurrentDir]; if(theDir) { FOREVER // loop until we can read no more (EOF or other err) // If non-duplicate entry found, it returns. { TRAP(err, theDir->ReadL(anEntry)); if(err != KErrNone) break; __PRINT2(_L("CCompDirCB:: ReadL got = '%S' from dir %d"),&anEntry.iName, iCurrentDir); filename=dirName; filename+=anEntry.iName; if (!IsDuplicate(filename)) return; } // We have either reached EOF for CurrentDir or encounted an error. __PRINT1(_L("CCompDirCB:: ReadL err = %d"),err); if(err != KErrEof) { User::Leave(err); } } } while (iCurrentDir--); User::Leave(KErrEof); }TBool CCompDirCB::IsDuplicate(TFileName& aFilename)//// Is used by ReadL to determine if a file name read is a duplicate of// a filename already read bit it.// { RArray<TCompMount> &mounts = ((CCompMountCB*)&Mount())->iMounts; TInt count = mounts.Count(); TEntry tmpEntry; __PRINT1(_L("theMount->iMounts.Count() = %d"),count); for (TInt idx = iCurrentDir+1; idx < count; idx++) { TRAPD(r, mounts[idx].iMount->EntryL(aFilename,tmpEntry)); if ((r == KErrNone) || (r == KErrHidden) || (r == KErrPathHidden)) { __PRINT1(_L("CCompDirCB:: Duplicate (r=%d)"),r); return (ETrue); } } return (EFalse); }void CCompDirCB::StoreLongEntryNameL(const TDesC& aName)//// Stores the Long Entry Name// { __ASSERT_ALWAYS(iCurrentDir >= 0 && iDirs[iCurrentDir] != NULL, Fault(ECompDirStoreLongEntryNameL)); iDirs[iCurrentDir]->StoreLongEntryNameL(aName); }extern "C" {EXPORT_C CFileSystem* CreateFileSystem()//// Create a new file system// { return(CCompFileSystem::NewL()); }}