void CSenServiceManagerBCTest::DeleteDBL(){
TPtrC file;
TInt fileErr = KErrNone;
CFileMan* fileMan = CFileMan::NewL(iFsSession);
CleanupStack::PushL(fileMan);
fileErr = fileMan->Delete(KSessionsFile);
RDebug::Print( KSessionsFile);
RDebug::Print( _L( "WSModTester: DeleteFileL status %d" ), fileErr );
if(!(fileErr == KErrNone || fileErr == KErrNotFound))
{
User::LeaveIfError(fileErr);
}
fileErr = fileMan->Delete(KIdentitiesFile);
RDebug::Print( _L( "WSModTester: DeleteFileL status %d" ), fileErr );
if(!(fileErr == KErrNone || fileErr == KErrNotFound))
{
User::LeaveIfError(fileErr);
}
CleanupStack::PopAndDestroy();
}
/**
*
* Test step Preamble.
*
* @xxxx
*
*/
enum TVerdict CTestStepConverterSharedHeapMultiFile::DoTestStepPreambleL(void)
{
enum TVerdict verdict;
// this installs the scheduler
verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();
// Printing to the console and log file
INFO_PRINTF1( iTestStepName );
iError = KErrNone; //KErrTimedOut;
if(!GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName7"), iFileName) ||
!GetStringFromConfig(_L("SectionOne"), _L("AudioFNameToConvert"), iFileName2) )
{
INFO_PRINTF1(_L("Failed to find filename"));
return EInconclusive;
}
// Delete the generated file before starting
CFileMan* fileMan;
iFs.Connect();
fileMan = CFileMan::NewL(iFs);
fileMan->Delete(iFileName2);
iFs.Close();
delete fileMan;
fileMan = NULL;
return verdict;
}
// -----------------------------------------------------------------------------
// CSisxUIStartupFile::ClearAllNewFiles
// Deletes all resource files from import directory.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CSisxUIStartupFile::ClearAllNewFiles()
{
TInt result( KErrNone );
RFs fileSess;
CFileMan* fileMan = NULL;
result = fileSess.Connect();
if ( result == KErrNone )
{
TRAP( result, fileMan = CFileMan::NewL( fileSess ) );
}
if ( result == KErrNone )
{
TFileName resFile;
fileSess.PrivatePath( resFile );
resFile.Insert( 0, TParsePtrC( PathInfo::PhoneMemoryRootPath() ).Drive() );
resFile.Append( KImportDir );
resFile.Append( KNewFileMatch );
fileMan->Delete( resFile );
}
delete fileMan;
fileSess.Close();
return result;
}
TInt CSecMgrStore::RemoveTempPolicy(TPolicyID aPolicyID)
{
HBufC *tempPolicyFile = HBufC::NewLC(KMaxName);
TPtr tempPolicyFilePtr(tempPolicyFile->Des());
TInt ret= GetPolicyPath (tempPolicyFilePtr);
if ( (KErrNone==ret) || (KErrAlreadyExists==ret))
{
HBufC *fPolicyName = HBufC::NewLC(KMaxName);
TPtr policyNamePtr(fPolicyName->Des());
policyNamePtr.Num (aPolicyID);
tempPolicyFilePtr.Append (policyNamePtr);
tempPolicyFilePtr.Append (_L("_temp"));
tempPolicyFilePtr.Append (KDatExtn);
CleanupStack::PopAndDestroy(fPolicyName);
}
CFileMan *fm = CFileMan::NewL(iFsSession);
TInt rmTempResult = fm->Delete(tempPolicyFilePtr);
delete fm;
CleanupStack::PopAndDestroy(tempPolicyFile);
return rmTempResult;
}
//This function is used in the test code to kill SCHSVR or MinimalTaskHandler
//processes (or some other) when they leftover and may cause OOM condinitons.
static TInt DeleteScheduleFilesL()
{
RFs fs;
_LIT(KFilePath, "_:\\Private\\10005399\\*.*");
//Get the correct system drive
TBuf<32> filePath(KFilePath);
filePath[0] = RFs::GetSystemDriveChar();
User::LeaveIfError(fs.Connect());
CleanupClosePushL(fs);
CFileMan* fileManager = CFileMan::NewL(fs);
CleanupStack::PushL(fileManager);
TInt ret = fileManager->Delete(filePath);
if(ret != KErrNone && ret != KErrNotFound && ret != KErrPathNotFound)
{
RDebug::Print(_L("DeleteScheduleFilesL - err=%d\n"), ret);
//Resource/memory/file deallocation is not the right place for User::Leave() call!
//Sometimes fileManager->Delete() fails with error "-14" (KErrInUse),
//because SCHSVR server is alive!
//User::Leave(ret);
}
CleanupStack::PopAndDestroy(fileManager);
CleanupStack::PopAndDestroy(); //fs
return KErrNone;
}
/**
Set the current default Contacts database drive and optionally moves the
default Contacts database from the current default drive to the new drive.
@param aDriveUnit New current default Contacts database drive.
@param aCopy ETrue if default Contacts database should be moved to new drive.
*/
void CCntDbManagerController::SetDatabaseDriveL(TDriveUnit aDriveUnit, TBool aCopy)
{
if (aDriveUnit == iDefaultDriveUnit) // Same drive?
{
aCopy = EFalse;
if (iIniFileManager->DatabaseDriveSet())
{
return;
}
}
// Old drive name.
TDriveName oldDrv = iDefaultDriveUnit.Name();
// New drive name.
TDriveName newDrv = aDriveUnit.Name();
TBuf<KCntMaxFilePath> oldPath;
User::LeaveIfError(iFs.PrivatePath(oldPath));
// Drive name goes before the path.
oldPath.Insert(0,oldDrv);
// Filename goes after the path.
oldPath.Append(KSqLiteFilePrefix);
oldPath.Append(KContactsBaseFilename);
TBuf<KCntMaxFilePath> newPath;
User::LeaveIfError(iFs.PrivatePath(newPath));
// Drive name goes before the path.
newPath.Insert(0,newDrv);
// Filename goes after the path.
newPath.Append(KSqLiteFilePrefix);
newPath.Append(KContactsBaseFilename);
// Move the old file to the new drive location.
CFileMan* fileManager = CFileMan::NewL(iFs);
CleanupStack::PushL(fileManager);
// The new file will be overwritten if it exists. If the file or the path
// doesn't exist then it will be created.
if (aCopy)
{
User::LeaveIfError(fileManager->Copy(oldPath, newPath, CFileMan::ERecurse | CFileMan::EOverWrite ));
}
// Change the default drive to the specified drive.
iDefaultDriveUnit = aDriveUnit;
// Save to Contacts initialisation file.
iIniFileManager->SetDefaultDatabaseDrive(iDefaultDriveUnit, ETrue);
iIniFileManager->ScheduleSaveIniFileSettings(CIniFileManager::ESaveDefaultDbDrive);
// Remove the old file.
if (aCopy)
{
(void)fileManager->Delete(oldPath);
}
CleanupStack::PopAndDestroy(fileManager);
}
//The function deletes a file, identified by the aFullPath argument.
//The function leaves if the delete operation error is different than KErrNone and KErrNotFound.
static void DoDeleteTestFileL(CFileMan& aFm, const TDesC& aFullPath)
{
TInt err = aFm.Attribs(aFullPath, 0, KEntryAttReadOnly, TTime(0));
if(err == KErrNone)
{
err = aFm.Delete(aFullPath);
}
if(err != KErrNone && err != KErrNotFound)
{
User::Leave(err);
}
}
TInt DoDeleteTempFiles()
{
CFileMan* fm = NULL;
TRAPD(err, fm = CFileMan::NewL(TheFs));
TEST2(err, KErrNone);
TFileName path;
path.Copy(KPrivateDir);
path.Append(_L("temp\\"));
path.Append(_L("*.$$$"));
err = fm->Delete(path);
delete fm;
return err;
}
void TRepositoryCacheManagerTester::DeleteFilesL()
{
_LIT( KOldInstallFiles, "c:\\private\\10202BE9\\*.ini" );
CFileMan* fm = CFileMan::NewL( iFs );
CleanupStack::PushL( fm );
TInt r = fm->Delete( KOldInstallFiles );
if ( r != KErrNone && r != KErrNotFound && r != KErrPathNotFound )
User::Leave(r);
CleanupStack::PopAndDestroy( fm );
}
// ---------------------------------------------------------
// CPosTp29::ReInitTestL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp29::ReInitTestL()
{
iGlobalErr = KErrNone;
iFile1.Close();
iFile2.Close();
CFileMan* fileMan = CFileMan::NewL(iFileServer);
fileMan->Delete(KFile1);
fileMan->Delete(KFile2);
delete fileMan;
User::LeaveIfError(iFile1.Create(iFileServer, KFile1, EFileWrite));
User::LeaveIfError(iFile2.Create(iFileServer, KFile2, EFileWrite));
}
/**
*
* Test step Postamble.
*
* @xxxx
*
*/
enum TVerdict CTestStepConvertOpen::DoTestStepPostambleL(void)
{
//delete the output file
CFileMan* fileMan;
iFs.Connect();
fileMan = CFileMan::NewL(iFs);
fileMan->Delete(iFileName2);
iFs.Close();
delete fileMan;
fileMan = NULL;
delete iConvert;
iConvert = NULL;
//[ Destroy the scheduler ]
return CTestStepUnitMMFAudClient::DoTestStepPostambleL();
}
/**
*
* Test step Postamble.
*
* @xxxx
*
*/
enum TVerdict CTestStepConverterSharedHeapMultiFile::DoTestStepPostambleL(void)
{
CFileMan* fileMan;
iFs.Connect();
fileMan = CFileMan::NewL(iFs);
fileMan->Delete(iFileName2);
iFs.Close();
delete fileMan;
fileMan = NULL;
// close array
iConverters.Close();
INFO_PRINTF1(_L("finished with this test step"));
//[ Destroy the scheduler ]
return CTestStepUnitMMFAudClient::DoTestStepPostambleL();
}
void TRepositoryCacheManagerTester::InstallIniFileL( TBorderTestStage aFileSet )
{
_LIT( KDriveC, "c:" );
_LIT( KDriveZ, "z:" );
TBuf<KMaxFileName> src1;
TBuf<KMaxFileName> dest1;
TInt r;
DeleteFilesL();
CFileMan* fm = CFileMan::NewL( iFs );
CleanupStack::PushL( fm );
if ((aFileSet>=ELastStage)||(aFileSet<0))
{
RDebug::Print( _L( "Illegal parameter to function: %d\r\n" ), aFileSet );
TheTest( EFalse, __LINE__ );
}
else
{
dest1.Copy( KDriveC );
dest1.Append( KCacheMgrIniFileFolder );
dest1.Append( KCacheMgrIniFile );
r = fm->Delete( dest1 );
if ( r != KErrNone && r != KErrNotFound && r != KErrPathNotFound )
User::Leave( r );
r = iFs.MkDirAll( dest1 );
if ( r != KErrNone && r != KErrAlreadyExists )
User::Leave( r );
src1.Copy( KDriveZ );
src1.Append( KCacheMgrIniFileFolder );
src1.Append( KCacheMgrIniSrcFile );
TBuf<2> testNo;
testNo.Num(aFileSet);
src1.Append( testNo );
User::LeaveIfError( fm->Copy( src1, dest1 ) );
r = fm->Attribs( dest1, KEntryAttArchive, KEntryAttReadOnly, TTime( 0 ), CFileMan::ERecurse );
TEST2( r, KErrNone );
}
CleanupStack::PopAndDestroy( fm );
}
void CHttpCacheManager::DeleteMarkedFilesL( CHttpCacheFileHash* aOnDiskFilesMap, RFs& aRfs )
{
//Step 3. Delete all files on disk that don't belong to any of the Cache Handlers.
CFileMan* fileMan = CFileMan::NewL( aRfs );
THttpCacheFileHashIter iter( aOnDiskFilesMap->HashMap() );
const TDesC* key;
while ((key = iter.NextKey()) != 0)
{
const TFileInfo* value ( (iter.CurrentValue()) );
if( value->iUserInt == KCacheFileNeedsDelete )
{
TPtrC ext( key->Right(KIndexFileExtension().Length()) );
if ( ext.CompareF( KIndexFileExtension ) != 0 && // ignore any .dat index files
ext.CompareF( KValidationFileExtension ) != 0 ) // ignore any .val files
{
fileMan->Delete( *key );
}
}
}
delete fileMan;
}
// ---------------------------------------------------------
// CPosTp29::TryRestoreResourceFile
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp29::TryRestoreResourceFile()
{
iLog->Put(_L("TryRestoreResourceFile"));
CFileMan* fileMan = NULL;
TRAPD(err, fileMan = CFileMan::NewL(iFileServer));
User::LeaveIfError(err);
if (fileMan)
{
// Try to restore the backup up rsc-file (only possible when LM FW is not flashed.
TInt result = fileMan->Copy(KInternalServicesResFileBackup, KInternalServicesResFileCdrive, CFileMan::EOverWrite);
if (result == KErrNotFound)
{
if (BaflUtils::FileExists(iFileServer, KInternalServicesResFileRom))
{
// LM FW is flashed. We need to remove the rsc-file on c:
fileMan->Delete(KInternalServicesResFileCdrive);
}
}
delete fileMan;
}
}
void CTestMessageConverterManager::TestStartConversion()
{
_LIT(KFunction,"TestStartConversion");
INFO_PRINTF1(KFunction);
RFs fs;
User::LeaveIfError(fs.Connect());
CFileMan* fileMngr = CFileMan::NewL(fs);
CleanupStack::PushL(fileMngr);
TPtrC drive;
// create the directories
fs.MkDirAll(_L("D:\\private\\1000484b\\mail2\\"));
fs.MkDirAll(_L("E:\\private\\1000484b\\mail2\\"));
// cleanup mesasging.db in drive D
TRAPD(err,fileMngr->Delete(KDbFileName));
MY_ASSERT_EQUALS(err, KErrNone);
//copy mail2
TRAP(err, fileMngr->Copy(KConverterMail2Folder,KMail2FolderPathD,2));
MY_ASSERT_EQUALS(err, KErrNone);
CleanupStack::PopAndDestroy(fileMngr);
fs.Close();
_LIT(KStartMessageStoreConversionL,"Starting Conversion on Drive D, this request will be cancelled after some time so that we can resume conversion in the next step");
INFO_PRINTF1(KStartMessageStoreConversionL);
//Conversion request
TDriveNumber driveNumber = EDriveD;
TAny* conversionStatus = &driveNumber;
_LIT(KConverterTestThread,"StartMessageStoreConversion");
err = iConverterThread.Create(KConverterTestThread, &CMessageConverterManager::StartConversion,KDefaultStackSize*8,KMinHeapSize,0x8000000,conversionStatus,EOwnerThread);
// Request for notification
TRAPD(error, iConverterThread.Logon(iActiveWaiter->iStatus);)
/**
*
* Test step Preamble.
*
* @xxxx
*
*/
enum TVerdict CTestStepConvertOpen::DoTestStepPreambleL(void)
{
enum TVerdict verdict;
// this installs the scheduler
verdict = CTestStepUnitMMFAudClient::DoTestStepPreambleL();
if (verdict != EPass)
return verdict;
// Printing to the console and log file
INFO_PRINTF1(_L("MM-MMF-ACLNT-U-0551-CP"));
INFO_PRINTF1(_L("this is a test of CMdaAudioConvertUtility::OpenL(file1, file2) "));
if(!GetStringFromConfig(_L("SectionOne"), _L("AudioPlayFName7"), iFileName) ||
!GetStringFromConfig(_L("SectionOne"), _L("AudioFNameToConvert"), iFileName2) )
{
//INFO_PRINTF2(_L("file name %s not found..."), iFileName);
//INFO_PRINTF2(_L(" or file name %s not found..."), iFileName2);
INFO_PRINTF1(_L("Failed to find filename"));
return EInconclusive;
}
// Delete the generated file before starting
CFileMan* fileMan;
iFs.Connect();
fileMan = CFileMan::NewL(iFs);
fileMan->Delete(iFileName2);
iFs.Close();
delete fileMan;
fileMan = NULL;
// create the Recorder utility
if ( (iConvert = CMdaAudioConvertUtility::NewL(*this)) == NULL )
return EInconclusive;
return EPass;
}
void CCentRepToolSession::PerformRFSL()
{
RDEBUG("CentRepToolSession: Restore factory setting operation started");
//RFS tasks in centrep tool
// 1. restory setting enforcements
// 2. remove backup and temp files from private directory
//clean private directory
RFs rfs;
TInt err = rfs.Connect();
if( err != KErrNone )
{
RDEBUG_2("**** CCentRepToolSession::PerformRFSL() - failed to connect to RFs: %d", err );
return;
}
CleanupClosePushL( rfs);
TBuf<100> privatePath;
err = rfs.PrivatePath( privatePath);
if ( err == KErrNone)
{
//remove files from private directory, also backups
CFileMan* file = CFileMan::NewL( rfs);
privatePath.Append(_L("*.*"));
err = file->Delete( privatePath, CFileMan::ERecurse);
delete file;
}
CleanupStack::PopAndDestroy( &rfs);
RDEBUG("CentRepToolSession: Restore factory setting operation finished");
}
void IntegrityDeleteFileL(const TDesC& aPath, CIntegrityTreeLeaf* aLeaf, RFs& aFs,
RLoader& aLoader, CFileMan& aFileMan)
{
_LIT(KSysBin, "\\sys\\bin");
RBuf name;
name.CreateL(aPath, KMaxFileName);
CleanupClosePushL(name);
name.Append(aLeaf->Name());
TEntry entry;
TInt err = aFs.Entry(name, entry);
if (err == KErrNone)
{
aFs.SetAtt(name, 0, KEntryAttReadOnly);
if(entry.IsDir())
{
// Make sure to append slash before calling RmDir - otherwise it deletes the parent directory
if (name[name.Length()-1] != KPathDelimiter)
{
name.Append(KPathDelimiter);
}
User::LeaveIfError(aFileMan.RmDir(name));
}
else
{
if ( aLeaf->Type() == EBackupFile ) // Implies a commit operation is in progress
{
if ( IsBinary(entry) )
{
// Forming the file name so the renamed file can be under sys/bin
// for special delete mechanism using RLoader::Delete
RBuf tmpName;
TParsePtrC fileName(name);
tmpName.CreateL(name.Length() + KSysBin.iTypeLength);
CleanupClosePushL(tmpName);
tmpName.Append(fileName.Drive());
tmpName.Append(KSysBin);
tmpName.Append(fileName.Path());
tmpName.Append(fileName.NameAndExt());
DEBUG_PRINTF3(_L("Integrity Services - Renaming %S to %S"), &name, &tmpName);
aFileMan.Rename(name,tmpName,CFileMan::EOverWrite);
User::LeaveIfError(aLoader.Delete(tmpName)); // Using RLoader delete for paged binaries
DEBUG_PRINTF2(_L("Integrity Services - Deleted renamed file %S"), &tmpName);
// prune the directory tree if possible
RemoveDirectoryTreeL(aFs, tmpName);
CleanupStack::PopAndDestroy(&tmpName);
}
else
{
User::LeaveIfError(aFileMan.Delete(name));
}
}
else
{
// Need to use RLoader Delete which can be used during deletion of Added files during Rollback
User::LeaveIfError(aLoader.Delete(name));
}
}
// prune the directory tree if possible
RemoveDirectoryTreeL(aFs, name);
}
else if(err != KErrNotFound && err != KErrPathNotFound)
{
DEBUG_PRINTF3(_L("Integrity Services - error %d removing %S"), err, &name);
User::Leave(err);
}
else
{
DEBUG_PRINTF3(_L("Integrity Services - error %d removing %S"), err, &name);
// Check for any renamed files to move it to sys/bin for special delete mechanism
RBuf tmpName;
TParsePtrC fileName(name);
tmpName.CreateL(name.Length() + KSysBin.iTypeLength);
CleanupClosePushL(tmpName);
tmpName.Append(fileName.Drive());
tmpName.Append(KSysBin);
tmpName.Append(fileName.Path());
tmpName.Append(fileName.NameAndExt());
DEBUG_PRINTF2(_L("Integrity Services - Removing %S renamed binary files if any"), &tmpName);
aLoader.Delete(tmpName);
// prune the directory tree if possible
RemoveDirectoryTreeL(aFs, tmpName);
CleanupStack::PopAndDestroy(&tmpName);
}
CleanupStack::PopAndDestroy(&name);
}
// ---------------------------------------------------------------------------
// 2nd phase constructor
// ---------------------------------------------------------------------------
//
void CCatalogsHttpDownloadManager::ConstructL( TBool aCleanup )
{
DLTRACEIN((""));
User::LeaveIfError( iFs.Connect() );
// shared so that RFiles can be given to Download manager
User::LeaveIfError( iFs.ShareProtected() );
QString DmgrUid(QString::number(KNCDEngineAppID));
iDmgr = new DownloadManager(DmgrUid);
iDmgr->initialize();
iQTmgr = new CCatalogsHttpQTDownloadManager(this,iDmgr);
TUid sessionId( TUid::Uid( iSessionId ) );
if ( aCleanup )
{
DLTRACE(("Cleaning download manager before connecting"));
TUidName client( CleanUidName( sessionId ) );
TPath path;
path.Format( KCatalogsDownloadMgrPath, &client );
CFileMan* fileman = CFileMan::NewL( iFs );
CleanupStack::PushL( fileman );
DLINFO(( _L("Clearing directory: %S"), &path ));
// Ignoring errors
fileman->Delete( path );
CleanupStack::PopAndDestroy( fileman );
}
// Connect with the download manager
// If the 3rd parameter == ETrue, this session inherits downloads
// from other sessions that have the same UID.
TInt err = KErrNone;
TInt retries = KCatalogsDlMgrConnectRetryAttempts;
do
{
if ( err != KErrNone )
{
DLERROR(("DL manager connection failed with err: %d, retry attempts left",
err, retries ));
// This halts the whole thread which is not nice but shouldn't
// be a problem since this should occur only when the download
// manager is being shutdown when we try to connect to it
User::After( KCatalogsDlMgrConnectRetryInterval );
}
}
while ( err != KErrNone && retries-- );
if( err != KErrNone )
{
DLINFO(("Leaving.. DL manager connection failed with: %d", err ));
User::Leave( err );
}
DLTRACE(("ConnectL ok"));
iDefaultConfig = CCatalogsHttpConfig::NewL();
iNetworkManager = &CCatalogsHttpSessionManager::NetworkManagerL();
iNetworkManager->AddObserverL( *this );
// Restore downloads from previous sessions
// RestoreDownloadsL();
DLTRACEOUT((""));
}
