diff -r 000000000000 -r a41df078684a kerneltest/f32test/server/t_dcnone.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/kerneltest/f32test/server/t_dcnone.cpp Mon Oct 19 15:55:17 2009 +0100 @@ -0,0 +1,1331 @@ +// 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: +// + +#include +#include +#include +#include +#include +#include +#include +#include "t_server.h" + +GLDEF_D RTest test(_L("t_dcnone")); +GLDEF_D TTime gTimeNow; +LOCAL_D TInt gTheDriveNum; + +//_LIT(KDefPath, "\\Default\\"); + +const TInt KPathPosition = 2; +_LIT(KExpectedPrivatePath, "\\Private\\00000001\\"); + + +_LIT(KResourcePath, "?:\\Resource\\"); +_LIT(KSystemPath, "?:\\Sys\\"); +_LIT(KPrivatePath, "?:\\Private\\"); +_LIT(KPrivateFalseID, "?:\\Private\\FFFFFFFF\\"); +_LIT(KDriveName, "Billy"); +//_LIT(KVolLable, "Benny"); + +_LIT(KFileSys, "systemfile.txt"); +//_LIT(KFileSys2, "systemfile.tmp"); +_LIT(KFileSys3, "sysfile.rna"); + +_LIT(KFilePri, "privatefile.txt"); +_LIT(KFilePri2, "privatefile.tmp"); +_LIT(KFilePri3, "prifile.rna"); + +_LIT(KFileRes, "resourcefile.txt"); +//_LIT(KFileRes2, "resourcefile.tmp"); +_LIT(KFileRes3, "resfile.rna"); + +_LIT(KMkDirSub,"Subdir\\"); +_LIT(KOldFile,"?:\\Anyold.txt"); +//_LIT(KNullPath, ""); +//_LIT(KLFFSName, "Lffs"); + +_LIT(KWildPath, "Z:\\SYS\\"); +_LIT(KWildFile, "*"); + +_LIT(KPrivatePathTest1, "\\Private\\00000001"); +_LIT(KPrivatePathTest2, "\\Private\\FFFFFFFF"); +_LIT(KPrivatePathTest3, "\\Private\\FFFFFFFF\\"); +TInt theDrive=0; +TCapability TheCaps; +TBuf<4> driveBuf=_L("?:\\"); +RFormat format; +TInt count; +RRawDisk rawdisk; +RFile file1; +RFile file2; +RDir dir; +CDir* dirEntries; +TInt r; +TBuf<40> fsname; +TBuf<40> systestname; +TBuf<40> pritestname; +TBuf<40> restestname; +TBuf<40> theprivatepath; +TBuf<40> pritestfalseidname; +TBuf<40> mkdirname; +TFileName fromTemp; + + +TBuf<25> prifilename; +TBuf<25> sysfilename; +TBuf<30> realName; +TBuf<40> shortfilename; +TBuf<40> longfilename; + +TRequestStatus aStat1; +TRequestStatus aStat2; +TRequestStatus aStat3; +TRequestStatus aStat4; + +TVolumeInfo aVolInfo; +// TDriveInfo adriveInfo; + +TBuf<40> systestfile; +TBuf<40> pritestfile; +TBuf<40> restestfile; +TBuf<40> systestfile1; +TBuf<40> pritestfile1; +TBuf<40> restestfile1; + +TTime testtime; +TBuf<20> oldName; +TBuf<25> temp; +TEntry entry; + + + + +LOCAL_C void TestPathCheck() +// +// This test case is brought in by INC054580 +// (NTT Renaming sys ¨Cfolder on C -drive on H2 allows user to access sys -files) +// + { + TInt r = TheFs.Rename(_L("\\sys"), _L("\\sysbad")); + test(r == KErrPermissionDenied); + r = TheFs.Rename(_L("\\resource"), _L("\\resourcebad")); + test(r == KErrPermissionDenied); + r = TheFs.Rename(_L("\\private"), _L("\\privatebad")); + test(r == KErrPermissionDenied); + } + +LOCAL_C void systemRFstest() +// +// +// + { + systestname=KSystemPath; + systestname[0]=(TText)('A' + gTheDriveNum); + + mkdirname.Zero(); + mkdirname.Append(systestname); + mkdirname.Append(KMkDirSub); + r=TheFs.MkDirAll(mkdirname); + test(r==KErrPermissionDenied); + + r=TheFs.RmDir(mkdirname); + test(r==KErrPermissionDenied); + + r=TheFs.SetSubst(systestname,EDriveP); + test(r==KErrPermissionDenied); + + r=TheFs.SetSessionPath(systestname); + test(r==KErrPermissionDenied); + + TheFs.NotifyChange(ENotifyAll,aStat1,systestname); + test(aStat1==KErrPermissionDenied); + + systestfile=KSystemPath; + systestfile[0]=(TText)('A' + gTheDriveNum); + systestfile1=systestfile; + systestfile.Append(KFileSys); + systestfile1.Append(KFileSys3); + + oldName=KOldFile; + oldName[0]=(TText)gDriveToTest; + + r=TheFs.GetShortName(systestfile, shortfilename); + test(r==KErrPermissionDenied); + + r=TheFs.GetLongName(systestfile1, longfilename); + test(r==KErrPermissionDenied); + + r=file1.Create(TheFs,oldName,EFileWrite); + test(r==KErrNone || r==KErrAlreadyExists); + file1.Close(); + + r=TheFs.Replace(oldName,systestfile); + test(r==KErrPermissionDenied); + + r=TheFs.Rename(systestfile,systestfile1); + test(r==KErrPermissionDenied); + + // check that the entry for the system directory itself can be retrieved with no error + // - with or without a slash + TPtrC restrictedDir(systestname.Ptr(), systestname.Length()); + r=TheFs.Entry(restrictedDir, entry); + test.Printf(_L("RFs::Entry(%S) returned %d"), &restrictedDir, r); + test(r==KErrNone); + test (entry.iAtt & KEntryAttDir); + + TPtrC restrictedDirWithNoBackSlash(restrictedDir.Ptr(), restrictedDir.Length()-1); + r=TheFs.Entry(restrictedDirWithNoBackSlash,entry); + test.Printf(_L("RFs::Entry(%S) returned %d"), &restrictedDirWithNoBackSlash, r); + test(r==KErrNone); + + r=TheFs.Entry(systestfile1,entry); + test(r==KErrPermissionDenied); + + r=TheFs.SetEntry(systestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly); + test(r==KErrPermissionDenied); + + r=TheFs.Delete(systestfile1); + test(r==KErrPermissionDenied); + + } + + +LOCAL_C void resourceRFstest() +// +// +// + { + + restestname=KResourcePath; + restestname[0]=(TText)('A' + gTheDriveNum); + + mkdirname.Zero(); + mkdirname.Append(restestname); + mkdirname.Append(KMkDirSub); + r=TheFs.MkDirAll(mkdirname); + test(r==KErrPermissionDenied); + + TheFs.RmDir(mkdirname); + test(r==KErrPermissionDenied); + + r=TheFs.SetSubst(restestname,EDriveP); + test(r==KErrPermissionDenied); + + r=TheFs.RealName(_L("P:\\File.XXX"),realName); + test(r==KErrNone); + + r=TheFs.SetSessionPath(restestname); + test(r==KErrNone); + + TheFs.NotifyChange(ENotifyAll,aStat4,restestname); + test(aStat4==KRequestPending); + + + restestfile=KResourcePath; + restestfile[0]=(TText)('A' + gTheDriveNum); + restestfile1=restestfile; + restestfile.Append(KFileRes); + restestfile1.Append(KFileRes3); + + oldName=KOldFile; + oldName[0]=(TText)gDriveToTest; + + r=TheFs.GetShortName(restestfile, shortfilename); + test(r==KErrNone || KErrPathNotFound); + + r=TheFs.GetLongName(restestfile1, longfilename); + test(r==KErrNone || KErrPathNotFound); + + r=file1.Create(TheFs,oldName,EFileWrite); + test(r==KErrNone || r==KErrAlreadyExists); + file1.Close(); + + r=TheFs.Replace(oldName,restestfile); + test(r==KErrPermissionDenied); + + r=TheFs.Rename(restestfile,restestfile1); + test(r==KErrPermissionDenied); + + // check that the entry for the resource directory itself can be retrieved with no error + // - with or without a slash + TPtrC restrictedDir(restestname.Ptr(), restestname.Length()); + r=TheFs.Entry(restrictedDir, entry); + test.Printf(_L("RFs::Entry(%S) returned %d"), &restrictedDir, r); + test(r==KErrNone); + test (entry.iAtt & KEntryAttDir); + + TPtrC restrictedDirWithNoBackSlash(restrictedDir.Ptr(), restrictedDir.Length()-1); + r=TheFs.Entry(restrictedDirWithNoBackSlash,entry); + test.Printf(_L("RFs::Entry(%S) returned %d"), &restrictedDirWithNoBackSlash, r); + test(r==KErrNone); + + r=TheFs.Entry(restestfile1,entry); + test(r==KErrNone || r==KErrNotFound); + + r=TheFs.SetEntry(restestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly); + test(r==KErrPermissionDenied); + + r=TheFs.Delete(restestfile1); + test(r==KErrPermissionDenied); + + } + + +LOCAL_C void privatefalseIDRFstest() +// +// +// + { + pritestfalseidname=KPrivateFalseID; + pritestfalseidname[0]=(TText)('A' + gTheDriveNum); + + mkdirname.Zero(); + mkdirname.Append(pritestfalseidname); + mkdirname.Append(KMkDirSub); + + r=TheFs.MkDirAll(mkdirname); + test(r==KErrPermissionDenied); + + r=TheFs.RmDir(mkdirname); + test(r==KErrPermissionDenied); + + r=TheFs.SetSubst(pritestfalseidname,EDriveP); + test(r==KErrPermissionDenied); + + TheFs.NotifyChange(ENotifyAll,aStat2,pritestfalseidname); + test(aStat2==KErrPermissionDenied); + + + pritestfile=KPrivateFalseID; + pritestfile[0]=(TText)('A' + gTheDriveNum); + pritestfile1=pritestfile; + pritestfile.Append(KFilePri2); + pritestfile1.Append(KFilePri3); + + oldName=KOldFile; + oldName[0]=(TText)gDriveToTest; + + r=TheFs.GetShortName(pritestfile, shortfilename); + test(r==KErrPermissionDenied); + + r=TheFs.GetLongName(pritestfile1, longfilename); + test(r==KErrPermissionDenied); + + r=file1.Create(TheFs,oldName,EFileWrite); + test(r==KErrNone || r==KErrAlreadyExists); + file1.Close(); + + r=TheFs.Replace(oldName,pritestfile); + test(r==KErrPermissionDenied); + + r=TheFs.Rename(pritestfile,pritestfile1); + test(r==KErrPermissionDenied); + + r=TheFs.Entry(pritestfile1,entry); + test(r==KErrPermissionDenied); + + r=TheFs.SetEntry(pritestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly); + test(r==KErrPermissionDenied); + + r=TheFs.Delete(pritestfile1); + test(r==KErrPermissionDenied); + + } + + + +LOCAL_C void privateRFstest() +// +// +// + { + pritestname=KPrivatePath; + pritestname[0]=(TText)('A' + gTheDriveNum); + + mkdirname.Zero(); + mkdirname.Append(pritestname); + mkdirname.Append(KMkDirSub); + + r=TheFs.MkDirAll(mkdirname); + test(r==KErrPermissionDenied); + + r=TheFs.RmDir(mkdirname); + test(r==KErrPermissionDenied); + + r=TheFs.SetSubst(pritestname,EDriveP); + test(r==KErrPermissionDenied); + + TheFs.NotifyChange(ENotifyAll,aStat2,pritestname); + test(aStat2==KErrPermissionDenied); + + + pritestfile=KPrivatePath; + pritestfile[0]=(TText)('A' + gTheDriveNum); + pritestfile1=pritestfile; + pritestfile.Append(KFilePri2); + pritestfile1.Append(KFilePri3); + + oldName=KOldFile; + oldName[0]=(TText)gDriveToTest; + + r=TheFs.GetShortName(pritestfile, shortfilename); + test(r==KErrPermissionDenied); + + r=TheFs.GetLongName(pritestfile1, longfilename); + test(r==KErrPermissionDenied); + + r=file1.Create(TheFs,oldName,EFileWrite); + test(r==KErrNone || r==KErrAlreadyExists); + file1.Close(); + + r=TheFs.Replace(oldName,pritestfile); + test(r==KErrPermissionDenied); + + r=TheFs.Rename(pritestfile,pritestfile1); + test(r==KErrPermissionDenied); + + r=TheFs.Entry(pritestfile1,entry); + test(r==KErrPermissionDenied); + + // check that the entry for the private directory itself can be retrieved with no error + // - with or without a slash + TPtrC restrictedDir(pritestname.Ptr(), pritestname.Length()); + r=TheFs.Entry(restrictedDir, entry); + test.Printf(_L("RFs::Entry(%S) returned %d"), &restrictedDir, r); + test(r==KErrNone); + test (entry.iAtt & KEntryAttDir); + + TPtrC restrictedDirWithNoBackSlash(restrictedDir.Ptr(), restrictedDir.Length()-1); + r=TheFs.Entry(restrictedDirWithNoBackSlash,entry); + test.Printf(_L("RFs::Entry(%S) returned %d"), &restrictedDirWithNoBackSlash, r); + test(r==KErrNone); + + r=TheFs.SetEntry(pritestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly); + test(r==KErrPermissionDenied); + + r=TheFs.Delete(pritestfile1); + test(r==KErrPermissionDenied); + + } + + +LOCAL_C void privateSIDRFstest() +// +// +// + { + theprivatepath[0]=(TText)gDriveToTest; + test.Printf(_L("the Private Path = %S"),&theprivatepath); + + mkdirname.Zero(); + mkdirname.Append(theprivatepath); + mkdirname.Append(KMkDirSub); + r=TheFs.MkDirAll(mkdirname); + test(r==KErrNone); + + r=TheFs.RmDir(mkdirname); + test(r==KErrNone); + + r=TheFs.SetSubst(theprivatepath,EDriveP); + test(r==KErrPermissionDenied); + + r=TheFs.RealName(_L("P:\\File.XXX"),realName); + test(r==KErrNone); + + r=TheFs.SetSessionPath(theprivatepath); + test(r==KErrNone); + + TheFs.NotifyChange(ENotifyAll,aStat3,theprivatepath); + test(aStat3==KRequestPending); + + + pritestfile=theprivatepath; + pritestfile[0]=(TText)('A' + gTheDriveNum); + pritestfile1=pritestfile; + pritestfile.Append(KFilePri2); + pritestfile1.Append(KFilePri3); + + oldName=KOldFile; + oldName[0]=(TText)gDriveToTest; + + r=TheFs.GetShortName(pritestfile, shortfilename); + test(r==KErrNone || KErrPathNotFound); + + r=TheFs.GetLongName(pritestfile1, longfilename); + test(r==KErrNone || KErrPathNotFound); + + r=file1.Create(TheFs,oldName,EFileWrite); + test(r==KErrNone || r==KErrAlreadyExists); + file1.Close(); + + r=TheFs.Replace(oldName,pritestfile); + test(r==KErrNone); + + r=TheFs.Rename(pritestfile,pritestfile1); + test(r==KErrNone || r==KErrAlreadyExists); + + r=TheFs.Entry(pritestfile1,entry); + test(r==KErrNone); + + //Test Entry with correct SID + r=TheFs.Entry(theprivatepath,entry); + test(r==KErrNone); + + //Test Entry with correct SID and without "//" appended + r=TheFs.Entry(KPrivatePathTest1,entry); + test(r==KErrNone); + + //Test Entry with invalid SID, without // appended + r=TheFs.Entry(KPrivatePathTest2,entry); + test(r==KErrPermissionDenied); + + //Test Entry with invalid SID + r=TheFs.Entry(KPrivatePathTest3,entry); + test(r==KErrPermissionDenied); + + r=TheFs.SetEntry(pritestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly); + test(r==KErrNone); + + r=TheFs.Delete(pritestfile1); + test(r==KErrNone); + + } + + +LOCAL_C void systemRFiletest() +// +// +// + { + r=TheFs.SetSessionPath(systestname); + test(r==KErrPermissionDenied); + + r=file1.Temp(TheFs,systestname,fromTemp,EFileWrite); + test(r==KErrPermissionDenied); + + + TBuf<25> sysfilename; + sysfilename.Append(systestname); + sysfilename.Append(KFileSys); + + r=file1.Create(TheFs,sysfilename,EFileWrite); + test(r==KErrPermissionDenied); + + r=file1.Open(TheFs,sysfilename,EFileWrite); + test(r==KErrPermissionDenied); + + r=file1.Open(TheFs,sysfilename,EFileRead); + test(r==KErrPermissionDenied); + + r=file1.Replace(TheFs,sysfilename,EFileWrite); + test(r==KErrPermissionDenied); + + TFindFile finder(TheFs); + CDir* dir = NULL; + r=finder.FindWildByDir(KWildFile, KWildPath, dir); + if (!(r==KErrPermissionDenied)) + test.Printf(_L("T_DCNONE: test find wildcards r = %d (expected KErrPermissionDenied)\n"), r); + test(r==KErrPermissionDenied); + delete dir; + } + +LOCAL_C void resourceRFiletest() +// +// +// + { + r=TheFs.SetSessionPath(restestname); + test(r==KErrNone); + + r=file1.Temp(TheFs,restestname,fromTemp,EFileWrite); + test(r==KErrPermissionDenied); + file1.Close(); + + r=file1.Create(TheFs,KFileRes,EFileWrite); + test(r==KErrPermissionDenied); + file1.Close(); + + r=file1.Open(TheFs,KFileRes,EFileWrite); + test(r==KErrPermissionDenied); + file1.Close(); + + r=file1.Open(TheFs,KFileRes,EFileRead|EFileShareReadersOnly); + test(r==KErrNone || r==KErrPathNotFound); + file1.Close(); + + r=file1.Open(TheFs,KFileRes,EFileShareReadersOrWriters|EFileRead); + test(r==KErrNone || r==KErrPathNotFound); + file1.Close(); + + r=file1.Open(TheFs,KFileRes,EFileShareReadersOrWriters|EFileWrite); + test(r==KErrPermissionDenied); + file1.Close(); + + r=file1.Open(TheFs,KFileRes,EFileShareReadersOnly); + test(r==KErrNone || r==KErrPathNotFound); + + r=file1.ChangeMode(EFileShareExclusive); //this is not illegal though will prevent shared access to resource which is nit my fault but may be desirable to prevent + test(r==KErrNone || r==KErrPathNotFound); + + //this operation is prevented as you can not open a file for write access in the resource directory + r=file1.Rename(KFileRes3); + test(r==KErrPermissionDenied || r==KErrAccessDenied); + + file1.Close(); + + r=file1.Replace(TheFs,KFileRes,EFileWrite); + test(r==KErrPermissionDenied); + file1.Close(); + + } + + +LOCAL_C void privatefalseIDRFiletest() +// +// +// + { + + r=TheFs.SetSessionPath(pritestfalseidname); + test(r==KErrPermissionDenied); + + r=file1.Temp(TheFs,pritestfalseidname,fromTemp,EFileWrite); + test(r==KErrPermissionDenied); + + TBuf<25> prifilename; + prifilename.Append(pritestname); + prifilename.Append(KFileSys); + + r=file1.Create(TheFs,prifilename,EFileWrite); + test(r==KErrPermissionDenied); + + + r=file1.Open(TheFs,prifilename,EFileWrite); + test(r==KErrPermissionDenied); + + r=file1.Open(TheFs,prifilename,EFileRead); + test(r==KErrPermissionDenied); + + + r=file1.Replace(TheFs,prifilename,EFileWrite); + test(r==KErrPermissionDenied); + + } + + + +LOCAL_C void privateRFiletest() +// +// +// + { + + r=TheFs.SetSessionPath(pritestname); + test(r==KErrPermissionDenied); + + r=file1.Temp(TheFs,pritestname,fromTemp,EFileWrite); + test(r==KErrPermissionDenied); + + TBuf<25> prifilename; + prifilename.Append(pritestname); + prifilename.Append(KFileSys); + + r=file1.Create(TheFs,prifilename,EFileWrite); + test(r==KErrPermissionDenied); + + + r=file1.Open(TheFs,prifilename,EFileWrite); + test(r==KErrPermissionDenied); + + + r=file1.Open(TheFs,prifilename,EFileRead); + test(r==KErrPermissionDenied); + + + r=file1.Replace(TheFs,prifilename,EFileWrite); + test(r==KErrPermissionDenied); + + } + +LOCAL_C void privateSIDRFiletest() +// +// +// + { + + r=TheFs.SetSessionToPrivate(gTheDriveNum); + test(r==KErrNone); + + r=file1.Temp(TheFs,theprivatepath,fromTemp,EFileWrite); + test(r==KErrNone); + file1.Close(); + r=file1.Create(TheFs,KFilePri,EFileWrite); + test(r==KErrNone || r==KErrAlreadyExists); + file1.Close(); + r=file1.Open(TheFs,KFilePri,EFileWrite); + test(r==KErrNone); + file1.Close(); + r=file1.Open(TheFs,KFilePri,EFileRead); + test(r==KErrNone); + file1.Close(); + r=file1.Replace(TheFs,KFilePri,EFileWrite); + test(r==KErrNone); + r=file1.Rename(KFilePri3); + test(r==KErrNone || r==KErrAlreadyExists); + file1.Close(); + + } + + +LOCAL_C void RDirtest() +// +// +// + { + //system + + TBuf<30> dirNameBuf(KSystemPath); + dirNameBuf[0]=(TText)gDriveToTest; + r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal); + test(r==KErrPermissionDenied); + dir.Close(); + r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries); + test(r==KErrPermissionDenied); + dirNameBuf.Zero(); + delete dirEntries; + + dirNameBuf=KPrivateFalseID; + dirNameBuf[0]=(TText)gDriveToTest; + r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal); + test(r==KErrPermissionDenied); + dir.Close(); + r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries); + test(r==KErrPermissionDenied); + dirNameBuf.Zero(); + delete dirEntries; + + //Private + dirNameBuf=KPrivatePath; + dirNameBuf[0]=(TText)gDriveToTest; + r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal); + test(r==KErrPermissionDenied); + dir.Close(); + r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries); + test(r==KErrPermissionDenied); + dirNameBuf.Zero(); + delete dirEntries; + //Private/uid + TheFs.PrivatePath(dirNameBuf); + dirNameBuf.Insert(0,_L("?:")); + dirNameBuf[0]=(TText)gDriveToTest; + r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal); + test(r==KErrNone); + dir.Close(); + r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries); + test(r==KErrNone); + dirNameBuf.Zero(); + delete dirEntries; + //Resource + dirNameBuf=KResourcePath; + dirNameBuf[0]=(TText)gDriveToTest; + r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal); + test(r==KErrNone); + r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries); + test(r==KErrNone); + dir.Close(); + delete dirEntries; + } + + +LOCAL_C void TestNoCaps() +// +// test APIs with no capabilities +// + { + r=TheFs.FileSystemName(fsname,gTheDriveNum); + test(r==KErrNone); + r = DismountFileSystem(TheFs, fsname, gTheDriveNum); + test(r==KErrPermissionDenied); +// r=TheFs.RemoveFileSystem(fsname); //can not test due to bug elsewhere fix exists +// test(r==KErrPermissionDenied); +// r=TheFs.AddFileSystem(fsname); +// test(r==KErrPermissionDenied); + r = MountFileSystem(TheFs, fsname, gTheDriveNum); + test(r==KErrPermissionDenied); + r=TheFs.SetDriveName(gTheDriveNum,KDriveName); + test(r==KErrPermissionDenied); +// r=TheFs.SetVolumeLabel(KVolLable, gTheDriveNum); //broken on wins C: +// test(r==KErrPermissionDenied); + + systemRFstest(); + resourceRFstest(); + privateRFstest(); + privateSIDRFstest(); + privatefalseIDRFstest(); + + systemRFiletest(); + resourceRFiletest(); + privateRFiletest(); + privateSIDRFiletest(); + privatefalseIDRFiletest(); + //disk changes to sys and pri paths should have completed these + test(aStat4 == KRequestPending); + TheFs.NotifyChangeCancel(aStat4); + test(aStat4==KErrCancel); + + + User::WaitForRequest(aStat3); + test(aStat1==KErrPermissionDenied); + test(aStat2==KErrPermissionDenied); + test(aStat3==KErrNone); + + r=TheFs.SetSessionPath(systestname); + test(r==KErrPermissionDenied); + + +//Test RRawDisk class + r=rawdisk.Open(TheFs,gTheDriveNum); + test(r==KErrPermissionDenied); +// rawdisk.Close(); + + r=format.Open(TheFs,driveBuf,EHighDensity,count); + test(r==KErrPermissionDenied); + + RDirtest(); + + driveBuf[0]=(TText)gDriveToTest; + r=TheFs.ScanDrive(driveBuf); + test(r==KErrPermissionDenied); + r=TheFs.CheckDisk(driveBuf); + test(r==KErrPermissionDenied); + } + +LOCAL_C void TestCaps() +// +// test format etc that require certain capabilities +// + { +#ifndef __REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ + const char myDiagMsg[]="Capability Check Failure"; +#endif //!__REMOVE_PLATSEC_DIAGNOSTIC_STRINGS__ + r=RProcess().HasCapability(ECapabilityAllFiles, __PLATSEC_DIAGNOSTIC_STRING(myDiagMsg)); + test(!r); + r=RProcess().HasCapability(ECapabilityTCB, __PLATSEC_DIAGNOSTIC_STRING(myDiagMsg)); + test(!r); + r=RProcess().HasCapability(ECapabilityDiskAdmin, __PLATSEC_DIAGNOSTIC_STRING(myDiagMsg)); + test(!r); + r=RProcess().HasCapability(ECapability_None, __PLATSEC_DIAGNOSTIC_STRING(myDiagMsg)); + test(r); + + driveBuf[0]=(TText)gDriveToTest; + r=TheFs.SessionPath(temp); + test(r==KErrNone); + + r=TheFs.CreatePrivatePath(gTheDriveNum); + test(r==KErrNone || r== KErrAlreadyExists); + + TBuf<18> tempPri; + r=TheFs.PrivatePath(tempPri); + test(r==KErrNone); + theprivatepath = _L("?:"); + theprivatepath.Append(tempPri); + + TestNoCaps(); + + TFileName thesessionpath; + r=TheFs.SetSessionToPrivate(gTheDriveNum); + test(r==KErrNone); + r=TheFs.SessionPath(thesessionpath); + test(r==KErrNone); + + test(thesessionpath == theprivatepath); + + } + + +LOCAL_C void MakeDirs() +// +// Create system and private directories for scan with and without DC +// + { + TInt r; + r = TheFs.MkDir(_L("\\normal\\")); + test(r == KErrNone || r == KErrAlreadyExists); + r = TheFs.MkDir(_L("\\normal\\one\\")); + test(r == KErrNone || r == KErrAlreadyExists); + r = TheFs.MkDir(_L("\\normal\\two\\")); + test(r == KErrNone || r == KErrAlreadyExists); + r = TheFs.MkDir(_L("\\sys\\")); + test(r == KErrPermissionDenied); + r = TheFs.MkDir(_L("\\sys\\one\\")); + test(r == KErrPermissionDenied); + r = TheFs.MkDir(_L("\\sys\\two\\")); + test(r == KErrPermissionDenied); + r = TheFs.MkDir(_L("\\private\\")); + test(r == KErrPermissionDenied); + r = TheFs.MkDir(_L("\\private\\one\\")); + test(r == KErrPermissionDenied); + r = TheFs.MkDir(_L("\\private\\two\\")); + test(r == KErrPermissionDenied); + r = TheFs.MkDir(_L("\\ZZZZZZ\\")); + test(r == KErrNone || r == KErrAlreadyExists); + } + +TFileName dirName; + +LOCAL_C void ScanDir(const TDesC& aName, CDirScan::TScanDirection aDirection, TInt aError) + { + CDirScan* scanner = NULL; + TRAP(r, scanner = CDirScan::NewL(TheFs)); + test(r == KErrNone && scanner); + + TRAP(r, scanner->SetScanDataL(aName,KEntryAttDir,ESortByName|EAscending,aDirection)); + test(r == KErrNone); + + CDir *entryList=NULL; + for (;;) + { + TRAP(r, scanner->NextL(entryList)); + test(r == aError); + if (entryList==NULL) + break; + TInt count=entryList->Count(); + while (count--) + { + TEntry data=(*entryList)[count]; + TBuf path=scanner->AbbreviatedPath(); + dirName = path; + dirName.Append(data.iName); + test.Printf(_L(" %S\n"),&dirName); + + } + delete entryList; + entryList=NULL; + } + delete scanner; + + } + +/** +The following test, tests CFileMan and CDirScan API on folders private and sys +to confirm that any operation on these folders for any app with incorrect capability +returns KErrPermissionDenied. This test step was added as a result of DEF051428 +("PlatSec: Incorrect errors returned by f32") +*/ +LOCAL_C void TestCaging() + { + CFileMan* fMan=CFileMan::NewL(TheFs); + TInt r; + if(fMan!=NULL) + { + + // Checking the private path + TBuf<30> privatepath; + r=TheFs.PrivatePath(privatepath); + test.Printf(_L("Private Path is=%S"),&privatepath); + + r = TheFs.MkDir(_L("\\Caged\\")); + test(r==KErrNone || r==KErrAlreadyExists); + + CDir* entryCount=NULL; + r=TheFs.GetDir(_L("\\*.*"),KEntryAttNormal,ESortNone,entryCount); + test(r==KErrNone); + TInt rootCount= entryCount->Count(); + + delete entryCount; + entryCount=NULL; + + + //Testing Copy + CDir* entryCount2=NULL; + r=fMan->Copy(_L("\\sys\\"),_L("\\Caged\\")); + test(r == KErrPermissionDenied); + r=fMan->Copy(_L("\\*"),_L("\\Caged\\")); + test(r == KErrNone); + + r=TheFs.GetDir(_L("\\Caged\\*.*"),KEntryAttNormal,ESortNone,entryCount2); + test(r==KErrNone); + TInt cagedCount= entryCount2->Count(); + + test(cagedCount==rootCount); + + delete entryCount2; + entryCount2=NULL; + + // Check if both copied sys and private are empty (no information is exposed) + CDir* entryCount3=NULL; + r=TheFs.GetDir(_L("\\Caged\\private\\*.*"),KEntryAttNormal|KEntryAttDir,ESortNone,entryCount3); + test(r==KErrPathNotFound); + delete entryCount3; + entryCount3=NULL; + + CDir* entryCount4=NULL; + r=TheFs.GetDir(_L("\\Caged\\sys\\*.*"),KEntryAttNormal|KEntryAttDir,ESortNone,entryCount4); + test(r==KErrPathNotFound); + delete entryCount4; + entryCount4=NULL; + + + r=fMan->Copy(_L("\\private\\two\\moo"),_L("\\private\\two\\mew")); + test(r == KErrPermissionDenied); + + // Create a test file + RFile testFile; + r = testFile.Replace(TheFs, _L("\\capTest"),EFileWrite); + test(r==KErrNone || r==KErrAlreadyExists); + testFile.Close(); + + TFileName name; + name = privatepath; + name.Append(_L("privateFile.tst")); + RFile privateFile; + r = privateFile.Replace(TheFs, name,EFileWrite); + test(r==KErrNone || r==KErrAlreadyExists); + privateFile.Close(); + + + r=fMan->Copy(_L("\\capTest"),_L("\\private\\two\\moo")); + test(r == KErrPermissionDenied); + r=fMan->Copy(_L("\\capTest"),_L("\\sys\\bin\\moo")); + test(r == KErrPermissionDenied); + r=fMan->Copy(_L("\\sys\\bin\\capTest"),_L("\\sys\\bin\\moo")); + test(r == KErrPermissionDenied); + r=fMan->Copy(_L("\\sys\\*"),_L("\\")); + test (r==KErrPermissionDenied); + r=fMan->Copy(name,_L("\\sys\\")); + test(r==KErrPermissionDenied); + + // Testing Move + r=fMan->Move(_L("\\private\\two\\moo"),_L("\\private\\one\\moo")); + test(r == KErrPermissionDenied); + r=fMan->Move(_L("\\private\\two\\moo.."),_L("\\private\\one\\moo")); + test(r == KErrPermissionDenied); + r=fMan->Move(_L("\\private\\two\\moo"),_L("\\private\\one\\moo..")); + test(r == KErrPermissionDenied); + r=fMan->Move(name,_L("\\privateFile.tst")); + test(r == KErrNone); + r=fMan->Move(_L("\\privateFile.tst"),name); + test(r == KErrNone); + r=fMan->Move(_L("\\capTest"),_L("\\private\\two\\moo")); + test(r == KErrPermissionDenied); + r=fMan->Move(_L("\\capTest"),_L("\\sys\\bin\\moo")); + test(r == KErrPermissionDenied); + r=fMan->Move(_L("\\sys\\bin\\capTest"),_L("\\sys\\bin\\moo")); + test(r == KErrPermissionDenied); + r=fMan->Move(_L("\\sys\\*"),_L("\\")); + test (r==KErrPermissionDenied); + r=fMan->Move(name,_L("\\sys\\")); + test(r==KErrPermissionDenied); + + + // Testing Attribs + r=fMan->Attribs(_L("\\private\\two\\moo"),KEntryAttReadOnly,0,TTime(0)); + test(r == KErrPermissionDenied); + r=fMan->Attribs(_L("\\private\\moo"),KEntryAttReadOnly,0,TTime(0)); + test(r == KErrPermissionDenied); + r=fMan->Attribs(name,KEntryAttReadOnly,0,TTime(0)); + test(r == KErrNone); + r=fMan->Attribs(name,0,KEntryAttReadOnly,TTime(0)); + test(r == KErrNone); + + + // Testing RmDir + r=fMan->RmDir(_L("\\private\\")); + test(r == KErrPermissionDenied); + r=fMan->RmDir(_L("\\private\\two\\")); + test(r == KErrPermissionDenied); + r=fMan->RmDir(_L("\\private\\tw?\\")); + test(r == KErrPermissionDenied); + r=fMan->RmDir(_L("\\sys\\")); + test(r == KErrPermissionDenied); + + + // Testing Rename + r=fMan->Rename(_L("\\private\\two\\moo"),_L("\\private\\two\\mew")); + test(r == KErrPermissionDenied); + + // Testing Delete + r=fMan->Delete(_L("\\private\\two\\test")); + test(r == KErrPermissionDenied); + r=fMan->Delete(_L("\\private\\moo")); + test(r == KErrPermissionDenied); + r=fMan->Delete(_L("\\sys\\moo")); + test(r == KErrPermissionDenied); + + + //Something that actually exists in Private + r=fMan->Rename(name,_L("\\private\\00000001\\moo")); + test(r == KErrNone); + r=fMan->Rename(_L("\\private\\00000001\\moo"),name); + test(r == KErrNone); + r=fMan->Copy(name,_L("\\private\\00000001\\moo")); + test(r == KErrNone); + r=fMan->Delete(_L("\\private\\00000001\\moo")); + test(r == KErrNone); + + // Clean up the test data + r=fMan->RmDir(_L("\\Caged\\")); + test(r == KErrNone); + r=fMan->Delete(_L("\\capTest")); + test(r == KErrNone); + r=fMan->Delete(name); + test(r == KErrNone); + delete(fMan); + } + + // CDirScan tests + ScanDir(_L("\\"), CDirScan::EScanUpTree, KErrNone); + ScanDir(_L("\\"), CDirScan::EScanDownTree, KErrNone); + ScanDir(_L("\\private\\"), CDirScan::EScanDownTree, KErrPermissionDenied); + ScanDir(_L("\\private\\"), CDirScan::EScanUpTree, KErrPermissionDenied); + } +LOCAL_C void CleanDirs() +// +// Remove system and private directories for scan with and without DC +// (note that the \Private directory may not be able to be removed at this +// point if it contains other directories, so failing with "in use" is +// permitted in this case). +// + { + TInt r; + r = TheFs.RmDir(_L("\\normal\\one\\")); + test(r == KErrNone); + r = TheFs.RmDir(_L("\\normal\\two\\")); + test(r == KErrNone); + r = TheFs.RmDir(_L("\\normal\\")); + test(r == KErrNone); + r = TheFs.RmDir(_L("\\sys\\one\\")); + test(r == KErrPermissionDenied); + r = TheFs.RmDir(_L("\\sys\\two\\")); + test(r == KErrPermissionDenied); + r = TheFs.RmDir(_L("\\sys\\")); + test(r == KErrPermissionDenied); + r = TheFs.RmDir(_L("\\private\\one\\")); + test(r == KErrPermissionDenied); + r = TheFs.RmDir(_L("\\private\\two\\")); + test(r == KErrPermissionDenied); + r = TheFs.RmDir(_L("\\private\\")); + test(r == KErrPermissionDenied); + r = TheFs.RmDir(_L("\\ZZZZZZ\\")); + test(r == KErrNone); + } + +TFileName gDirList[100]; +TInt gDirNum = 0; + +LOCAL_C void ListDirs() +// +// List the directories and files on the disk, without DC (so we +// find all of them), saving them in gDirList[] apart from +// members of the System and Private ones. +// + { + CDirScan* scanner = NULL; + TInt r; + TRAP(r, scanner = CDirScan::NewL(TheFs)); + test(r == KErrNone && scanner); + TParse dirName; + TheFs.Parse(_L("\\"),dirName); + TRAP(r, scanner->SetScanDataL(dirName.FullName(),KEntryAttDir,ESortByName|EAscending)); + test(r == KErrNone); + CDir *entryList; + test.Printf(_L("------ ALL DIRECTORIES ------\n")); + for (;;) + { + scanner->NextL(entryList); + if (entryList==NULL) + break; + TInt count=entryList->Count(); + while (count--) + { + TEntry data=(*entryList)[count]; + TBuf path=scanner->AbbreviatedPath(); + gDirList[gDirNum] = path; + gDirList[gDirNum].Append(data.iName); + test.Printf(_L(" %S\n"),&gDirList[gDirNum]); + gDirNum++; + } + delete entryList; + entryList=NULL; + } + delete scanner; + } + +LOCAL_C void TestDirs() +// +// Scan directories and files with DC on, so only the root \Private +// and \System directories should be found (no contents). +// + { + + MakeDirs(); + ListDirs(); + + CDirScan* scanner = NULL; + TInt r; + TRAP(r, scanner = CDirScan::NewL(TheFs)); + test(r == KErrNone && scanner); + TParse dirName; + TheFs.Parse(_L("\\"),dirName); + TRAP(r, scanner->SetScanDataL(dirName.FullName(),KEntryAttDir,ESortByName|EAscending)); + test(r == KErrNone); + CDir *entryList = NULL; + TInt num = 0; + test.Printf(_L("------ ACCESSIBLE DIRECTORIES ------\n")); + for (;;) + { + TRAP(r, scanner->NextL(entryList)); + if (r != KErrNone) + { + test.Printf(_L("*** ERROR %d doing NextL()\n"), r); + break; + } + if (entryList==NULL) + break; + TInt count=entryList->Count(); + while (count--) + { + TEntry data=(*entryList)[count]; + TBuf path=scanner->AbbreviatedPath(); + path.Append(data.iName); + if (path == gDirList[num]) + { + test.Printf(_L("%S\n"),&path); + num++; + } + else + { + test.Printf(_L("%S *** NOT FOUND ***\n"),&path); + } + } + delete entryList; + entryList=NULL; + } + delete scanner; + CleanDirs(); + test(r == KErrNone); + if (num < gDirNum) + { + test.Printf(_L("Directory not as expected (%d found < %d expected\n"), num, gDirNum); + test(0); + } + test.Printf(_L("------------------------------------\n")); + + } + +void TestSystemDrive() + { + test.Next(_L("TestSystemDrive")); + TDriveNumber drive = RFs::GetSystemDrive(); + test.Printf(_L("System Drive is %c:\n"), 'A'+drive); + for(TInt i=EDriveA; i<=EDriveZ; i++) + { + test(TheFs.SetSystemDrive((TDriveNumber)i) == KErrPermissionDenied); + } + TChar drvchar = RFs::GetSystemDriveChar(); + test(drvchar == (TChar)('A' + drive)); + } + +LOCAL_C void CleanupL() +// +// Clean up tests +// + { + test.Next(_L("Delete test directory")); + CFileMan* fMan=CFileMan::NewL(TheFs); + TInt r=fMan->RmDir(gSessionPath); + test(r==KErrNone); + delete fMan; + } + +GLDEF_C void CallTestsL(/*TChar aDriveLetter*/) +// +// Do all tests +// + { + if( !PlatSec::IsCapabilityEnforced(ECapabilityTCB) || + !PlatSec::IsCapabilityEnforced(ECapabilityAllFiles) || + !PlatSec::IsCapabilityEnforced(ECapabilityDiskAdmin)) + { + test.Printf(_L("Insufficient capabilities enabled - leaving t_dcnone")); + test.Printf(_L("\n")); // Prevent overwrite by next print + return; + } + TurnAllocFailureOff(); + TheFs.CharToDrive(gDriveToTest,gTheDriveNum); + + TBuf<30> sesspath; + sesspath=_L("?:\\"); + sesspath[0] = (TText)gDriveToTest; + + TInt r= TheFs.SetSessionPath(sesspath); + test(r==KErrNone); + + TBuf<2> cmd; + cmd.SetLength(1); + cmd[0] = (TText)gDriveToTest; + RProcess tp; + r=tp.Create(_L("clean_prepdc.exe"),sesspath); + test(r==KErrNone); + { + TRequestStatus ps; + tp.Logon(ps); + tp.Resume(); + tp.Close(); + User::WaitForRequest(ps); + } + + //check double mode ie that Defpath still works + RFs fs1; + RFs fs2; + + r=fs1.Connect(); + test(r==KErrNone); + r=fs1.SessionPath(sesspath); + test(r==KErrNone); + test.Printf(_L("session1 Path=%S"),&sesspath); + + TBuf<30> privatepath; + r=fs1.SetSessionToPrivate(gTheDriveNum); + test(r==KErrNone); + r=fs1.PrivatePath(privatepath); + test(r==KErrNone); + r=privatepath.Compare(KExpectedPrivatePath()); + test(r==0); + r=fs1.SessionPath(sesspath); + test(r==KErrNone); + r=privatepath.Compare(sesspath.Mid(KPathPosition)); + test(r==0); + r=fs1.CreatePrivatePath(gTheDriveNum); + test(r==KErrNone); + fs1.Close(); + + r=fs2.Connect(); + test(r==KErrNone); + r=fs2.SessionPath(sesspath); + test(r==KErrNone); + test.Printf(_L("session2 Path=%S"),&sesspath); + fs2.Close(); + + TestCaps(); + TestCaging(); + TestDirs(); + TestPathCheck(); + TestSystemDrive(); + + test.Printf(_L("No of files open=%d"), TheFs.ResourceCount()); + + CleanupL(); + }