--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/installationservices/swi/test/swicaptests/registrycaptest.cpp Thu Dec 17 08:51:10 2009 +0200
@@ -0,0 +1,599 @@
+/*
+* Copyright (c) 2005-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:
+*
+*/
+
+
+/**
+ @file
+*/
+
+#include "registrycaptest.h"
+
+#include "sisregistrywritablesession.h"
+#include "sisregistrywritableentry.h"
+#include "sisregistrysession.h"
+#include "sisregistrypackage.h"
+#include "sisregistryentry.h"
+#include "sisrevocationentry.h"
+#include "sisregistryserver.h"
+#include "application.h"
+#include "sistruststatus.h"
+#include "sisregistryfiledescription.h"
+#include "sisregistrydependency.h"
+#include "userselections.h"
+#include "siscontroller.h"
+#include "filesisdataprovider.h"
+#include "dessisdataprovider.h"
+#include "cleanuputils.h"
+#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
+#include "swtypereginfo.h"
+#endif
+#include <e32def.h>
+#include <f32file.h>
+
+using namespace Swi;
+
+_LIT(KPublicRegistryCapTestName, "Registry public (no caps) interface capability test");
+_LIT(KReadUserDataRegistryCapTestName, "Registry public (ReadUserData) interface capability test");
+_LIT(KPrivateRegistryCapTestName, "Registry private interface capability test");
+_LIT(KDaemonRegistryCapTestName, "Registry daemon interface capability test");
+_LIT(KRevocationRegistryCapTestName, "Registry revocation interface capability test");
+#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
+_LIT(KSifServerRegistryCapTestName, "Registry SIF interface security test");
+#endif
+
+CPublicRegistryCapTest* CPublicRegistryCapTest::NewL()
+ {
+ CPublicRegistryCapTest* self=new(ELeave) CPublicRegistryCapTest();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+CPublicRegistryCapTest::CPublicRegistryCapTest()
+ {
+ }
+
+void CPublicRegistryCapTest::ConstructL()
+ {
+ SetNameL(KPublicRegistryCapTestName);
+ }
+
+void CPublicRegistryCapTest::RunTestL()
+ {
+ Swi::RSisRegistrySession session;
+ CleanupClosePushL(session);
+
+ TInt err = session.Connect();
+
+ if (KErrNone != err)
+ {
+ SetFail();
+ CleanupStack::PopAndDestroy(&session);
+ return;
+ }
+
+ // RSisregistryEntry
+ Swi::RSisRegistryEntry entry;
+
+// open an entry to do tests on
+ TUid uid = { 0x101f7989}; // Package known to exist
+ if (KErrNone != CheckFailL(entry.Open(session, uid), _L("Open(TUid)")))
+ {
+ CleanupStack::PopAndDestroy(&session);
+ return;
+ }
+ CleanupClosePushL(entry);
+
+ TRAP(err, entry.IsSignedL());
+ CheckFailL(err, _L("RSisregistryEntry::IsSignedL"));
+
+ TRAP(err, entry.IsInRomL());
+ CheckFailL(err, _L("RSisregistryEntry::IsInRomL"));
+
+ TRAP(err, entry.VersionL());
+ CheckFailL(err, _L("RSisregistryEntry::VersionL"));
+
+ TRAP(err, entry.LanguageL());
+ CheckFailL(err, _L("RSisregistryEntry::LanguageL"));
+
+ TRAP(err, entry.SelectedDriveL());
+ CheckFailL(err, _L("SelectedDriveL"));
+
+ TRAP(err, entry.TrustStatusL());
+ CheckFailL(err, _L("RSisregistryEntry::TrustStatusL"));
+
+ HBufC* name=NULL;
+ TRAP(err, name = entry.PackageNameL());
+ CleanupStack::PushL(name);
+ CheckFailL(err, _L("RSisregistryEntry::PackageNameL"));
+ CleanupStack::PopAndDestroy(name);
+
+ TRAP(err, name= entry.UniqueVendorNameL());
+ CleanupStack::PushL(name);
+ CheckFailL(err, _L("RSisregistryEntry::UniqueVendorNameL"));
+ CleanupStack::PopAndDestroy(name);
+
+ TRAP(err, entry.LocalizedVendorNameL());
+ CheckFailL(err, _L("RSisregistryEntry::LocalizedVendorNameL"));
+
+
+ RPointerArray<HBufC8> chains;
+ TRAP(err, entry.CertificateChainsL(chains));
+ CleanupResetAndDestroyPushL(chains);
+ CheckFailL(err, _L("RSisregistryEntry::CertificateChainsL"));
+ CleanupStack::PopAndDestroy(&chains);
+
+ TRAP(err, entry.PropertyL(0));
+ CheckFailL(err, _L("RSisregistryEntry::PropertyL"));
+
+ Swi::CSisRegistryPackage* package=NULL;
+ TRAP(err, package=entry.PackageL());
+ delete package;
+ CheckFailL(err, _L("RSisregistryEntry::PackageL"));
+
+ RPointerArray<HBufC8> controllers;
+ TRAP(err, entry.ControllersL(controllers));
+ CleanupResetAndDestroyPushL(controllers);
+ CheckFailL(err, _L("RSisregistryEntry::ControllersL"));
+ CleanupStack::PopAndDestroy(&controllers);
+
+ TUid nonExistentUid ={0};
+ TRAP(err, session.IsInstalledL(nonExistentUid));
+ CheckFailL(err, _L("RSisRegistrySession::IsInstalledL(TUid)"));
+
+ TBuf8<5> controller;
+ TRAP(err, session.IsInstalledL(controller));
+ CheckFailL(err, _L("RSisRegistrySession::IsInstalledL(TDesC8&)"));
+
+// These two are unimplemented in the server
+// TRAP(err, session.HashL(_L("C:\\a filename.txt")));
+// CheckFailL(err, _L("RSisRegistrySession::HashL"));
+// TRAP(err, session.ModifiableL(_L("C:\\a filename.txt")));
+// CheckFailL(err, _L("RSisRegistrySession::ModifiableL"));
+
+ TUid sid={0};
+ TRAP(err, session.SidToPackageL(sid));
+ CheckFailL(err, _L("RSisRegistrySession::SidToPackageL"));
+
+ TRAP(err, entry.RemovableL());
+ CheckFailL(err, _L("RSisregistryEntry::RemovableL"));
+
+#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
+ TRAP(err, session.IsFileRegisteredL(_L("some.file")));
+ CheckFailL(err, _L("RSisregistrySession::IsFileRegisteredL"));
+
+ TRAP(err, session.GetComponentIdForUidL(uid));
+ CheckFailL(err, _L("RSisregistrySession::GetComponentIdForUidL"));
+#endif
+
+ Swi::RSisRegistryWritableEntry writableEntry;
+
+ TUid uidOpen = { 0x101f7989}; // Package known to exist
+
+ if (KErrNone != writableEntry.Open(session, uidOpen))
+ {
+ SetFail();
+ CleanupStack::PopAndDestroy(&session);
+ return;
+ }
+
+ CleanupClosePushL(writableEntry);
+
+ RPointerArray<Swi::CSisRegistryFileDescription> fileDescriptions;
+ TRAP(err, writableEntry.FileDescriptionsL(fileDescriptions));
+ CleanupResetAndDestroyPushL(fileDescriptions);
+ CheckFailL(err, _L("FileDescriptionsL"));
+ CleanupStack::PopAndDestroy(&fileDescriptions);
+
+ TRAP(err, writableEntry.PreInstalledL());
+ CheckFailL(err, _L("PreInstalledL"));
+
+ TRAP(err, writableEntry.IsPresentL());
+ CheckFailL(err, _L("RSisregistryEntry::IsPresentL"));
+
+ TRAP(err, writableEntry.IsAugmentationL());
+ CheckFailL(err, _L("RSisregistryEntry::IsAugmentationL"));
+
+ TRAP(err, writableEntry.UidL());
+ CheckFailL(err, _L("RSisregistryEntry::UidL"));
+
+ RArray<TUid> sids;
+ TRAP(err, writableEntry.SidsL(sids));
+ CleanupClosePushL(sids);
+ CheckFailL(err, _L("RSisregistryEntry::Sids"));
+ CleanupStack::PopAndDestroy(&sids);
+
+ RPointerArray<HBufC> files;
+ TRAP(err, writableEntry.FilesL(files));
+ CleanupResetAndDestroyPushL(files);
+ CheckFailL(err, _L("RSisregistryEntry::FilesL"));
+ CleanupStack::PopAndDestroy(&files);
+
+ _LIT(KFileName ,"\\a filename.txt");
+ TDriveUnit sysDrive(RFs::GetSystemDrive());
+ TBuf<128> fileName = sysDrive.Name();
+ fileName.Append(KFileName);
+ TRAP(err, writableEntry.HashL(fileName));
+ CheckFailL(err, _L("RSisregistryEntry::HashL"));
+
+ RPointerArray<HBufC> packageNames;
+ RPointerArray<HBufC> vendorNames;
+ TRAP(err, writableEntry.AugmentationsL(packageNames, vendorNames));
+ CleanupResetAndDestroyPushL(vendorNames);
+ CleanupResetAndDestroyPushL(packageNames);
+ CheckFailL(err, _L("RSisregistryEntry::AugmentationsL(RPointerArray<HBufC>&,RPointerArray<HBufC>&)"));
+ CleanupStack::PopAndDestroy(&packageNames);
+ CleanupStack::PopAndDestroy(&vendorNames);
+
+ RPointerArray<Swi::CSisRegistryPackage> packages;
+ CleanupResetAndDestroyPushL(packages);
+ TRAP(err, writableEntry.AugmentationsL(packages));
+ CheckFailL(err, _L("RSisregistryEntry::AugmentationsL(RPointerArray<CSisRegistryPackage>&)"));
+ CleanupStack::PopAndDestroy(&packages);
+
+ TRAP(err, writableEntry.SizeL());
+ CheckFailL(err, _L("RSisregistryEntry::SizeL"));
+
+ CleanupStack::PopAndDestroy(3, &session);
+ }
+
+CReadUserDataRegistryCapTest* CReadUserDataRegistryCapTest::NewL()
+ {
+ CReadUserDataRegistryCapTest* self=new(ELeave) CReadUserDataRegistryCapTest();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+CReadUserDataRegistryCapTest::CReadUserDataRegistryCapTest()
+ {
+ SetCapabilityRequired(ECapabilityReadUserData);
+ }
+
+void CReadUserDataRegistryCapTest::ConstructL()
+ {
+ SetNameL(KReadUserDataRegistryCapTestName);
+ }
+
+void CReadUserDataRegistryCapTest::RunTestL()
+ {
+ Swi::RSisRegistrySession session;
+ CleanupClosePushL(session);
+
+ TInt err = session.Connect();
+
+ if (KErrNone != err)
+ {
+ SetFail();
+ CleanupStack::PopAndDestroy(&session);
+ return;
+ }
+
+// RSisRegistrySession tests
+ RArray<TUid> uids;
+ TRAP(err, session.InstalledUidsL(uids));
+ CleanupClosePushL(uids);
+ CheckFailL(err, _L("RSisRegistrySession::InstalledUidsL"));
+ CleanupStack::PopAndDestroy(&uids);
+
+ RPointerArray<Swi::CSisRegistryPackage> packages;
+ TRAP(err, session.InstalledPackagesL(packages));
+ CleanupResetAndDestroyPushL(packages);
+ CheckFailL(err, _L("RSisRegistrySession::InstalledPackagesL"));
+ CleanupStack::PopAndDestroy(&packages);
+
+ RPointerArray<Swi::CSisRegistryPackage> removablePackages;
+ TRAP(err, session.RemovablePackagesL(removablePackages));
+ CleanupResetAndDestroyPushL(removablePackages);
+ CheckFailL(err, _L("RSisRegistrySession::RemovablePackagesL"));
+ CleanupStack::PopAndDestroy(&removablePackages);
+
+ // start debug.
+
+ Swi::RSisRegistryWritableEntry entry;
+
+ TUid uidOpen = {0x101f7989}; // Package known to exist
+
+ if (KErrNone != entry.Open(session, uidOpen))
+ {
+ SetFail();
+ CleanupStack::PopAndDestroy(&session);
+ return;
+ }
+
+ CleanupClosePushL(entry);
+
+ TRAP(err, entry.DependentPackagesL(packages));
+ packages.ResetAndDestroy();
+ CheckFailL(err, _L("DependentPackagesL"));
+
+ RPointerArray<Swi::CSisRegistryDependency> dependencies;
+ TRAP(err, entry.DependenciesL(dependencies));
+ dependencies.ResetAndDestroy();
+ CheckFailL(err, _L("DependenciesL"));
+ TRAP(err, entry.EmbeddedPackagesL(packages));
+ packages.ResetAndDestroy();
+ CheckFailL(err, _L("EmbeddedPackagesL"));
+
+ TRAP(err, entry.EmbeddingPackagesL(packages));
+ packages.ResetAndDestroy();
+ CheckFailL(err, _L("EmbeddingPackagesL"));
+
+ CleanupStack::PopAndDestroy(2, &session);
+ }
+
+
+
+CPrivateRegistryCapTest* CPrivateRegistryCapTest::NewL()
+ {
+ CPrivateRegistryCapTest* self=new(ELeave) CPrivateRegistryCapTest();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+CPrivateRegistryCapTest::CPrivateRegistryCapTest()
+ {
+ SetCapabilityRequired(ECapabilityTCB);
+ SetSidRequired(Swi::KSwisSecureId);
+ }
+
+void CPrivateRegistryCapTest::ConstructL()
+ {
+ SetNameL(KPrivateRegistryCapTestName);
+ }
+
+void CPrivateRegistryCapTest::RunTestL()
+ {
+ Swi::RSisRegistryWritableSession session;
+ CleanupClosePushL(session);
+
+ if (KErrNone != session.Connect())
+ {
+ SetFail();
+ CleanupStack::PopAndDestroy(&session);
+ return;
+ }
+
+ TInt err = 0;
+
+#ifndef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
+ TRAP(err, session.RegenerateCacheL());
+ CheckFailL(err, _L("RegenerateCacheL"));
+#endif
+
+ {
+ // setup the application
+ Swi::CApplication* app=Swi::CApplication::NewLC();
+ TUint64 id=0;
+ RFs fs;
+ User::LeaveIfError(fs.Connect());
+
+ RFile file;
+ _LIT(KControllerFile, "z:\\tswi\\swicaptests\\data\\controller");
+ User::LeaveIfError(file.Open(fs, KControllerFile, EFileRead | EFileShareReadersOnly));
+ CleanupClosePushL(file);
+ TInt fileSize;
+ User::LeaveIfError(file.Size(fileSize));
+ HBufC8* buffer = HBufC8::NewLC(fileSize);
+ TPtr8 ptr(buffer->Des());
+ User::LeaveIfError(file.Read(0, ptr, fileSize));
+
+ // Read the controller
+ CDesDataProvider* desProvider = CDesDataProvider::NewLC(*buffer);
+ Sis::CController* controller = Sis::CController::NewL(*desProvider, Sis::EAssumeType);
+
+ app->SetInstall(*controller);
+ app->UserSelections().SetLanguage(ELangEnglish);
+ app->UserSelections().SetDrive(2);
+
+ TRAP(err, session.AddEntryL(*app, *buffer, id));
+ CheckFailL(err, _L("AddEntryL"));
+
+ TRAP(err, session.UpdateEntryL(*app, *buffer, id));
+ CheckFailL(err, _L("UpdateEntryL"));
+
+#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
+ RCPointerArray<CSoftwareTypeRegInfo> regInfoArray;
+ CleanupClosePushL(regInfoArray);
+
+ TRAP(err, session.AddEntryL(*app, *buffer, regInfoArray, id));
+ CheckFailL(err, _L("AddEntryL for LEEs"));
+
+ TRAP(err, session.UpdateEntryL(*app, *buffer, regInfoArray, id));
+ CheckFailL(err, _L("UpdateEntryL for LEEs"));
+
+ CleanupStack::PopAndDestroy(®InfoArray);
+#endif
+
+ CleanupStack::PopAndDestroy(desProvider);
+ CleanupStack::PopAndDestroy(buffer);
+ CleanupStack::PopAndDestroy(&file);
+ CleanupStack::PopAndDestroy(app); // app, file, buffer, desProvider, controller
+ }
+
+ Swi::RSisRegistryWritableEntry entry;
+
+ TUid uidOpen = {0x101f7989}; // Package known to exist
+
+ if (KErrNone != entry.Open(session, uidOpen))
+ {
+ SetFail();
+ CleanupStack::PopAndDestroy(&session);
+ return;
+ }
+
+ CleanupClosePushL(entry);
+
+ TRAP(err, entry.InstallTypeL());
+ CheckFailL(err, _L("InstallTypeL"));
+
+ CleanupStack::PopAndDestroy(2, &session);
+ }
+
+CDaemonRegistryCapTest* CDaemonRegistryCapTest::NewL()
+ {
+ CDaemonRegistryCapTest* self=new(ELeave) CDaemonRegistryCapTest();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+CDaemonRegistryCapTest::CDaemonRegistryCapTest()
+ {
+ SetSidRequired(Swi::KDaemonSecureId);
+ }
+
+void CDaemonRegistryCapTest::ConstructL()
+ {
+ SetNameL(KDaemonRegistryCapTestName);
+ }
+
+void CDaemonRegistryCapTest::RunTestL()
+ {
+ Swi::RSisRegistryWritableSession session;
+ CleanupClosePushL(session);
+
+ TInt err = session.Connect();
+
+ if (KErrNone != err)
+ {
+ SetFail();
+ CleanupStack::PopAndDestroy(&session);
+ return;
+ }
+
+ const TInt KTestDrive=7; // random drive
+ TRAP(err, session.AddDriveL(KTestDrive));
+ CheckFailL(err, _L("AddDriveL"));
+
+#ifndef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
+ TRAP(err, session.RemoveDriveL(KTestDrive));
+ CheckFailL(err, _L("RemoveDriveL"));
+#endif
+
+ TRAP(err, session.RecoverL());
+ CheckFailL(err, _L("RecoverL"));
+
+ CleanupStack::PopAndDestroy(&session);
+ }
+
+
+CRevocationRegistryCapTest* CRevocationRegistryCapTest::NewL()
+ {
+ CRevocationRegistryCapTest* self=new(ELeave) CRevocationRegistryCapTest();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+CRevocationRegistryCapTest::CRevocationRegistryCapTest()
+ {
+ SetCapabilityRequired(ECapabilityNetworkServices);
+ SetCapabilityRequired(ECapabilityWriteUserData);
+ }
+
+void CRevocationRegistryCapTest::ConstructL()
+ {
+ SetNameL(KRevocationRegistryCapTestName);
+ }
+
+void CRevocationRegistryCapTest::RunTestL()
+ {
+ Swi::RSisRegistryWritableSession session;
+ CleanupClosePushL(session);
+
+ TInt err = session.Connect();
+
+ if (KErrNone != err)
+ {
+ SetFail();
+ CleanupStack::PopAndDestroy(&session);
+ return;
+ }
+
+ Swi::RSisRevocationEntry entry;
+
+ TUid uidOpen = {0x101f7989}; // Package known to exist
+
+ if (KErrNone != entry.Open(session, uidOpen))
+ {
+ SetFail();
+ CleanupStack::PopAndDestroy(&session);
+ return;
+ }
+
+ CleanupClosePushL(entry);
+
+ TRAP(err, entry.CheckRevocationStatusL(_L8("dummy")));
+ CheckFailL(err, _L("CheckRevocationStatus"));
+
+ CleanupStack::PopAndDestroy(2,&session);
+ }
+
+
+#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
+
+CSifServerRegistryCapTest* CSifServerRegistryCapTest::NewL()
+ {
+ CSifServerRegistryCapTest* self=new(ELeave) CSifServerRegistryCapTest();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+CSifServerRegistryCapTest::CSifServerRegistryCapTest()
+ {
+ SetSidRequired(TUid::Uid(0x10285BCB)); //SIF servers's UID3 (ie: SID)
+ }
+
+void CSifServerRegistryCapTest::ConstructL()
+ {
+ SetNameL(KSifServerRegistryCapTestName);
+ }
+
+void CSifServerRegistryCapTest::RunTestL()
+ {
+ Usif::TComponentId componentId(0x01);
+ Swi::RSisRegistryWritableSession session;
+ CleanupClosePushL(session);
+
+ TInt err = session.Connect();
+ if (KErrNone != err)
+ {
+ SetFail();
+ CleanupStack::PopAndDestroy(&session);
+ return;
+ }
+
+ TRAP(err, session.ActivateComponentL(componentId));
+ CheckFailL(err, _L("ActivateComponentL"));
+
+ TRAP(err, session.DeactivateComponentL(componentId));
+ CheckFailL(err, _L("DeactivateComponentL"));
+
+ CleanupStack::PopAndDestroy(&session);
+ }
+#endif
+
+