--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/userlibandfileserver/fileserver/sfile/sf_svr.cpp Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,1367 @@
+// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// f32\sfile\sf_svr.cpp
+//
+//
+
+#include "sf_std.h"
+#include "sf_cache_man.h"
+#include "sf_file_cache.h"
+#include "sf_memory_man.h"
+
+TInt DoFsSubClose(CFsRequest* aRequest)
+//
+// Close a subsession.
+//
+ {
+ const TInt handle(aRequest->Message().Int3());
+
+ CFsObject* pO=SessionObjectFromHandle(handle,0,aRequest->Session());
+ if(!pO)
+ return KErrBadHandle;
+
+ aRequest->Session()->DecResourceCount();
+ aRequest->Session()->Handles().Remove(handle,ETrue);
+
+ // this request has also opened this object, so close it here before it
+ // gets to a plugin as a plugin may attempt to open the file/dir itself
+ aRequest->SetScratchValue64( MAKE_TUINT64(I64HIGH(aRequest->ScratchValue64()), 0));
+
+ return(KErrNone);
+ }
+
+
+TInt TFsSubClose::DoRequestL(CFsRequest* aRequest)
+//
+// Close a subsession.
+//
+ {
+
+ // Leave and then panic client with KErrBadHandle if necessary.
+ CFsObject* pO = SessionObjectFromHandle(aRequest->Message().Int3(),0,aRequest->Session());
+ if(!pO)
+ return KErrBadHandle;
+
+ if(aRequest->Message().Function() == EFsFileSubClose)
+ {
+ CFileShare* pShare = (CFileShare*) aRequest->ScratchValue();
+
+ // flush the file cache
+ CFileCache* fileCache = pShare->File().FileCache();
+ if (fileCache && fileCache->FlushDirty(aRequest) == CFsRequest::EReqActionBusy)
+ return CFsRequest::EReqActionBusy;
+
+ // if any write requests are being fair scheduled, wait for them to complete
+ if (pShare->RequestInProgress())
+ return CFsRequest::EReqActionBusy;
+ }
+
+ return DoFsSubClose(aRequest);
+ }
+
+TInt TFsSubClose::Initialise(CFsRequest* aRequest)
+//
+// Now moved to RequestAllocator::GetRequest
+//
+ {
+ TInt r = KErrNone;
+ // Closing a file share may require flushing of dirty data, so deal with this in the drive thread
+ // in TFsSubClose::DoRequestL(). For other objects (EFsFormatSubClose, EFsDirSubClose, EFsRawSubClose,
+ // FsPluginSubClose) we may complete the message here.
+ if(aRequest->FsFunction() == EFsFileSubClose)
+ {
+ CFileShare* pShare = (CFileShare*)
+ SessionObjectFromHandle(aRequest->Message().Int3(), FileShares->UniqueID(), aRequest->Session());
+
+ if(!pShare)
+ User::Leave(KErrBadHandle);
+
+ HBufC* pFileName = pShare->File().FileName().Alloc();
+ aRequest->SetScratchValue64( MAKE_TUINT64((TUint) pFileName, (TUint) pShare) );
+ TInt driveNumber = pShare->File().Drive().DriveNumber();
+ aRequest->SetDriveNumber(driveNumber);
+ }
+
+ // Define a completion routine so that we can see whether this request is cancelled -
+ // if it is we still want to close the subsession (but not bother about flushing dirty data)
+ r = ((CFsMessageRequest*) aRequest)->PushOperation(TFsSubClose::Complete);
+
+
+
+ return r;
+ }
+
+TInt TFsSubClose::Complete(CFsRequest* aRequest)
+ {
+ // if LastError() != KErrNone, this implies the request has been cancelled.
+ // i.e. TFsSubClose::DoRequestL() has not been called, so we need to call DoFsSubClose() here
+ if (((CFsMessageRequest*) aRequest)->LastError() != KErrNone)
+ DoFsSubClose(aRequest);
+
+ return CFsRequest::EReqActionComplete;
+ }
+
+
+TInt TFsNotifyChange::DoRequestL(CFsRequest* aRequest)
+//
+//
+//
+ {
+ CStdChangeInfo* notificationInfo=new CStdChangeInfo;
+ if (notificationInfo==NULL)
+ return (KErrNoMemory);
+ const RMessage2& m=aRequest->Message();
+ notificationInfo->Initialise((TNotifyType)m.Int0(),(TRequestStatus*)m.Ptr1(),m,aRequest->Session());
+ TInt r=FsNotify::AddChange(notificationInfo,KDriveInvalid);
+ if(r!=KErrNone)
+ delete(notificationInfo);
+ return(r);
+ }
+
+
+TInt TFsNotifyChange::Initialise(CFsRequest* /*aRequest*/)
+//
+//
+//
+ {
+ return(KErrNone);
+ }
+
+TInt TFsNotifyChangeEx::DoRequestL(CFsRequest* aRequest)
+//
+// Set up an extended change notification
+//
+ {
+ TUint notifyType=aRequest->Message().Int0();
+ if (aRequest->Src().NamePresent()) // Monitoring a file
+ { // Reject if iNotifyType is ENotifyDir
+ if (notifyType&ENotifyDir)
+ return (KErrArgument);
+ }
+ CExtChangeInfo* notificationInfo=new CExtChangeInfo;
+ if (notificationInfo==NULL)
+ return (KErrNoMemory);
+/* TEntry t;
+ TInt ret=aRequest->Drive()->Entry(aRequest->Src().FullName().Mid(2),t);
+ if ((ret==KErrNotFound)||(ret==KErrPathNotFound)||(ret==KErrInUse))
+ // Path does not yet exist or drive has been locked - still submit request
+ // but mark it as notify all since the client is potentially interested
+ notifyType=ENotifyAll;
+ else if (ret!=KErrNone)
+ {
+ delete notificationInfo;
+ return(ret);
+ }*/
+
+ const RMessage2& m=aRequest->Message();
+ notificationInfo->Initialise((TNotifyType)notifyType,(TRequestStatus*)m.Ptr2(),m,aRequest->Session(),aRequest->Src().FullName().Mid(2));
+ TInt drive;
+ if (aRequest->ScratchValue()!=0)
+ drive=KDriveInvalid;
+ else
+ drive=aRequest->DriveNumber();
+ TInt ret=FsNotify::AddChange(notificationInfo,drive);
+ if(ret!=KErrNone)
+ delete(notificationInfo);
+ return(ret);
+ }
+
+
+TInt TFsNotifyChangeEx::Initialise(CFsRequest* aRequest)
+ {
+ // Establish whether the directory or file to watch actually exists
+ // This sets the aSession members iTheName and iTheParse etc
+ TInt ret=KErrNone;
+ TBool monitorAllDrives=EFalse;
+ TFileName notifyPath;
+
+ TRAP(ret,aRequest->ReadL(KMsgPtr1,notifyPath));
+ if(ret!=KErrNone)
+ return(ret);
+ if(notifyPath.Length()==0)
+ return(KErrArgument);
+
+ if ((notifyPath[0]==KMatchAny)||(notifyPath[0]==KMatchOne))
+ {
+ // Use the default session drive for now
+ // Client has submitted a ? or * for drive
+ monitorAllDrives=ETrue;
+ ret=ParseNotificationPath(aRequest,aRequest->Src(),notifyPath);
+ if (ret!=KErrNone)
+ return(ret);
+ }
+ else
+ {
+ // Client has submitted a single drive to monitor
+ monitorAllDrives=EFalse;
+
+ ret = ParseNoWildSubstPtr1(aRequest, aRequest->Src());
+ if (ret!=KErrNone)
+ return(ret);
+ }
+ aRequest->SetScratchValue(monitorAllDrives);
+ ret = PathCheck(aRequest,aRequest->Src().FullName().Mid(2),&KCapFsNotifyChangeEx, __PLATSEC_DIAGNOSTIC_STRING("Extended Change Notifier"));
+ return(ret);
+ }
+
+TInt TFsNotifyChangeCancel::DoRequestL(CFsRequest* aRequest)
+//
+//
+//
+ {
+ FsNotify::CancelChangeSession(aRequest->Session());
+#if defined(_DEBUG)
+ FsNotify::CancelDebugSession(aRequest->Session());
+#endif
+ return(KErrNone);
+ }
+
+
+
+TInt TFsNotifyChangeCancel::Initialise(CFsRequest* /*aRequest*/)
+//
+//
+//
+ {
+ return KErrNone;
+ }
+
+
+
+TInt TFsNotifyChangeCancelEx::DoRequestL(CFsRequest* aRequest)
+//
+//
+//
+ {
+ FsNotify::CancelChangeSession(aRequest->Session(),(TRequestStatus*)aRequest->Message().Ptr0());
+#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
+ FsNotify::CancelDebugSession(aRequest->Session());
+#endif
+ return(KErrNone);
+ }
+
+
+
+TInt TFsNotifyChangeCancelEx::Initialise(CFsRequest* /*aRequest*/)
+//
+//
+//
+ {
+ return KErrNone;
+ }
+
+//
+// Setup a disk space notification request
+//
+TInt TFsNotifyDiskSpace::DoRequestL(CFsRequest *aRequest)
+ {
+ //-- first check that the threshold value is correct and is less than the volume size
+ const TUint64 threshold = aRequest->ScratchValue64();
+ if(threshold <= 0)
+ return KErrArgument;
+
+ //-- get the size of the mounted volume to check that the requested threshold isn't larger than the volume
+ TUint64 volSz;
+ TInt r = aRequest->Drive()->MountedVolumeSize(volSz);
+ if (r!=KErrNone)
+ return r;
+
+ if(threshold >= volSz)
+ return KErrArgument;
+
+
+ //-- Create the disk space notificator object and append it to the FsNotify queue
+ CDiskSpaceInfo* info=new CDiskSpaceInfo;
+ if(info==NULL)
+ return(KErrNoMemory);
+
+ const RMessage2& m=aRequest->Message();
+ info->Initialise((TRequestStatus*)m.Ptr2(),m,aRequest->Session(),threshold);
+
+ r=FsNotify::AddDiskSpace(info,aRequest->DriveNumber());
+ if(r!=KErrNone)
+ delete info;
+
+ return(r);
+ }
+
+
+TInt TFsNotifyDiskSpace::Initialise(CFsRequest *aRequest)
+//
+//
+//
+ {
+ TInt r=ValidateDriveDoSubst(aRequest->Message().Int1(),aRequest);
+ if (r==KErrNone)
+ {
+ TInt64 threshold;
+ TPtr8 tBuf((TUint8*)&threshold,sizeof(TInt64));
+ aRequest->ReadL(KMsgPtr0,tBuf);
+ aRequest->SetScratchValue64(threshold);
+ }
+ return(r);
+ }
+
+TInt TFsNotifyDiskSpaceCancel::DoRequestL(CFsRequest *aRequest)
+//
+// Cancel disk space notification
+//
+ {
+ FsNotify::CancelDiskSpaceSession(aRequest->Session(),(TRequestStatus*)aRequest->Message().Ptr0());
+ return(KErrNone);
+ }
+
+
+TInt TFsNotifyDiskSpaceCancel::Initialise(CFsRequest* /*aRequest*/)
+//
+//
+//
+ {
+ return(KErrNone);
+ }
+
+TInt TFsSynchroniseDriveThread::DoRequestL(CFsRequest* /*aRequest*/)
+//
+// This is to ensure that previous message has been handled in drive thread.
+//
+ {
+ return CFsRequest::EReqActionComplete;
+ }
+
+TInt TFsSynchroniseDriveThread::Initialise(CFsRequest *aRequest)
+//
+// Set the drive thread.
+//
+ {
+ if(aRequest->Message().Int0() == -1) //If no drive thread then complete the message
+ {
+ return CFsRequest::EReqActionComplete;
+ }
+ TInt r=ValidateDriveDoSubst(aRequest->Message().Int0(),aRequest);
+ return r;
+ }
+
+#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
+EXPORT_C void DebugNotifySessions(TInt aFunction,TInt /*aDrive*/)
+//
+// Notify sessions of a debug event
+//
+ {
+ // Notifying involves memory de-allocation on the file server's heap -
+ // check if we need to switch heaps.
+ RAllocator* current_alloc = &User::Heap();
+ RAllocator* svr_alloc = ServerThreadAllocator;
+ if (current_alloc != svr_alloc)
+ User::SwitchHeap(svr_alloc);
+ FsNotify::HandleDebug(aFunction);
+ if (current_alloc != svr_alloc)
+ User::SwitchHeap(current_alloc);
+ }
+#else
+EXPORT_C void DebugNotifySessions(TInt,TInt)
+//
+// Notify sessions of a debug event
+//
+ {}
+#endif
+
+
+TInt TFsDriveList::DoRequestL(CFsRequest* aRequest)
+//
+// Get the current drive list.
+//
+ {
+ TDriveList list(KMaxDrives);
+
+ const TUint mask = (TUint) aRequest->Message().Int1();
+ const TUint matchedFlags= mask & KDriveAttMatchedFlags; //KDriveAttMatchedFlags = 0xFFF
+ const TUint matchedAtt = mask & KDriveAttMatchedAtt; //KDriveAttMatchedAtt = 0x0FFF0000
+
+ TInt r = ValidateMatchMask(mask);
+ if(r!=KErrNone)
+ return r;
+
+ for (TInt i=0;i<KMaxDrives;i++)
+ {
+ if(RFs::IsValidDrive(i))
+ {
+ const TUint driveAtt= TheDrives[i].Att();
+ if(matchedFlags != 0 )
+ {
+ switch(matchedAtt)
+ {
+ case KDriveAttExclude :
+ {
+ list[i]= (driveAtt & matchedFlags ) ? (TUint8)0:(TUint8)driveAtt ;
+ break;
+ }
+ case 0:
+ {
+ list[i] = (driveAtt & matchedFlags) ? (TUint8)driveAtt:(TUint8)0 ;
+ break;
+ }
+ case KDriveAttExclusive :
+ {
+ if(matchedFlags != KDriveAttLogicallyRemovable)
+ {
+ list[i] = ((TUint8)driveAtt == matchedFlags) ? (TUint8)driveAtt:(TUint8)0;
+ }
+ else
+ {
+ list[i] = (driveAtt == (matchedFlags | KDriveAttRemovable)) ? (TUint8)driveAtt:(TUint8)0;
+ }
+ break;
+ }
+ case KDriveAttExclude | KDriveAttExclusive:
+ {
+ if(matchedFlags != KDriveAttLogicallyRemovable)
+ {
+ list[i] = ((TUint8)driveAtt == matchedFlags) ?(TUint8)0:(TUint8)driveAtt;
+ }
+ else
+ {
+ list[i] = (driveAtt == (matchedFlags | KDriveAttRemovable)) ? (TUint8)driveAtt:(TUint8)0;
+ }
+ break;
+ }
+ default:
+ {
+ return KErrArgument;
+ }
+ }
+ }
+ else //matchedFlags == 0
+ {
+ switch(matchedAtt)
+ {
+ case 0:
+ list[i] = (TUint8)0 ;
+ break;
+ case KDriveAttAll:
+ list[i]= (TUint8)driveAtt;
+ break;
+ default: //all other cases are incorrect
+ return KErrArgument;
+ }
+ }
+ }
+ else //r!=KErrNone
+ {
+ list[i]=0;
+ }
+ }
+
+ aRequest->WriteL(KMsgPtr0,list);
+
+ // Finally, kick off a speculative probe for devices
+ ProxyDrives->Lock();
+ TInt idx = ProxyDrives->Count();
+ while(idx--)
+ {
+ CExtProxyDriveFactory* pF = (CExtProxyDriveFactory*)(*ProxyDrives)[idx];
+ if(pF)
+ {
+ pF->AsyncEnumerate();
+ }
+ }
+ ProxyDrives->Unlock();
+
+ return(KErrNone);
+ }
+
+TInt TFsDriveList::Initialise(CFsRequest* /*aRequest*/)
+//
+//
+//
+ {
+ return KErrNone;
+ }
+
+TInt TFsDrive::DoRequestL(CFsRequest* aRequest)
+//
+// Get drive info.
+//
+ {
+ // executed in main thread, therefore lock to ensure that
+ // dismount cannot occur during request
+ FsThreadManager::LockDrive(aRequest->DriveNumber());
+ TDriveInfo info;
+ aRequest->Drive()->DriveInfo(info);
+ if(aRequest->SubstedDrive())
+ info.iDriveAtt=KDriveAttSubsted;
+ FsThreadManager::UnlockDrive(aRequest->DriveNumber());
+ TPckgC<TDriveInfo> pInfo(info);
+ aRequest->WriteL(KMsgPtr0,pInfo);
+ return(KErrNone);
+ }
+
+TInt TFsDrive::Initialise(CFsRequest* aRequest)
+//
+//
+//
+ {
+ TInt r=ValidateDriveDoSubst(aRequest->Message().Int1(),aRequest);
+ return(r);
+ }
+
+
+/**
+ Get volume info.
+*/
+TInt TFsVolume::DoRequestL(CFsRequest* aRequest)
+ {
+ TVolumeInfo v;
+ TPckg<TVolumeInfo> pV(v);
+
+ //-- read TVolumeInfo from the client side, the client may have provided some data to pass to the server and FSY side
+ aRequest->ReadL(KMsgPtr0,pV);
+
+ TRequestStatus* pStat = (TRequestStatus*)aRequest->Message().Ptr2();
+ if(pStat)
+ {//-- the user called an asynchronous version of the RFs::Volume
+ //-- indicate that we request free space asynchronously by setting a special flag that we will pass to the FSY
+ v.iVolSizeAsync = ETrue;
+ //-- at present the user's request will be completed by file server as the result of TFsVolume operation.
+ }
+ else
+ {
+ v.iVolSizeAsync = EFalse;
+ }
+
+ //-- ask the FSY to provide us its volume information
+ TInt r=aRequest->Drive()->Volume(v);
+
+ CSessionFs* session=aRequest->Session();
+ if (r==KErrNone)
+ {
+ TDrive* drive = aRequest->Drive();
+ const TInt driveNumber = drive->DriveNumber();
+
+ if(!session->ReservedAccess(driveNumber))
+ {
+ const TInt reserve = drive->ReservedSpace();
+ if(v.iFree <= reserve)
+ v.iFree = 0;
+ else
+ v.iFree -= reserve;
+ }
+
+ if(aRequest->SubstedDrive())
+ v.iDrive.iDriveAtt=KDriveAttSubsted;
+
+
+
+ if (drive->IsMounted() && drive->CurrentMount().LocalBufferSupport() == KErrNone && CCacheManagerFactory::CacheManager() != NULL)
+ v.iFileCacheFlags = TFileCacheSettings::Flags(driveNumber);
+ else
+ v.iFileCacheFlags = TFileCacheFlags(0);
+
+
+ aRequest->WriteL(KMsgPtr0,pV);
+ }
+
+ return(r);
+ }
+
+TInt TFsVolume::Initialise(CFsRequest* aRequest)
+//
+//
+//
+ {
+
+ TInt r=ValidateDriveDoSubst(aRequest->Message().Int1(),aRequest);
+ return(r);
+ }
+
+
+TInt TFsSetVolume::DoRequestL(CFsRequest* aRequest)
+//
+// Set the volume name.
+//
+ {
+ TInt r = CheckDiskSpace(0, aRequest);
+ if(r != KErrNone)
+ return r;
+
+ TFileName volumeName;
+ aRequest->ReadL(KMsgPtr0,volumeName);
+ if (volumeName.Length()>KMaxVolumeNameLength) // KMaxVolumeNameLength = 11
+ return(KErrBadName);
+
+ // Validate name - return KErrBadName if it contains illegal characters such as * ? / | > <
+ TNameChecker checker(volumeName);
+ TText badChar;
+ if (checker.IsIllegalName(badChar))
+ return(KErrBadName);
+
+ return(aRequest->Drive()->SetVolume(volumeName));
+ }
+
+
+TInt TFsSetVolume::Initialise(CFsRequest* aRequest)
+//
+//
+//
+ {
+ TInt r=ValidateDriveDoSubst(aRequest->Message().Int1(),aRequest);
+ if (r!=KErrNone)
+ return(r);
+ if (!KCapFsSetVolume.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Set Volume")))
+ return KErrPermissionDenied;
+ return KErrNone;
+ }
+
+
+TInt TFsSubst::DoRequestL(CFsRequest* aRequest)
+//
+// Get a drive substitution.
+//
+ {
+ TInt r=ValidateDrive(aRequest->Message().Int1(),aRequest);
+ if(r!=KErrNone)
+ return(r);
+ TFileName substName;
+ __PRINT(_L("aRequest->Drive()->Att()&KDriveAttSubsted"));
+ __PRINT1(_L("aRequest->Drive()->Subst()"),&aRequest->Drive()->Subst());
+ if (aRequest->Drive()->IsSubsted())
+ substName=aRequest->Drive()->Subst();
+ aRequest->WriteL(KMsgPtr0,substName);
+ return(KErrNone);
+ }
+
+
+TInt TFsSubst::Initialise(CFsRequest* /*aRequest*/)
+//
+//
+//
+ {
+ return KErrNone;
+ }
+
+
+TInt TFsSetSubst::DoRequestL(CFsRequest* aRequest)
+//
+// Set a drive substitution.
+//
+ {
+ TInt r=ValidateDrive(aRequest->Message().Int1(),aRequest);
+ if (r!=KErrNone)
+ return(r);
+ TDrive* pD=aRequest->Drive();
+ r=ParsePathPtr0(aRequest,aRequest->Src());
+ if (r!=KErrNone)
+ return(r);
+ //TODO: no protection for unsubsting drives (could check substed path if system then only CRoot process can unsubst
+ if (pD->IsSubsted() && !aRequest->Src().DrivePresent() && !aRequest->Src().PathPresent())
+ {
+ delete &pD->Subst();
+ pD->SetSubst(NULL);
+ pD->SetAtt(0);
+ pD->SetSubstedDrive(NULL);
+ return(KErrNone);
+ }
+ r=PathCheck(aRequest,aRequest->Src().FullName().Mid(2),&KCapFsSysSetSubst,&KCapFsPriSetSubst,&KCapFsROSetSubst, __PLATSEC_DIAGNOSTIC_STRING("Set Subst"));
+ if (r!=KErrNone)
+ return(r);
+ if (pD->Att()&(KDriveAttLocal|KDriveAttRom|KDriveAttRedirected|KDriveAttSubsted))
+ return(KErrGeneral);
+ if (pD==aRequest->Drive())
+ return(KErrGeneral);
+ if (aRequest->Drive()->Att()&(KDriveAttRedirected|KDriveAttSubsted))
+ return(KErrInUse);
+ HBufC* pS=aRequest->Src().FullName().Alloc();
+ if (pS==NULL)
+ return(KErrNoMemory);
+ __ASSERT_DEBUG(!&pD->SubstedDrive(),Fault(ETFsSetSubstNotNull));
+ delete &pD->Subst();
+ pD->SetSubst(pS);
+ pD->SetSubstedDrive(aRequest->Drive());
+ pD->SetAtt(KDriveAttSubsted);
+ return(KErrNone);
+ }
+
+TInt TFsSetSubst::Initialise(CFsRequest* aRequest)
+//
+//
+//
+ {
+ if (!KCapFsSetSubst.CheckPolicy(aRequest->Message(),__PLATSEC_DIAGNOSTIC_STRING("Set subst")))
+ return KErrPermissionDenied;
+ return KErrNone;
+ }
+
+
+TInt TFsRealName::DoRequestL(CFsRequest* aRequest)
+//
+// Get the real name of a file.
+//
+ {
+ TInt r=ParseSubstPtr0(aRequest,aRequest->Src());
+ if (r!=KErrNone)
+ return(r);
+ r=PathCheck(aRequest,aRequest->Src().FullName().Mid(2),&KCapFsSysRealName,&KCapFsPriRealName, __PLATSEC_DIAGNOSTIC_STRING("Real Name"));
+ if (r!=KErrNone)
+ return(r);
+ TFileName substName;
+ if (aRequest->Drive()->Att()&KDriveAttRedirected)
+ substName=aRequest->Drive()->Subst(); // DANGER?
+ else
+ substName=aRequest->Src().Drive();
+ if ((substName.Length()+aRequest->Src().FullName().Mid(2).Length())>KMaxFileName)
+ return(KErrBadName);
+ substName+=aRequest->Src().FullName().Mid(2);
+ aRequest->WriteL(KMsgPtr1,substName);
+ return(KErrNone);
+ }
+
+TInt TFsRealName::Initialise(CFsRequest* /*aRequest*/)
+//
+//
+//
+ {
+ return KErrNone;
+ }
+
+TInt TFsDefaultPath::DoRequestL(CFsRequest* aRequest)
+//
+// Get the default path.
+//
+ {
+ if(PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement))
+ return KErrNotSupported;
+ else if(PlatSec::ConfigSetting(PlatSec::EPlatSecDiagnotics))
+ {
+ //FIXME: to be remove the following when platform is fully secure
+ RThread tT;
+ TInt r=aRequest->Message().Client(tT,EOwnerThread);
+ if(r!=KErrNone)
+ return r;
+ RProcess tP;
+ r=tT.Process(tP);
+ if(r!=KErrNone)
+ {
+ tT.Close();
+ return r;
+ }
+ TName n;
+ n=tP.Name();
+ TInt b=n.Locate('[');
+ if (b>=0)
+ n.SetLength(b);
+ RDebug::Print(_L("**** API violation: %S should not use DefaultPath()\n"),&n);
+ tP.Close();
+ tT.Close();
+ //FIXME END
+ aRequest->WriteL(KMsgPtr0,TheDefaultPath);
+ return(KErrNone);
+ }
+ else
+ {
+ aRequest->WriteL(KMsgPtr0,TheDefaultPath);
+ return(KErrNone);
+ }
+ }
+
+TInt TFsDefaultPath::Initialise(CFsRequest* /*aRequest*/)
+//
+//
+//
+ {
+ return KErrNone;
+ }
+
+TInt TFsSetDefaultPath::DoRequestL(CFsRequest* aRequest)
+//
+// Set the default path.
+//
+ {
+ if(PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement))
+ return KErrNotSupported;
+ else if(PlatSec::ConfigSetting(PlatSec::EPlatSecDiagnotics))
+ {
+ //FIXME: to be remove the following when platform is fully secure
+ RThread tT;
+ TInt r=aRequest->Message().Client(tT,EOwnerThread);
+ if(r!=KErrNone)
+ return r;
+ RProcess tP;
+ r=tT.Process(tP);
+ if(r!=KErrNone)
+ {
+ tT.Close();
+ return r;
+ }
+ TName n;
+ n=tP.Name();
+ TInt b=n.Locate('[');
+ if (b>=0)
+ n.SetLength(b);
+ RDebug::Print(_L("**** API violation: %S should not use SetDefaultPath()\n"),&n);
+ tP.Close();
+ tT.Close();
+ //FIXME END
+ TParse parse;
+ /*TInt*/ r=ParsePathPtr0(aRequest,parse);
+ if (r!=KErrNone && r!=KErrInUse)
+ return(r);
+ if (IsIllegalFullName(parse.FullName()))
+ return(KErrBadName);
+ TheDefaultPath=parse.FullName();
+ return(KErrNone);
+ }
+ else
+ {
+ TParse parse;
+ TInt r=ParsePathPtr0(aRequest,parse);
+ if (r!=KErrNone && r!=KErrInUse)
+ return(r);
+ if (IsIllegalFullName(parse.FullName()))
+ return(KErrBadName);
+ TheDefaultPath=parse.FullName();
+ return(KErrNone);
+ }
+ }
+
+
+TInt TFsSetDefaultPath::Initialise(CFsRequest* /*aRequest*/)
+//
+//
+//
+ {
+ return KErrNone;
+ }
+
+TInt TFsSessionPath::DoRequestL(CFsRequest* aRequest)
+//
+// Get the session path
+//
+ {
+ aRequest->WriteL(KMsgPtr0,aRequest->Session()->Path());
+ return(KErrNone);
+ }
+
+TInt TFsSessionPath::Initialise(CFsRequest* /*aRequest*/)
+//
+//
+//
+ {
+ return KErrNone;
+ }
+
+
+TInt TFsSetSessionPath::DoRequestL(CFsRequest* aRequest)
+//
+// Set the session path
+//
+ {
+ TParse parse;
+ TInt r=ParsePathPtr0(aRequest,parse);
+ if (r!=KErrNone && r!=KErrInUse)
+ return(r);
+ r=PathCheck(aRequest,parse.FullName().Mid(2),&KCapFsSysSetSessionPath,&KCapFsPriSetSessionPath, __PLATSEC_DIAGNOSTIC_STRING("Set Session Path"));
+ if (r!=KErrNone)
+ return(r);
+ if (IsIllegalFullName(parse.FullName()))
+ return(KErrBadName);
+ HBufC* pP=parse.FullName().Alloc();
+ if (pP==NULL)
+ return(KErrNoMemory);
+ delete &aRequest->Session()->Path();
+ aRequest->Session()->SetPath(pP);
+ return(KErrNone);
+ }
+
+TInt TFsSetSessionPath::Initialise(CFsRequest* /*aRequest*/)
+//
+//
+//
+ {
+ return(KErrNone);
+ }
+
+
+TInt TFsParse::DoRequestL(CFsRequest* aRequest)
+//
+// Parse a file name.
+//
+ {
+ TFileName name;
+ aRequest->ReadL(KMsgPtr0,name);
+ TFileName rel;
+ if (aRequest->Message().Ptr1()!=NULL)
+ aRequest->ReadL(KMsgPtr1,rel);
+ TParse p;
+ TInt r=p.Set(name,&rel,&aRequest->Session()->Path());
+ if (r==KErrNone)
+ {
+ TPckgC<TParse> pP(p);
+ aRequest->WriteL(KMsgPtr2,pP);
+ }
+ return(r);
+ }
+
+TInt TFsParse::Initialise(CFsRequest* /*aRequest*/)
+//
+//
+//
+ {
+ return KErrNone;
+ }
+
+TInt TFsReserveDriveSpace::DoRequestL(CFsRequest* aRequest)
+//
+// set reserved value to add to a drives reserved area
+//
+ {
+ // extract request info
+ CSessionFs* session=aRequest->Session();
+ TDrive* drive = aRequest->Drive();
+
+ if(session->ReservedAccess(drive->DriveNumber()))
+ return KErrInUse;
+
+ const TInt reserve = aRequest->Message().Int1(); //-- bytes to reserve on the drive
+
+ // Check if requested reserve space is within the range
+ if(reserve > KMaxSessionDriveReserved || reserve < 0)
+ return KErrArgument;
+
+ const TInt64 threshold = reserve + drive->ReservedSpace(); //-- free bytes on the volume we actually need
+
+ TInt nRes = drive->RequestFreeSpaceOnMount(threshold);
+ if(nRes != KErrNone)
+ return nRes;
+
+ const TInt current = session->Reserved(drive->DriveNumber());
+ const TInt diff = reserve - current;
+ TInt drvReserved = drive->ReservedSpace();
+ if((drvReserved + diff) > KMaxTotalDriveReserved)
+ return KErrTooBig;
+
+ drvReserved += diff;
+ drive->SetReservedSpace(drvReserved);
+ return session->SetReserved(drive->DriveNumber(), reserve);
+
+ }
+
+TInt TFsReserveDriveSpace::Initialise(CFsRequest* aRequest)
+//
+// Validate drive and set up the session parameters for request
+//
+ {
+// if (!KCapFsReserveDriveSpace.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Reserve Drive Space")))
+// return KErrPermissionDenied;
+ TInt drvNumber=aRequest->Message().Int1();
+ drvNumber=aRequest->Message().Int0();
+ TInt r=ValidateDrive(aRequest->Message().Int0(),aRequest);
+ return(r);
+ }
+
+
+TInt TFsGetReserveAccess::DoRequestL(CFsRequest* aRequest)
+//
+// Get reserved access to a drives reserved area first checking that the session has first reserved some space
+//
+ {
+ CSessionFs* session=aRequest->Session();
+
+ TInt size=session->Reserved(aRequest->Drive()->DriveNumber());
+ if(size <= 0)
+ return KErrPermissionDenied;
+ else
+ session->SetReservedAccess(aRequest->Drive()->DriveNumber(),ETrue);
+ return KErrNone;
+ }
+
+TInt TFsGetReserveAccess::Initialise(CFsRequest* aRequest)
+//
+//
+//
+ {
+// if (!KCapFsGetReserveAccess.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Get Reserve Access")))
+// return KErrPermissionDenied;
+ TInt r=ValidateDrive(aRequest->Message().Int0(),aRequest);
+ return(r);
+ }
+
+
+TInt TFsReleaseReserveAccess::DoRequestL(CFsRequest* aRequest)
+//
+// Remove access for this session to the locked area for a given drive
+//
+ {
+ aRequest->Session()->SetReservedAccess(aRequest->Drive()->DriveNumber(),EFalse);
+ return KErrNone;
+ }
+
+TInt TFsReleaseReserveAccess::Initialise(CFsRequest* aRequest)
+//
+//
+//
+ {
+// if (!KCapFsReleaseReserveAccess.CheckPolicy(aRequest->Message(), __PLATSEC_DIAGNOSTIC_STRING("Release Reserve Access")))
+// return KErrPermissionDenied;
+ TInt r=ValidateDrive(aRequest->Message().Int0(),aRequest);
+ return(r);
+ }
+
+TInt TFsSetStartupConfiguration::DoRequestL(CFsRequest* aRequest)
+//
+// Configure file server according to command and parameters.
+//
+ {
+ TInt cmd = aRequest->Message().Int0();
+
+ switch (cmd)
+ {
+ case ELoaderPriority:
+ // Set loader thread priority
+ {
+ TInt r;
+ TFullName loaderFullName(RProcess().FullName());
+ loaderFullName.Append(_L("::LoaderThread"));
+ RThread loader;
+ r = loader.Open(loaderFullName);
+ if (r != KErrNone)
+ return r;
+ loader.SetPriority((TThreadPriority)aRequest->Message().Int1());
+ loader.Close();
+ }
+ break;
+ case ESetRugged:
+ {
+ TInt drive = aRequest->Message().Int1();
+ TInt r = ValidateDrive(drive, aRequest);
+ if (r != KErrNone)
+ return r;
+ TInt value = aRequest->Message().Int2();
+ aRequest->Drive()->SetRugged(value);
+ }
+ break;
+ default:
+ return KErrArgument;
+ }
+
+ return KErrNone;
+ }
+
+TInt TFsSetStartupConfiguration::Initialise(CFsRequest* aRequest)
+//
+// Check SID of message sender. Can be estart only
+//
+ {
+ if (aRequest->Message().SecureId() != KEstartUidValue)
+ return KErrPermissionDenied;
+ return KErrNone;
+ }
+
+
+const TInt KinitialChanges = EChangesLocale|EChangesMidnightCrossover|EChangesThreadDeath|EChangesPowerStatus|EChangesSystemTime|EChangesFreeMemory|EChangesOutOfMemory;
+
+CKernEventNotifier* CKernEventNotifier::New(TInt aPriority)
+ {
+ __PRINT(_L("CKernEventNotifier::New"));
+ CKernEventNotifier* self = new CKernEventNotifier(aPriority);
+ if (self && (self->iChangeNotifier.Create() != KErrNone))
+ delete self, self = NULL;
+ return self;
+ }
+
+CKernEventNotifier::~CKernEventNotifier()
+ {
+ Cancel();
+ iChangeNotifier.Close();
+ }
+
+void CKernEventNotifier::Start()
+ {
+ SetActive();
+ iChangeNotifier.Logon(iStatus);
+ }
+
+void CKernEventNotifier::RunL()
+ {
+ __PRINT(_L("CKernEventNotifier::RunL"));
+ iChange = iStatus.Int();
+ Start();
+
+ /* Avoid being triggered by initial events */
+ if (iChange != 0 && (iChange & KinitialChanges) != KinitialChanges)
+ {
+ if (iChange & EChangesLocale)
+ CKernEventNotifier::LocaleChangeCallback();
+ if (iChange & EChangesFreeMemory)
+ CKernEventNotifier::FreeMemoryChangeCallback();
+ // Add other event capture below this line
+ iChange = 0;
+ }
+ }
+
+void CKernEventNotifier::DoCancel()
+ {
+ iChangeNotifier.LogonCancel();
+ }
+
+
+extern TBool FatUtilitiesUpdateDrivesNotified;
+extern TBool FatUtilityFunctionsSet;
+
+TInt CKernEventNotifier::LocaleChangeCallback(TAny*)
+ {
+ __PRINT(_L("CKernEventNotifier::LocaleChangeCallback"));
+
+ //-- check if the locale has just been set and the drives are not yet notified about this.
+ if(FatUtilityFunctionsSet && !FatUtilitiesUpdateDrivesNotified)
+ {//-- notify drives about locale shange, but only once
+ for(TInt i=0; i<KMaxDrives; i++)
+ {
+ TDrive& drive=TheDrives[i];
+
+ if(drive.DriveNumber() >=0 && drive.IsRemovable() && !drive.IsSubsted())
+ {
+ __PRINT1(_L("CKernEventNotifier::LocaleChangeCallback upd drive: %d"), drive.DriveNumber());
+ drive.SetChanged(ETrue);
+ }
+ }
+
+ FatUtilitiesUpdateDrivesNotified = ETrue;
+ }
+
+ return KErrNone;
+ }
+
+TInt TFsQueryVolumeInfoExt::DoRequestL(CFsRequest* aRequest)
+ {
+ const TInt cmd = aRequest->Message().Int1();
+ TInt rel;
+
+ TDrive* pDrive = aRequest->Drive();
+
+ rel = pDrive->CheckMount();
+ if(rel != KErrNone)
+ return rel;
+
+ switch (cmd)
+ {
+
+ //-------------------------------------------------
+ //-- file system sub type query
+ case EFileSystemSubType:
+ {
+ TFSName name;
+ if (pDrive->IsMounted())
+ {
+ rel = pDrive->CurrentMount().FileSystemSubType(name);
+
+ //-- get the Mount's file system name if the FS subtype query is not supported or there are no subtypes.
+ if (rel==KErrNotSupported)
+ {
+ pDrive->CurrentMount().FileSystemName(name);
+ }
+
+ if (name.Length())
+ {
+ TPckgBuf<TFSName> pckgBuf(name);
+ aRequest->WriteL(KMsgPtr2, pckgBuf);
+ return KErrNone;
+ }
+ else
+ {
+ return rel;
+ }
+ }
+ else
+ {
+ return KErrNotReady;
+ }
+ }
+
+
+ //-------------------------------------------------
+ //-- this is RFs::VolumeIOParam() query
+ case EIOParamInfo:
+ {
+ TVolumeIOParamInfo ioInfo;
+ // 1. gets block size information via media driver
+ const TInt drive = aRequest->Message().Int0();
+
+ // validates local drive numbers
+ if(!IsValidLocalDriveMapping(drive))
+ {
+ ioInfo.iBlockSize = KErrNotReady;
+ }
+ else
+ {
+ // Get media capability
+ TLocalDriveCapsV6Buf capsBuf;
+
+ // is the drive local?
+ if (!IsProxyDrive(drive))
+ {
+ // 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
+ rel = GetLocalDrive(drive).Caps(capsBuf);
+ }
+ else // this need to be made a bit nicer
+ {
+ CExtProxyDrive* pD = GetProxyDrive(drive);
+ if(pD)
+ rel = pD->Caps(capsBuf);
+ else
+ rel = KErrNotReady;
+ }
+
+ if (rel != KErrNone)
+ {
+ ioInfo.iBlockSize = rel;
+ }
+ else
+ {
+ TLocalDriveCapsV6& caps = capsBuf();
+ if (caps.iBlockSize)
+ {
+ ioInfo.iBlockSize = caps.iBlockSize;
+ }
+ // returns default size (512) when block is not supported by
+ // underlying media
+ else
+ {
+ ioInfo.iBlockSize = KDefaultVolumeBlockSize;
+ }
+ }
+ }
+
+ // 2. gets cluster size via mounted file system; Also get Max. file size supported by the file system
+
+ ioInfo.iMaxSupportedFileSize = KMaxTUint64; //-- the value for "not supported case"
+
+ if (pDrive->IsMounted())
+ {
+ rel = pDrive->CurrentMount().FileSystemClusterSize();
+ ioInfo.iClusterSize = rel; // return cluster size or an error code if error happened.
+
+ pDrive->CurrentMount().GetMaxSupportedFileSize(ioInfo.iMaxSupportedFileSize);
+
+ }
+ else
+ {
+ ioInfo.iClusterSize = KErrNotReady;
+ }
+
+ // 3. get rec buffer size from estart.txt file
+ {
+ _LIT8(KLitSectionNameDrive,"Drive%C");
+ ioInfo.iRecReadBufSize = KErrNotSupported;
+ ioInfo.iRecWriteBufSize = KErrNotSupported;
+
+ TBuf8<8> sectionName;
+ TInt32 bufSize;
+ sectionName.Format(KLitSectionNameDrive, 'A' + drive);
+ // retrieve recommended buffer size information through F32 INI section
+ if (F32Properties::GetInt(sectionName, _L8("RecReadBufSize"), bufSize))
+ {
+ ioInfo.iRecReadBufSize = bufSize;
+ }
+ if (F32Properties::GetInt(sectionName, _L8("RecWriteBufSize"), bufSize))
+ {
+ ioInfo.iRecWriteBufSize = bufSize;
+ }
+
+ // packaging and returning results
+ TPckgBuf<TVolumeIOParamInfo> pckgBuf(ioInfo);
+ aRequest->WriteL(KMsgPtr2, pckgBuf);
+ }
+
+ // always return KErrNone as error codes are packaged and returned via ioInfo members
+ return KErrNone;
+ } //case EIOParamInfo:
+
+ //-------------------------------------------------
+ //-- check if the specified drive is synchronous or not
+ case EIsDriveSync:
+ {
+ const TInt drive = aRequest->Message().Int0();
+ const TBool bDrvSynch = FsThreadManager::IsDriveSync(drive, EFalse);
+ TPckgBuf<TBool> buf(bDrvSynch);
+ aRequest->WriteL(KMsgPtr2, buf);
+
+ return KErrNone;
+ }
+
+ //-------------------------------------------------
+ //-- query if the drive is finalised
+ case EIsDriveFinalised:
+ {
+ TBool bFinalised;
+ TInt nRes = pDrive->CurrentMount().IsMountFinalised(bFinalised);
+ if(nRes != KErrNone)
+ return nRes;
+
+ TPckgBuf<TBool> buf(bFinalised);
+ aRequest->WriteL(KMsgPtr2, buf);
+
+ return KErrNone;
+ }
+
+
+ default:
+ {
+ return KErrNotSupported;
+ }
+ }
+ }
+
+TInt TFsQueryVolumeInfoExt::Initialise(CFsRequest* aRequest)
+ {
+ TInt r = ValidateDriveDoSubst(aRequest->Message().Int0(),aRequest);
+ return r;
+ }
+
+TInt CKernEventNotifier::FreeMemoryChangeCallback()
+ {
+ __PRINT(_L("CKernEventNotifier::FreeMemoryChangeCallback"));
+
+ TBool belowThreshold = (iChange & EChangesLowMemory)?(TBool)ETrue:(TBool)EFalse;
+ CCacheManager* manager = CCacheManagerFactory::CacheManager();
+ if (manager)
+ {
+ manager->FreeMemoryChanged(belowThreshold);
+
+ // start flushing all dirty data
+ if (belowThreshold)
+ {
+ Files->Lock();
+ TInt count=Files->Count();
+ while(count--)
+ {
+ CFileCB* file = (CFileCB*)(*Files)[count];
+ if (file->FileCache())
+ // Cannot report errors here
+ // coverity [unchecked_value]
+ (void)file->FileCache()->FlushDirty();
+ }
+ Files->Unlock();
+ }
+ }
+
+#ifdef SYMBIAN_ENABLE_FAT_DIRECTORY_OPT
+ CCacheMemoryManager* cacheMemManager = CCacheMemoryManagerFactory::CacheMemoryManager();
+ if (cacheMemManager)
+ cacheMemManager->FreeMemoryChanged(belowThreshold);
+#endif //#ifdef SYMBIAN_ENABLE_FAT_DIRECTORY_OPT
+
+ return KErrNone;
+ }
+