635 void CSisRegistrySession::DeleteEntryL(const CSisRegistryObject& aObject, TInt64 aTransactionId, TBool aRegenerateCache/*=ETrue*/)

   636     {

   637     // Create a integrity service object

   638     CIntegrityServices* integrityService = CIntegrityServices::NewLC(aTransactionId, KIntegrityServicesPath);

   639     Server().Cache().RemoveRegistryEntryL(aObject, *integrityService);

   640 

   641     //If removal is for ROM upgrade type, 

   642     //After removing the existing registry entry set,

   643     //re generate the Registry Entry Cache. 

   644     //If any of the ROM based stub doesn't have it's registry set 

   645     //in appropriate path, it will create them (.reg & . ctl) 

   646     //from the ROM based stub sis file. 

   647     if ((aObject.InstallType() == Sis::EInstInstallation || 

   648             aObject.InstallType() == Sis::EInstPartialUpgrade) &&  

   649                 SisRegistryUtil::RomBasedPackageL(aObject.Uid()) &&

   650                     aRegenerateCache)

   651         {   

   652         Server().Cache().RegenerateCacheL();                    

   653         }       

   654             

   655     HBufC* logName = SisRegistryUtil::BuildLogFileNameLC();

   656     

   657     TDriveUnit sysDrive(RFs::GetSystemDrive());

   658     TBuf<128> logDir = sysDrive.Name();

   659     logDir.Append(KLogDir);

   660     

   661     if( SisRegistryUtil::FileExistsL(iFs,*logName))

   662         {

   663         TInt sizeOfFile = 0;

   664         RFile file;

   665         User::LeaveIfError(file.Open(iFs,logDir,EFileRead));

   666         CleanupClosePushL(file);

   667         User::LeaveIfError(file.Size(sizeOfFile));

   668         RBuf8 text;

   669         text.CreateL(sizeOfFile);

   670         text.CleanupClosePushL();

   671         file.Read(text,sizeOfFile);

   672         file.Close();

   673         integrityService->RemoveL(*logName);

   674         User::LeaveIfError(file.Create(iFs,logDir,EFileWrite| EFileShareExclusive |EFileStream));

   675         User::LeaveIfError(file.Write(text,sizeOfFile));

   676         CleanupStack::PopAndDestroy(2,&file);

   677         }           

   678     integrityService->AddL(*logName);

   679     Server().Cache().AddLogEntryL(aObject,ESwiLogUnInstall);    

   680         

   681     CleanupStack::PopAndDestroy(2, integrityService);// logName,integrityService    

   682     }

  1859 				sidObject = NULL;

  2337 

  2338 void CSisRegistrySession::DriveFormatDetectedL(TDriveUnit aDrive)

  2339     {   

  2340     DEBUG_PRINTF2(_L("Sis Registry Server - Drive format detected for drive %d"), static_cast<TInt>(aDrive));

  2341     

  2342     //Get the list of tokens.    

  2343     const RPointerArray <CSisRegistryToken>& tokensArray = Server().Cache().TokenList();

  2344 

  2345     TTime currentTime;

  2346     currentTime.UniversalTime();

  2347     TInt64 transactionId = currentTime.Int64();

  2348     

  2349     TBool regenerateCache = EFalse;

  2350     

  2351     TInt i(0);

  2352     

  2353     while(i < tokensArray.Count())

  2354         {

  2355         TUint installedDrives = tokensArray[i]->Drives();

  2356         

  2357         // Look for the formatted drive in the list of installed drives.

  2358         if(installedDrives & (1 << aDrive))

  2359             {

  2360             CSisRegistryObject* object = Server().Cache().ObjectL(*tokensArray[i]);

  2361 			CleanupStack::PushL(object);

  2362             

  2363             if (!regenerateCache && 

  2364                     (object->InstallType() == Sis::EInstInstallation || object->InstallType() == Sis::EInstPartialUpgrade) &&

  2365                          SisRegistryUtil::RomBasedPackageL(object->Uid()))

  2366                 {   

  2367                 regenerateCache = ETrue;                   

  2368                 }  

  2369             

  2370             // Retrieve all the associated files.

  2371             const RPointerArray<CSisRegistryFileDescription>& fileDescriptions = object->FileDescriptions();

  2372            

  2373             _LIT(KHashPathFormat, "%c:\\sys\\hash\\%S");

  2374             

  2375             for(TInt j=0; j<fileDescriptions.Count(); ++j)

  2376                 {

  2377                 const TDesC& targetPath = fileDescriptions[j]->Target();

  2378                 DEBUG_PRINTF2(_L("File - %S "), &targetPath);

  2379                 

  2380                 // Get the drive on which the file is present.

  2381                 TInt drive; 

  2382                 User::LeaveIfError(RFs::CharToDrive(targetPath[0], drive));

  2383                 

  2384                 // If the file is a binary ( present in \sys\bin), delete the corresponding hash present in 

  2385                 // C:\sys\hash               

  2386                 

  2387                 if(KErrNotFound != targetPath.FindF(KBinPath))

  2388                     {

  2389                     // Retrieve the filename from the target path.

  2390 					TParsePtrC parser(targetPath); 

  2391                     HBufC* fileName = parser.NameAndExt().AllocLC();

  2392                                        

  2393                     TChar systemDrive = RFs::GetSystemDriveChar();

  2394                     

  2395                     // Create the hash file path.

  2396                     RBuf hashFilePath;

  2397                     hashFilePath.CreateL(KMaxPath);

  2398                     CleanupClosePushL(hashFilePath);

  2399                     hashFilePath.Format(KHashPathFormat, static_cast<TUint>(systemDrive), fileName);

  2400                     

  2401                     // Delete hash file.

  2402                     SisRegistryUtil::DeleteFile(iFs, hashFilePath); //Ignore return code. 

  2403                     

  2404                     CleanupStack::PopAndDestroy(2, fileName);

  2405                     

  2406                     }

  2407                 

  2408                 if(aDrive == TDriveUnit(drive))

  2409                     {

  2410                     // File should not exist on disk as the drive is assumed to have been formatted.

  2411                     continue;

  2412                     }

  2413                 SisRegistryUtil::DeleteFile(iFs, targetPath); //Ignore return code.          

  2414                 }

  2415             

  2416             // Delete registry entry.

  2417             DeleteEntryL(*object, transactionId, EFalse);

  2418             CleanupStack::PopAndDestroy(object);

  2419             }

  2420         else

  2421             {

  2422             // Increment only in case an entry is not found.

  2423             i++;

  2424             }

  2425         }

  2426     

  2427     if(regenerateCache)

  2428         {

  2429         Server().Cache().RegenerateCacheL();

  2430         }

  2431     

  2432     // Commit the changes.

  2433     CIntegrityServices* intServ = CIntegrityServices::NewLC(transactionId, KIntegrityServicesPath);

  2434     intServ->CommitL();

  2435     CleanupStack::PopAndDestroy(intServ);

  2436     }