diff -r 000000000000 -r bde4ae8d615e os/ossrv/lowlevellibsandfws/pluginfw/Framework/SimpleTests/t_hashcheck.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/lowlevellibsandfws/pluginfw/Framework/SimpleTests/t_hashcheck.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,729 @@ +// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "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: +// Contains tests to exercise the hash checking feature for removable drives +// +// + + +#include +#include "../EcomTestUtils/EcomTestUtils.h" +#include +#include +#include "../Example/EComHashExample.h" +#include "../EcomTestUtils/TPropertyManager.h" + +using namespace Swi; + +LOCAL_D RTest test(_L("t_hashcheck.exe")); + +LOCAL_D CTrapCleanup* TheTrapCleanup = NULL; + +LOCAL_D CActiveScheduler* TheActiveScheduler = NULL; + +LOCAL_D RFs TheFs; + +#define UNUSED_VAR(a) a = a + +// Implementaion IDs used for testing +const TUid KUidTestInterface = {0x10009E34}; +const TUid KUidTestImplementation = {0x10009E35}; + +// Plugins used in tests. +_LIT(KEComHashExampleDllOnZ, "z:\\RAMOnly\\EComHashExample.dll"); +_LIT(KEComHashExampleRscOnZ, "z:\\RAMOnly\\EComHashExample.rsc"); + +_LIT(KEComAllRSCFilesName, "\\Resource\\Plugins\\*.rsc"); +_LIT(KEComRscDirName, "\\Resource\\Plugins"); + +#if defined(__WINSCW__) // X: on emulator +_LIT(KEComHashExampleDllOnRemovableDrive, "X:\\sys\\bin\\EComHashExample.dll"); +_LIT(KEComHashExampleRscOnRemovableDrive, "X:\\resource\\plugins\\EComHashExample.rsc"); +#else // E: on hardware +_LIT(KEComHashExampleDllOnRemovableDrive, "E:\\sys\\bin\\EComHashExample.dll"); +_LIT(KEComHashExampleRscOnRemovableDrive, "E:\\resource\\plugins\\EComHashExample.rsc"); +#endif + +// hash files +_LIT(KEComTempHashFileOnC, "c:\\EComTempHashFile.dll"); +_LIT(KEComTempCorruptHashFileOnC, "c:\\EComTempCorruptHashFile.dll"); +_LIT(KEComHashExampleHashFileOnRemovableDrive, "c:\\sys\\hash\\EComHashExample.dll"); +_LIT(KEComCorruptHash, "12345678912345678900"); + +const TInt KHashFileReadSize = 1024*8; + +void CreateTempHashFileL() + { + // Create valid hash file for the DLL to be used during this test. + TInt readsize = KHashFileReadSize; + HBufC8* block0 = HBufC8::NewLC(readsize); + TPtr8 fileblock0(block0->Des()); + CSHA1* hasher=CSHA1::NewL(); + CleanupStack::PushL(hasher); + + RFile file; + CleanupClosePushL(file); + User::LeaveIfError(file.Open(TheFs, KEComHashExampleDllOnZ, EFileRead)); + + TInt size; + User::LeaveIfError(file.Size(size)); + TInt offset=0; + do { + if((size - offset) < readsize) + readsize = (size - offset); + User::LeaveIfError(file.Read(offset, fileblock0, readsize)); + hasher->Update(fileblock0); + offset+=readsize; + } + while(offset < size); + + CleanupStack::PopAndDestroy(1); // file + + TBuf8 hash; + hash=hasher->Final(); + + CleanupStack::PopAndDestroy(2); // block0, hasher + + // write hash to file + RFile tempHashFile; + CleanupClosePushL(tempHashFile); + User::LeaveIfError(tempHashFile.Replace(TheFs, KEComTempHashFileOnC, EFileWrite)); + tempHashFile.Write(hash); + CleanupStack::PopAndDestroy(1); // tempHashFile + } + +void DeleteTempHashFileL() + { + TRAPD(err, EComTestUtils::FileManDeleteFileL(KEComTempHashFileOnC)); + test(err == KErrNone); + } + +void CreateTempCorruptHashFileL() + { + // write corrupt hash to file + TBuf8 hash; + hash.Append(KEComCorruptHash); + RFile tempHashFile; + CleanupClosePushL(tempHashFile); + User::LeaveIfError(tempHashFile.Replace(TheFs, KEComTempCorruptHashFileOnC, EFileWrite)); + tempHashFile.Write(hash); + CleanupStack::PopAndDestroy(1); // tempHashFile + } + +void DeleteTempCorruptHashFileL() + { + TRAPD(err, EComTestUtils::FileManDeleteFileL(KEComTempCorruptHashFileOnC)); + test(err == KErrNone); + } + +void CopyHashFile() + { + TRAPD(err, EComTestUtils::FileManCopyFileL(KEComTempHashFileOnC, + KEComHashExampleHashFileOnRemovableDrive)); + test(err == KErrNone); + } + +void DeleteHashFile() + { + TRAPD(err, EComTestUtils::FileManDeleteFileL(KEComHashExampleHashFileOnRemovableDrive)); + UNUSED_VAR(err); + + // If ECOM server is already running we need to allow some time for re-discovery + // to complete. + WAIT_FOR3s; + } + +void CopyCorruptHashFile() + { + TRAPD(err, EComTestUtils::FileManCopyFileL(KEComTempCorruptHashFileOnC, + KEComHashExampleHashFileOnRemovableDrive)); + test(err == KErrNone); + } + +void CopyPlugins() + { + TRAPD(err, EComTestUtils::FileManCopyFileL(KEComHashExampleDllOnZ, KEComHashExampleDllOnRemovableDrive)); + test(err == KErrNone); + TRAP(err, EComTestUtils::FileManCopyFileL(KEComHashExampleRscOnZ, KEComHashExampleRscOnRemovableDrive)); + test(err == KErrNone); + + // If ECOM server is already running we need to allow some time for re-discovery + // to complete. + WAIT_FOR3s; + } + +void DeletePlugins() + { + TRAPD(err, EComTestUtils::FileManDeleteFileL(KEComHashExampleDllOnRemovableDrive)); + UNUSED_VAR(err); + TRAP(err, EComTestUtils::FileManDeleteFileL(KEComHashExampleRscOnRemovableDrive)); + UNUSED_VAR(err); + + // If ECOM server is already running we need to allow some time for re-discovery + // to complete. + WAIT_FOR3s; + } + + +void DeleteRSCFolderOnDrive(TUint aDriveNum) + { + TInt err=KErrNone; + TDriveUnit aDrive(aDriveNum); + + TBuf<256> resourceFileName; + resourceFileName.Append(aDrive.Name()); + resourceFileName.Append(KEComAllRSCFilesName); + TRAP(err, EComTestUtils::FileManDeleteFileL(resourceFileName)); + + TBuf<256> resourceDirName; + resourceDirName.Append(aDrive.Name()); + resourceDirName.Append(KEComRscDirName); + TRAP(err, EComTestUtils::FileManDeleteDirL(resourceDirName)); + } + +TBool IsImplementationListedL() + { + RImplInfoPtrArray implArray; + REComSession::ListImplementationsL(KUidTestInterface, implArray); + + TBool found = EFalse; + TInt count = implArray.Count(); + while(count) + { + count--; + if(implArray[count]->ImplementationUid() == KUidTestImplementation) + { + found = ETrue; + break; + } + } + REComSession::FinalClose(); + implArray.ResetAndDestroy(); + return found; + } + +TInt IsImplementationCreatedL() + { + TUid dtor_ID_Key; + TAny* ptr = NULL; + TRAPD(err, ptr = REComSession::CreateImplementationL(KUidTestImplementation, dtor_ID_Key)); + + CImplementationHashExample* implPtr = reinterpret_cast (ptr); + + if(err == KErrNone) + { + REComSession::DestroyedImplementation(dtor_ID_Key); + delete implPtr; + } + + REComSession::FinalClose(); + return err; + } + +void DoPreInstall() + { + // Install in progress + PropertyManager::SetProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue, ESASwisInstall); + CopyHashFile(); + WAIT_FOR1s; + + // Install successful + PropertyManager::SetProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue, ESASwisInstall); + WAIT_FOR3s; + + // Reset + PropertyManager::SetProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue, ESASwisNone); + WAIT_FOR1s; + } + +void DoCorruptPreInstall() + { + // Install in progress + PropertyManager::SetProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue, ESASwisInstall); + CopyCorruptHashFile(); + WAIT_FOR1s; + + // Install successful + PropertyManager::SetProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue, ESASwisInstall); + WAIT_FOR3s; + + // Reset + PropertyManager::SetProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue, ESASwisNone); + WAIT_FOR1s; + } + +void DoPreUninstall() + { + // Uninstall in progress + PropertyManager::SetProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue, ESASwisUninstall); + DeleteHashFile(); + WAIT_FOR1s; + + // Uninstall successful + PropertyManager::SetProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue, ESASwisUninstall); + WAIT_FOR3s; + + // Reset + PropertyManager::SetProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue, ESASwisNone); + WAIT_FOR1s; + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-1922 +@SYMTestCaseDesc Test that implementation on removable drive is not available + when no hash file has been installed. +@SYMTestPriority High +@SYMTestActions Copy plugins to removable drive. + Call ListImplementations() and CreateImplementation() + Check implementation is unavailable. +@SYMTestExpectedResults The test must not fail. +@SYMDEF PDEF090578 +*/ +LOCAL_C void TestNoHashFileInstalledL() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-1922 ")); + __UHEAP_MARK; + + // Test ListImplementations() + CopyPlugins(); + TBool implListed = IsImplementationListedL(); + + // Check implementation + // On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's + // on the X drive. Because of this the implementation will not be listed. + // + // On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash + // is available for the DLL. In this case there is no hash so the implementation is + // not listed. + test(!implListed); + + // Test CreateImplementation() + TInt implCreated = IsImplementationCreatedL(); + + // Check implementation + // On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's + // on the X drive. Because of this the implementation will not be created. + // + // On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash + // is available for the DLL. In this case there is no hash so the implementation is + // not created. + test(implCreated == KErrNotFound); + + DeletePlugins(); + __UHEAP_MARKEND; + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-1923 +@SYMTestCaseDesc Test that implementation on removable drive is available + when a Pre Install occurs exists. +@SYMTestPriority High +@SYMTestActions Copy plugins to removable drive. + Call ListImplementations() and CreateImplementation() + Check implementation is unavailable. + Emulate pre-install. + Call ListImplementations() and CreateImplementation() + Check implementation is available. + Emulate uninstall. + Call ListImplementations() and CreateImplementation() + Check implementation is unavailable. +@SYMTestExpectedResults The test must not fail. +@SYMDEF PDEF090578 +*/ +LOCAL_C void TestPreInstallL() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-1923 ")); + __UHEAP_MARK; + + // Only copy plugins - during pre-install plugins exists before the install occurs + CopyPlugins(); + + // Test ListImplementations() + TBool implListed = IsImplementationListedL(); + + // Check implementation + // On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's + // on the X drive. Because of this the implementation will not be listed. + // + // On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash + // is available for the DLL. In this case there is no hash because install has not occurred + // so the implementation is not listed. + test(!implListed); + + // Test CreateImplementation() + // No hash so no implementation should be created. + TInt implCreated = IsImplementationCreatedL(); + + // Check implementation + // On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's + // on the X drive. Because of this the implementation will not be created. + // + // On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash + // is available for the DLL. In this case there is no hash because install has not occurred + // so the implementation is not created. + test(implCreated == KErrNotFound); + + // Do install + DoPreInstall(); + + // Test ListImplementations() + implListed = IsImplementationListedL(); + + _LIT(KMessage3,"Pre-Install 3: List = %d"); + RDebug::Print(KMessage3, implListed); + // Check implementation +#if defined(__WINSCW__) + // On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's + // on the X drive. Because of this the implementation will not be listed. + // + test(!implListed); +#else + // On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash + // is available for the DLL. In this case there is a hash so the implementation is + // listed. + test(implListed); +#endif + + // Test CreateImplementation() + implCreated = IsImplementationCreatedL(); + + // Check implementation was created +#if defined(__WINSCW__) + // On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's + // on the X drive. Because of this the implementation will not be created. + // + test(implCreated == KErrNotFound); +#else + // On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash + // is available for the DLL. In this case there is a hash so the implementation is + // created. + test(implCreated == KErrNone); +#endif + + __UHEAP_MARKEND; + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-1924 +@SYMTestCaseDesc Test that implementation on removable drive is unavailable + after an uninstall occurs. +@SYMTestPriority High +@SYMTestActions Emulate uninstall. + Call ListImplementations() and CreateImplementation() + Check implementation is unavailable. +@SYMTestExpectedResults The test must not fail. +@SYMDEF PDEF090578 +*/ +LOCAL_C void TestPreUninstallL() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-1924 ")); + __UHEAP_MARK; + + // Do uninstall + DoPreUninstall(); + + // Test ListImplementations() + TBool implListed = IsImplementationListedL(); + + // Check implementation + // On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's + // on the X drive. Because of this the implementation will not be listed. + // + // On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash + // is available for the DLL. In this case there is no hash so the implementation is + // not listed. + test(!implListed); + + // Test CreateImplementation() + TInt implCreated = IsImplementationCreatedL(); + + // Check implementation + // On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's + // on the X drive. Because of this the implementation will not be created. + // + // On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash + // is available for the DLL. In this case there is no hash so the implementation is + // not created. + test(implCreated == KErrNotFound); + + DeletePlugins(); + __UHEAP_MARKEND; + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-1925 +@SYMTestCaseDesc Test that implementation on removable drive is unavailable + if the hash is corrupted for the DLL. +@SYMTestPriority High +@SYMTestActions Emulate pre-install with a corrupted hash file. + Call ListImplementations() and CreateImplementation() + Check implementation is unavailable. +@SYMTestExpectedResults The test must not fail. +@SYMDEF PDEF090578 +*/ +LOCAL_C void TestCorruptHashL() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-1925 ")); + __UHEAP_MARK; + + // Only copy plugins - during pre-install plugins exists before the install occurs + CopyPlugins(); + + // Do pre install + DoCorruptPreInstall(); + + // Test ListImplementations() + TBool implListed = IsImplementationListedL(); + + // Check implementation + // On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's + // on the X drive. Because of this the implementation will not be listed. + // + // On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash + // is available for the DLL. In this case the hash file is corrupted so the implementation is + // not listed. + test(!implListed); + + // Test CreateImplementation() + TInt implCreated = IsImplementationCreatedL(); + + // Check implementation + // On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's + // on the X drive. Because of this the implementation will not be created. + // + // On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash + // is available for the DLL. In this case the hash file is corrupted so the implementation is + // not created. + test(implCreated == KErrNotFound); + + DeletePlugins(); + DeleteHashFile(); + __UHEAP_MARKEND; + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-1926 +@SYMTestCaseDesc Test that implementation on removable drive is available + when a full Install occurs exists. +@SYMTestPriority High +@SYMTestActions Copy plugins to removable drive. + Emulate pre-install. + Call ListImplementations() and CreateImplementation() + Check implementation is available. +@SYMTestExpectedResults The test must not fail. +@SYMDEF PDEF090578 +*/ +LOCAL_C void TestFullInstallL() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-1926 ")); + __UHEAP_MARK; + + // Only copy plugins - during pre-install plugins exists before the install occurs + CopyPlugins(); + // Do install + DoPreInstall(); + + // Test ListImplementations() + TBool implListed = IsImplementationListedL(); + + // Test CreateImplementation() + TInt implCreated = IsImplementationCreatedL(); + +#if defined(__WINSCW__) + // On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's + // on the X drive. Because of this the implementation will not be listed and + // the implementation will not be created. + test(!implListed); + test(implCreated == KErrNotFound); +#else + // On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash + // is available for the DLL. In this case there is a valid hash so the implementation is + // listed and created. + test(implListed); + test(implCreated == KErrNone); +#endif + + __UHEAP_MARKEND; + } +/** +@SYMTestCaseID SYSLIB-ECOM-CT-1927 +@SYMTestCaseDesc Test that implementation on removable drive is unavailable + after an uninstall occurs. +@SYMTestPriority High +@SYMTestActions Emulate uninstall. + Call ListImplementations() and CreateImplementation() + Check implementation is unavailable. +@SYMTestExpectedResults The test must not fail. +@SYMDEF PDEF09057 +*/ +LOCAL_C void TestFullUninstallL() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-1927 ")); + __UHEAP_MARK; + + //Clean up DLL on remove drive + DeletePlugins(); + + //Clean up the hash file related the DLL + DoPreUninstall(); + + // Test ListImplementations() + TBool implListed = IsImplementationListedL(); + + // Check implementation + // On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's + // on the X drive. Because of this the implementation will not be listed. + // + // On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash + // is available for the DLL. In this case there is no plugin and no hash so the implementation + // is not listed. + test(!implListed); + + // Test CreateImplementation() + TInt implCreated = IsImplementationCreatedL(); + // Check implementation + // On the emulator RLibrary::GetInfo() always returns KErrNotFound for DLL's + // on the X drive. Because of this the implementation will not be created. + // + // On hardware ECOM uses RLoader::CheckLibraryHash() to determine if the hash + // is available for the DLL. In this case there is no plugins and no hash file so the + // implementation is not created. + test(implCreated == KErrNotFound); + + __UHEAP_MARKEND; + } + +typedef void (*ClassFuncPtrL) (void); + +/** +Wrapper function to call all test functions + +@param testFuncL pointer to test function +@param aTestDesc test function name +*/ +LOCAL_C void DoBasicTestL(ClassFuncPtrL testFuncL, const TDesC& aTestDesc) + { + test.Next(aTestDesc); + + __UHEAP_MARK; + // find out the number of open handles + TInt startProcessHandleCount; + TInt startThreadHandleCount; + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount); + + //Call the test function + (*testFuncL)(); + + // check that no handles have leaked + TInt endProcessHandleCount; + TInt endThreadHandleCount; + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount); + + test(startThreadHandleCount == endThreadHandleCount); + + __UHEAP_MARKEND; + } + +LOCAL_C void DoTestsL() + { + __UHEAP_MARK; + +//If it is hardware and E: drive deosn't exist, don't run the test. +#if (!defined(__WINSCW__)) + if(!TheFs.IsValidDrive(EDriveE)) + { + test.Printf(_L("E: drive doesn't exist, the test won't be able to run \n")); + return; + } +#endif + + // Basic tests + test.Next(_L("Basic Test Suite")); + test.Start(_L("Basic Test Suite")); + DoBasicTestL(&TestPreInstallL, _L("TestPreInstallL")); + DoBasicTestL(&TestPreUninstallL, _L("TestPreUninstallL")); + + DoBasicTestL(&TestFullInstallL, _L("TestFullInstallL")); + DoBasicTestL(&TestFullUninstallL, _L("TestFullUninstallL")); + + DoBasicTestL(&TestNoHashFileInstalledL, _L("TestNoHashFileInstalledL")); + DoBasicTestL(&TestCorruptHashL, _L("TestCorruptHashL")); + test.End(); + + __UHEAP_MARKEND; + } + + +//Initialise the Active Scheduler +// +LOCAL_C void SetupL() + { + // Construct and install the Active Scheduler. The Active Schedular is needed + // by components used by this test as they are ActiveObjects. + TheActiveScheduler = new(ELeave)CActiveScheduler; + CActiveScheduler::Install(TheActiveScheduler); + + // create hash files + CreateTempHashFileL(); + CreateTempCorruptHashFileL(); + + //Define swinstall property + PropertyManager::DefineProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue,RProperty::EInt); + + // Initialise swinstall property + PropertyManager::SetProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue, ESASwisNone); + } + +GLDEF_C TInt E32Main() + { + __UHEAP_MARK; + + test.Printf(_L("\n")); + test.Title(); + test.Start(_L("Hash Tests")); + + TheTrapCleanup = CTrapCleanup::New(); + + //Delete swinstall property if it already exists + PropertyManager::DeleteProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue); + + TInt err = TheFs.Connect(); + test(err == KErrNone); + TRAP(err, SetupL()); + test(err == KErrNone); + + + // Perform tests. + TRAP(err,DoTestsL()); + test(err==KErrNone); + + DeleteTempHashFileL(); + DeleteTempCorruptHashFileL(); + + //Delete swinstall property + PropertyManager::DeleteProperty(KUidSystemCategory, KSAUidSoftwareInstallKeyValue); + +#if !defined(__WINSCW__) + DeleteRSCFolderOnDrive(EDriveE); +#endif + + delete TheActiveScheduler; + TheFs.Close(); + delete TheTrapCleanup; + + test.End(); + test.Close(); + + __UHEAP_MARKEND; + return (KErrNone); + }