1 /*

     2 * Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 /**

    20  @file

    21 */

    22 

    23 #include "registrycaptest.h"

    24 

    25 #include "sisregistrywritablesession.h"

    26 #include "sisregistrywritableentry.h"

    27 #include "sisregistrysession.h"

    28 #include "sisregistrypackage.h"

    29 #include "sisregistryentry.h"

    30 #include "sisrevocationentry.h"

    31 #include "sisregistryserver.h"

    32 #include "application.h"

    33 #include "sistruststatus.h"

    34 #include "sisregistryfiledescription.h"

    35 #include "sisregistrydependency.h"

    36 #include "userselections.h"

    37 #include "siscontroller.h"

    38 #include "filesisdataprovider.h"

    39 #include "dessisdataprovider.h"

    40 #include "cleanuputils.h"

    41 #ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

    42 #include "swtypereginfo.h"

    43 #endif

    44 #include <e32def.h>

    45 #include <f32file.h>

    46 

    47 using namespace Swi;

    48 

    49 _LIT(KPublicRegistryCapTestName, "Registry public (no caps) interface capability test");

    50 _LIT(KReadUserDataRegistryCapTestName, "Registry public (ReadUserData) interface capability test");

    51 _LIT(KPrivateRegistryCapTestName, "Registry private interface capability test");

    52 _LIT(KDaemonRegistryCapTestName, "Registry daemon interface capability test");

    53 _LIT(KRevocationRegistryCapTestName, "Registry revocation interface capability test");

    54 #ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

    55 _LIT(KSifServerRegistryCapTestName, "Registry SIF interface security test");

    56 #endif

    57 

    58 CPublicRegistryCapTest* CPublicRegistryCapTest::NewL()

    59 	{

    60 	CPublicRegistryCapTest* self=new(ELeave) CPublicRegistryCapTest();

    61 	CleanupStack::PushL(self);

    62 	self->ConstructL();

    63 	CleanupStack::Pop(self);

    64 	return self;

    65 	}

    66 

    67 CPublicRegistryCapTest::CPublicRegistryCapTest()

    68 	{

    69 	}

    70 	

    71 void CPublicRegistryCapTest::ConstructL()

    72 	{

    73 	SetNameL(KPublicRegistryCapTestName);

    74 	}

    75 

    76 void CPublicRegistryCapTest::RunTestL()

    77 	{

    78 	Swi::RSisRegistrySession session;

    79 	CleanupClosePushL(session);

    80 		

    81 	TInt err = session.Connect();

    82 	

    83 	if (KErrNone != err)

    84 		{

    85 		SetFail();

    86 		CleanupStack::PopAndDestroy(&session);

    87 		return;

    88 		}

    89 

    90 	// RSisregistryEntry

    91 	Swi::RSisRegistryEntry entry;

    92 	

    93 // open an entry to do tests on

    94 	TUid uid = { 0x101f7989}; // Package known to exist

    95 	if (KErrNone != CheckFailL(entry.Open(session, uid), _L("Open(TUid)")))

    96 		{

    97 		CleanupStack::PopAndDestroy(&session);

    98 		return;

    99 		}

   100 	CleanupClosePushL(entry);

   101 	

   102 	TRAP(err, entry.IsSignedL());

   103 	CheckFailL(err, _L("RSisregistryEntry::IsSignedL"));

   104 

   105 	TRAP(err, entry.IsInRomL());

   106 	CheckFailL(err, _L("RSisregistryEntry::IsInRomL"));

   107 	

   108 	TRAP(err, entry.VersionL());

   109 	CheckFailL(err, _L("RSisregistryEntry::VersionL"));

   110 

   111 	TRAP(err, entry.LanguageL());

   112 	CheckFailL(err, _L("RSisregistryEntry::LanguageL"));

   113 

   114 	TRAP(err, entry.SelectedDriveL());

   115 	CheckFailL(err, _L("SelectedDriveL"));

   116 

   117 	TRAP(err, entry.TrustStatusL());

   118 	CheckFailL(err, _L("RSisregistryEntry::TrustStatusL"));

   119 

   120 	HBufC* name=NULL;

   121 	TRAP(err, name = entry.PackageNameL());

   122 	CleanupStack::PushL(name);

   123 	CheckFailL(err, _L("RSisregistryEntry::PackageNameL"));

   124 	CleanupStack::PopAndDestroy(name);

   125 	

   126 	TRAP(err, name= entry.UniqueVendorNameL());

   127 	CleanupStack::PushL(name);

   128 	CheckFailL(err, _L("RSisregistryEntry::UniqueVendorNameL"));

   129 	CleanupStack::PopAndDestroy(name);

   130 	

   131 	TRAP(err, entry.LocalizedVendorNameL());

   132 	CheckFailL(err, _L("RSisregistryEntry::LocalizedVendorNameL"));

   133 

   134 

   135 	RPointerArray<HBufC8> chains;

   136 	TRAP(err, entry.CertificateChainsL(chains));

   137 	CleanupResetAndDestroyPushL(chains);

   138 	CheckFailL(err, _L("RSisregistryEntry::CertificateChainsL"));

   139 	CleanupStack::PopAndDestroy(&chains);

   140 

   141 	TRAP(err, entry.PropertyL(0));

   142 	CheckFailL(err, _L("RSisregistryEntry::PropertyL"));

   143 

   144 	Swi::CSisRegistryPackage* package=NULL;

   145 	TRAP(err, package=entry.PackageL());

   146 	delete package;

   147 	CheckFailL(err, _L("RSisregistryEntry::PackageL"));

   148 

   149 	RPointerArray<HBufC8> controllers;

   150 	TRAP(err, entry.ControllersL(controllers));

   151 	CleanupResetAndDestroyPushL(controllers);

   152 	CheckFailL(err, _L("RSisregistryEntry::ControllersL"));

   153 	CleanupStack::PopAndDestroy(&controllers);

   154 	

   155 	TUid nonExistentUid ={0};

   156 	TRAP(err, session.IsInstalledL(nonExistentUid));

   157 	CheckFailL(err, _L("RSisRegistrySession::IsInstalledL(TUid)"));

   158 

   159 	TBuf8<5> controller;

   160 	TRAP(err, session.IsInstalledL(controller));

   161 	CheckFailL(err, _L("RSisRegistrySession::IsInstalledL(TDesC8&)"));

   162 

   163 // These two are unimplemented in the server

   164 //	TRAP(err, session.HashL(_L("C:\\a filename.txt")));

   165 //	CheckFailL(err, _L("RSisRegistrySession::HashL"));

   166 //	TRAP(err, session.ModifiableL(_L("C:\\a filename.txt")));

   167 //	CheckFailL(err, _L("RSisRegistrySession::ModifiableL"));

   168 

   169 	TUid sid={0};

   170 	TRAP(err, session.SidToPackageL(sid));

   171 	CheckFailL(err, _L("RSisRegistrySession::SidToPackageL"));

   172 	

   173 	TRAP(err, entry.RemovableL());

   174 	CheckFailL(err, _L("RSisregistryEntry::RemovableL"));	

   175 

   176 #ifdef 	SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

   177 	TRAP(err, session.IsFileRegisteredL(_L("some.file")));

   178 	CheckFailL(err, _L("RSisregistrySession::IsFileRegisteredL"));		

   179 

   180 	TRAP(err, session.GetComponentIdForUidL(uid));

   181 	CheckFailL(err, _L("RSisregistrySession::GetComponentIdForUidL"));

   182 #endif

   183 

   184 	Swi::RSisRegistryWritableEntry writableEntry;

   185 	

   186 	TUid uidOpen = { 0x101f7989}; // Package known to exist

   187 	

   188 	if (KErrNone != writableEntry.Open(session, uidOpen))

   189 		{

   190 		SetFail();

   191 		CleanupStack::PopAndDestroy(&session);

   192 		return;

   193 		}

   194 

   195 	CleanupClosePushL(writableEntry);

   196 

   197 	RPointerArray<Swi::CSisRegistryFileDescription> fileDescriptions;

   198 	TRAP(err, writableEntry.FileDescriptionsL(fileDescriptions));

   199 	CleanupResetAndDestroyPushL(fileDescriptions);

   200 	CheckFailL(err, _L("FileDescriptionsL"));

   201 	CleanupStack::PopAndDestroy(&fileDescriptions);

   202 

   203 	TRAP(err, writableEntry.PreInstalledL());

   204 	CheckFailL(err, _L("PreInstalledL"));

   205 

   206 	TRAP(err, writableEntry.IsPresentL());

   207 	CheckFailL(err, _L("RSisregistryEntry::IsPresentL"));

   208 

   209 	TRAP(err, writableEntry.IsAugmentationL());

   210 	CheckFailL(err, _L("RSisregistryEntry::IsAugmentationL"));

   211 

   212 	TRAP(err, writableEntry.UidL());

   213 	CheckFailL(err, _L("RSisregistryEntry::UidL"));

   214 

   215 	RArray<TUid> sids;

   216 	TRAP(err, writableEntry.SidsL(sids));

   217 	CleanupClosePushL(sids);

   218 	CheckFailL(err, _L("RSisregistryEntry::Sids"));

   219 	CleanupStack::PopAndDestroy(&sids);

   220 

   221 	RPointerArray<HBufC> files;

   222 	TRAP(err, writableEntry.FilesL(files));

   223 	CleanupResetAndDestroyPushL(files);

   224 	CheckFailL(err, _L("RSisregistryEntry::FilesL"));

   225 	CleanupStack::PopAndDestroy(&files);

   226 

   227 	_LIT(KFileName ,"\\a filename.txt");

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

   229 	TBuf<128> fileName = sysDrive.Name();

   230 	fileName.Append(KFileName);

   231 	TRAP(err, writableEntry.HashL(fileName));

   232 	CheckFailL(err, _L("RSisregistryEntry::HashL"));

   233 

   234 	RPointerArray<HBufC> packageNames;

   235 	RPointerArray<HBufC> vendorNames;

   236 	TRAP(err, writableEntry.AugmentationsL(packageNames, vendorNames));

   237 	CleanupResetAndDestroyPushL(vendorNames);

   238 	CleanupResetAndDestroyPushL(packageNames);

   239 	CheckFailL(err, _L("RSisregistryEntry::AugmentationsL(RPointerArray<HBufC>&,RPointerArray<HBufC>&)"));

   240 	CleanupStack::PopAndDestroy(&packageNames);

   241 	CleanupStack::PopAndDestroy(&vendorNames);

   242 

   243 	RPointerArray<Swi::CSisRegistryPackage> packages;

   244 	CleanupResetAndDestroyPushL(packages);

   245 	TRAP(err, writableEntry.AugmentationsL(packages));

   246 	CheckFailL(err, _L("RSisregistryEntry::AugmentationsL(RPointerArray<CSisRegistryPackage>&)"));

   247 	CleanupStack::PopAndDestroy(&packages);

   248 

   249 	TRAP(err, writableEntry.SizeL());

   250 	CheckFailL(err, _L("RSisregistryEntry::SizeL"));	

   251 	

   252 	CleanupStack::PopAndDestroy(3, &session);

   253 	}

   254 

   255 CReadUserDataRegistryCapTest* CReadUserDataRegistryCapTest::NewL()

   256 	{

   257 	CReadUserDataRegistryCapTest* self=new(ELeave) CReadUserDataRegistryCapTest();

   258 	CleanupStack::PushL(self);

   259 	self->ConstructL();

   260 	CleanupStack::Pop(self);

   261 	return self;

   262 	}

   263 

   264 CReadUserDataRegistryCapTest::CReadUserDataRegistryCapTest()

   265 	{

   266 	SetCapabilityRequired(ECapabilityReadUserData);

   267 	}

   268 	

   269 void CReadUserDataRegistryCapTest::ConstructL()

   270 	{

   271 	SetNameL(KReadUserDataRegistryCapTestName);

   272 	}

   273 

   274 void CReadUserDataRegistryCapTest::RunTestL()

   275 	{

   276 	Swi::RSisRegistrySession session;

   277 	CleanupClosePushL(session);

   278 		

   279 	TInt err = session.Connect();

   280 	

   281 	if (KErrNone != err)

   282 		{

   283 		SetFail();

   284 		CleanupStack::PopAndDestroy(&session);

   285 		return;

   286 		}

   287 	

   288 // RSisRegistrySession tests

   289 	RArray<TUid> uids;

   290 	TRAP(err, session.InstalledUidsL(uids));

   291 	CleanupClosePushL(uids);

   292 	CheckFailL(err, _L("RSisRegistrySession::InstalledUidsL"));

   293 	CleanupStack::PopAndDestroy(&uids);

   294 	

   295 	RPointerArray<Swi::CSisRegistryPackage> packages;

   296 	TRAP(err, session.InstalledPackagesL(packages));

   297 	CleanupResetAndDestroyPushL(packages);

   298 	CheckFailL(err, _L("RSisRegistrySession::InstalledPackagesL"));

   299 	CleanupStack::PopAndDestroy(&packages);

   300 

   301 	RPointerArray<Swi::CSisRegistryPackage> removablePackages;

   302 	TRAP(err, session.RemovablePackagesL(removablePackages));

   303 	CleanupResetAndDestroyPushL(removablePackages);

   304 	CheckFailL(err, _L("RSisRegistrySession::RemovablePackagesL"));

   305 	CleanupStack::PopAndDestroy(&removablePackages);

   306 	

   307 	// start debug.

   308 	

   309 	Swi::RSisRegistryWritableEntry entry;

   310 		

   311 	TUid uidOpen = {0x101f7989}; // Package known to exist

   312 	

   313 	if (KErrNone != entry.Open(session, uidOpen))

   314 		{

   315 		SetFail();

   316 		CleanupStack::PopAndDestroy(&session);

   317 		return;

   318 		}

   319 

   320 	CleanupClosePushL(entry);

   321 		

   322 	TRAP(err, entry.DependentPackagesL(packages));

   323 	packages.ResetAndDestroy();

   324 	CheckFailL(err, _L("DependentPackagesL"));

   325 				

   326 	RPointerArray<Swi::CSisRegistryDependency> dependencies;

   327 	TRAP(err, entry.DependenciesL(dependencies));

   328 	dependencies.ResetAndDestroy();

   329 	CheckFailL(err, _L("DependenciesL"));

   330 	TRAP(err, entry.EmbeddedPackagesL(packages));

   331 	packages.ResetAndDestroy();

   332 	CheckFailL(err, _L("EmbeddedPackagesL"));

   333 

   334 	TRAP(err, entry.EmbeddingPackagesL(packages));

   335 	packages.ResetAndDestroy();

   336 	CheckFailL(err, _L("EmbeddingPackagesL"));

   337 	

   338 	CleanupStack::PopAndDestroy(2, &session);

   339 	}

   340 

   341 

   342 

   343 CPrivateRegistryCapTest* CPrivateRegistryCapTest::NewL()

   344 	{

   345 	CPrivateRegistryCapTest* self=new(ELeave) CPrivateRegistryCapTest();

   346 	CleanupStack::PushL(self);

   347 	self->ConstructL();

   348 	CleanupStack::Pop(self);

   349 	return self;

   350 	}

   351 

   352 CPrivateRegistryCapTest::CPrivateRegistryCapTest()

   353 	{

   354 	SetCapabilityRequired(ECapabilityTCB);

   355 	SetSidRequired(Swi::KSwisSecureId);

   356 	}

   357 	

   358 void CPrivateRegistryCapTest::ConstructL()

   359 	{

   360 	SetNameL(KPrivateRegistryCapTestName);

   361 	}

   362 

   363 void CPrivateRegistryCapTest::RunTestL()

   364 	{

   365 	Swi::RSisRegistryWritableSession session;

   366 	CleanupClosePushL(session);

   367 		

   368 	if (KErrNone != session.Connect())

   369 		{

   370 		SetFail();

   371 		CleanupStack::PopAndDestroy(&session);

   372 		return;

   373 		}

   374 

   375 	TInt err = 0;

   376 

   377 #ifndef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

   378 	TRAP(err, session.RegenerateCacheL());

   379 	CheckFailL(err, _L("RegenerateCacheL"));

   380 #endif

   381 	

   382 		{

   383 		// setup the application

   384 		Swi::CApplication* app=Swi::CApplication::NewLC();

   385 		TUint64 id=0;

   386 		RFs fs;

   387 		User::LeaveIfError(fs.Connect());

   388 		

   389 		RFile file;

   390 		_LIT(KControllerFile, "z:\\tswi\\swicaptests\\data\\controller");

   391 		User::LeaveIfError(file.Open(fs, KControllerFile, EFileRead | EFileShareReadersOnly));

   392 		CleanupClosePushL(file);

   393 		TInt fileSize;

   394 		User::LeaveIfError(file.Size(fileSize));

   395 		HBufC8* buffer = HBufC8::NewLC(fileSize);

   396 		TPtr8 ptr(buffer->Des());

   397 		User::LeaveIfError(file.Read(0, ptr, fileSize));

   398 	

   399 		// Read the controller

   400 		CDesDataProvider* desProvider = CDesDataProvider::NewLC(*buffer);

   401 		Sis::CController* controller = Sis::CController::NewL(*desProvider, Sis::EAssumeType);

   402 

   403 		app->SetInstall(*controller);

   404 		app->UserSelections().SetLanguage(ELangEnglish);

   405 		app->UserSelections().SetDrive(2);

   406 		

   407 		TRAP(err, session.AddEntryL(*app, *buffer, id));

   408 		CheckFailL(err, _L("AddEntryL"));

   409 		

   410 		TRAP(err, session.UpdateEntryL(*app, *buffer, id));

   411 		CheckFailL(err, _L("UpdateEntryL"));

   412 

   413 #ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

   414 		RCPointerArray<CSoftwareTypeRegInfo> regInfoArray;

   415 		CleanupClosePushL(regInfoArray);

   416 		

   417 		TRAP(err, session.AddEntryL(*app, *buffer, regInfoArray, id));

   418 		CheckFailL(err, _L("AddEntryL for LEEs"));

   419 		

   420 		TRAP(err, session.UpdateEntryL(*app, *buffer, regInfoArray, id));

   421 		CheckFailL(err, _L("UpdateEntryL for LEEs"));

   422 		

   423 		CleanupStack::PopAndDestroy(&regInfoArray);

   424 #endif

   425 

   426 		CleanupStack::PopAndDestroy(desProvider); 

   427 		CleanupStack::PopAndDestroy(buffer); 

   428 		CleanupStack::PopAndDestroy(&file); 

   429 		CleanupStack::PopAndDestroy(app); // app, file, buffer, desProvider, controller

   430 		}

   431 

   432 	Swi::RSisRegistryWritableEntry entry;

   433 	

   434 	TUid uidOpen = {0x101f7989}; // Package known to exist

   435 	

   436 	if (KErrNone != entry.Open(session, uidOpen))

   437 		{

   438 		SetFail();

   439 		CleanupStack::PopAndDestroy(&session);

   440 		return;

   441 		}

   442 

   443 	CleanupClosePushL(entry);

   444 

   445 	TRAP(err, entry.InstallTypeL());

   446 	CheckFailL(err, _L("InstallTypeL"));

   447 

   448 	CleanupStack::PopAndDestroy(2, &session);

   449 	}

   450 

   451 CDaemonRegistryCapTest* CDaemonRegistryCapTest::NewL()

   452 	{

   453 	CDaemonRegistryCapTest* self=new(ELeave) CDaemonRegistryCapTest();

   454 	CleanupStack::PushL(self);

   455 	self->ConstructL();

   456 	CleanupStack::Pop(self);

   457 	return self;

   458 	}

   459 

   460 CDaemonRegistryCapTest::CDaemonRegistryCapTest()

   461 	{

   462 	SetSidRequired(Swi::KDaemonSecureId);

   463 	}

   464 	

   465 void CDaemonRegistryCapTest::ConstructL()

   466 	{

   467 	SetNameL(KDaemonRegistryCapTestName);

   468 	}

   469 

   470 void CDaemonRegistryCapTest::RunTestL()

   471 	{

   472 	Swi::RSisRegistryWritableSession session;

   473 	CleanupClosePushL(session);

   474 		

   475 	TInt err = session.Connect();

   476 	

   477 	if (KErrNone != err)

   478 		{

   479 		SetFail();

   480 		CleanupStack::PopAndDestroy(&session);

   481 		return;

   482 		}

   483 

   484 	const TInt KTestDrive=7; // random drive

   485 	TRAP(err, session.AddDriveL(KTestDrive));

   486 	CheckFailL(err, _L("AddDriveL"));

   487 

   488 #ifndef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

   489 	TRAP(err, session.RemoveDriveL(KTestDrive));

   490 	CheckFailL(err, _L("RemoveDriveL"));

   491 #endif

   492 

   493 	TRAP(err, session.RecoverL());

   494 	CheckFailL(err, _L("RecoverL"));

   495 

   496 	CleanupStack::PopAndDestroy(&session);

   497 	}

   498 

   499 

   500 CRevocationRegistryCapTest* CRevocationRegistryCapTest::NewL()

   501 	{

   502 	CRevocationRegistryCapTest* self=new(ELeave) CRevocationRegistryCapTest();

   503 	CleanupStack::PushL(self);

   504 	self->ConstructL();

   505 	CleanupStack::Pop(self);

   506 	return self;

   507 	}

   508 

   509 CRevocationRegistryCapTest::CRevocationRegistryCapTest()

   510 	{

   511 	SetCapabilityRequired(ECapabilityNetworkServices);

   512 	SetCapabilityRequired(ECapabilityWriteUserData);

   513 	}

   514 	

   515 void CRevocationRegistryCapTest::ConstructL()

   516 	{

   517 	SetNameL(KRevocationRegistryCapTestName);

   518 	}

   519 

   520 void CRevocationRegistryCapTest::RunTestL()

   521 	{

   522 	Swi::RSisRegistryWritableSession session;

   523 	CleanupClosePushL(session);

   524 		

   525 	TInt err = session.Connect();

   526 	

   527 	if (KErrNone != err)

   528 		{

   529 		SetFail();

   530 		CleanupStack::PopAndDestroy(&session);

   531 		return;

   532 		}

   533 

   534 	Swi::RSisRevocationEntry entry;

   535 	

   536 	TUid uidOpen = {0x101f7989}; // Package known to exist

   537 	

   538 	if (KErrNone != entry.Open(session, uidOpen))

   539 		{

   540 		SetFail();

   541 		CleanupStack::PopAndDestroy(&session);

   542 		return;

   543 		}

   544 

   545 	CleanupClosePushL(entry);

   546 

   547 	TRAP(err, entry.CheckRevocationStatusL(_L8("dummy")));

   548 	CheckFailL(err, _L("CheckRevocationStatus"));

   549 

   550 	CleanupStack::PopAndDestroy(2,&session);

   551 	}

   552 

   553 

   554 #ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

   555 

   556 CSifServerRegistryCapTest* CSifServerRegistryCapTest::NewL()

   557 	{

   558 	CSifServerRegistryCapTest* self=new(ELeave) CSifServerRegistryCapTest();

   559 	CleanupStack::PushL(self);

   560 	self->ConstructL();

   561 	CleanupStack::Pop(self);

   562 	return self;

   563 	}

   564 

   565 CSifServerRegistryCapTest::CSifServerRegistryCapTest()

   566 	{

   567 	SetSidRequired(TUid::Uid(0x10285BCB)); //SIF servers's UID3 (ie: SID)

   568 	}

   569 	

   570 void CSifServerRegistryCapTest::ConstructL()

   571 	{

   572 	SetNameL(KSifServerRegistryCapTestName);

   573 	}

   574 

   575 void CSifServerRegistryCapTest::RunTestL()

   576 	{

   577 	Usif::TComponentId componentId(0x01);

   578 	Swi::RSisRegistryWritableSession session;

   579 	CleanupClosePushL(session);

   580 		

   581 	TInt err = session.Connect();

   582 	if (KErrNone != err)

   583 		{

   584 		SetFail();

   585 		CleanupStack::PopAndDestroy(&session);

   586 		return;

   587 		}

   588 

   589 	TRAP(err, session.ActivateComponentL(componentId));

   590 	CheckFailL(err, _L("ActivateComponentL"));

   591 

   592 	TRAP(err, session.DeactivateComponentL(componentId));

   593 	CheckFailL(err, _L("DeactivateComponentL"));

   594 

   595 	CleanupStack::PopAndDestroy(&session);

   596 	}

   597 #endif

   598 

   599