1 /*

     2 * Copyright (c) 2008-2010 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 * Scr Accessor - server and implementation

    16 *

    17 */

    18 

    19 

    20 /**

    21  @file 

    22  @test

    23  @internalComponent

    24 */

    25 

    26 #include "tscraccessor_server_session.h"

    27 #include "tscraccessor_common.h"

    28 #include "tscraccessor_client.h"

    29 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    30 #include "screntries_internal.h"

    31 #endif //SYMBIAN_ENABLE_SPLIT_HEADERS

    32 #include <scs/cleanuputils.h>

    33 #include <usif/usiferror.h>

    34 #include <usif/scr/screntries_platform.h>

    35 using namespace Usif;

    36 

    37 /////////////////////// Utility functions //////////////////////////////

    38 void StartTimer(TTime& aTimer)

    39 	{

    40 	aTimer.HomeTime();

    41 	}

    42 

    43 TInt StopTimer(TTime aStartTimer)

    44 	{

    45 	TTime endTime;

    46 	endTime.HomeTime();

    47 		

    48 	TTimeIntervalMicroSeconds duration = endTime.MicroSecondsFrom(aStartTimer);

    49 	TInt actualDuration = I64INT(duration.Int64())/1000; // in millisecond

    50 	return actualDuration;

    51 	}

    52 

    53 //////////////////////// Server implementation /////////////////////////

    54 

    55 CServer2* CScrAccessServer::NewLC()

    56 	{

    57 	CScrAccessServer* self=new(ELeave) CScrAccessServer;

    58 	CleanupStack::PushL(self);

    59 	self->ConstructL();

    60 	return self;

    61 	}

    62 

    63 CScrAccessServer::CScrAccessServer()

    64 	:CServer2(0, ESharableSessions)

    65 	{

    66 	}

    67 

    68 CScrAccessServer::~CScrAccessServer()

    69 	{

    70 	iScrSession.Close();

    71 	}

    72 

    73 void CScrAccessServer::ConstructL()

    74 	{

    75 	StartL(KScrAccessServerName);

    76 	}

    77 

    78 CSession2* CScrAccessServer::NewSessionL(const TVersion&, const RMessage2&) const

    79 	{

    80 	return new(ELeave) CScrAccessSession();

    81 	}

    82 

    83 void CScrAccessServer::AddSession()

    84 	{

    85 	++iSessionCount;

    86 	}

    87 

    88 void CScrAccessServer::DropSession()

    89 	{

    90 	--iSessionCount;

    91 	if(!iSessionCount)

    92 		CActiveScheduler::Stop();

    93 	}

    94 

    95 

    96 //////////////////////// Session implementation /////////////////////////

    97 CScrAccessSession::CScrAccessSession()

    98 	{

    99 	}

   100 

   101 void CScrAccessSession::CreateL()

   102 	{

   103 	Server().AddSession();

   104 	}

   105 

   106 CScrAccessSession::~CScrAccessSession()

   107 	{

   108 	Server().DropSession();

   109 	}

   110 

   111 HBufC* ReadDescFromMessageLC(const RMessage2& aMessage, TInt aSlot)

   112 	{

   113 	TInt len = aMessage.GetDesLengthL(aSlot);

   114 	HBufC* desc = HBufC::NewLC(len);

   115 	TPtr ptrDesc(desc->Des());

   116 	aMessage.ReadL(aSlot, ptrDesc);

   117 	return desc;

   118 	}

   119 

   120 void VerifySoftwareTypeAdditionL(TInt& aError, RScrAccessor::TAccessorOperationResult& aOpResult, RSoftwareComponentRegistry& aScrSession, const TDesC& aMimeType, TUid aExpectedPluginUid)

   121 	{

   122 	// Do verification, there is no error until this step

   123 	if(KErrNone == aError)

   124 		{ // if adding software type operation is successful, check if the software type has really been added to teh sCR.

   125 		  // Get the plugin uid of the newly added MIME type

   126 		TUid retrievedPluginUid;

   127 		TRAP(aError, retrievedPluginUid = aScrSession.GetPluginUidL(aMimeType));

   128 		if(KErrNone == aError)

   129 			{ // if the plugin uid is found, then compare it with the expected one.

   130 			if(retrievedPluginUid != aExpectedPluginUid)

   131 				aOpResult = RScrAccessor::EOpFailUnexpectedPluginUid;

   132 			}

   133 		else if(KErrNotFound == aError)

   134 			aOpResult = RScrAccessor::EOpFailSwTypeNotFound;

   135 		// if the returned error is different from KErrNone and KErrNotFound, pass it to the client.

   136 		}

   137 	}

   138 

   139 void GenerateTestDataL(RPointerArray<HBufC>& aMimeTypes, const TDesC& aBaseMimeTypeName, TInt aMimeTypeNum, RPointerArray<CLocalizedSoftwareTypeName>& aLocalizedSwTypeNames, const TDesC& aBaseSwTypeName, TInt aSwTypesNum)

   140 	{

   141 	RBuf buf;

   142 	buf.CreateL(aBaseMimeTypeName.Length() + 3); // 3 is extra bytes to append number to the buffer

   143 	buf.CleanupClosePushL();

   144 	buf.Copy(aBaseMimeTypeName);

   145 	

   146 	for(TInt i=0; i<aMimeTypeNum; ++i)

   147 		{

   148 		buf.AppendNum(i);

   149 		HBufC *name = buf.AllocLC();

   150 		aMimeTypes.AppendL(name);

   151 		CleanupStack::Pop(name);

   152 		buf.SetLength(buf.Length()-1);

   153 		}

   154 	buf.Close();

   155 	

   156 	buf.CreateL(aBaseSwTypeName.Length() + 3);

   157 	buf.Copy(aBaseSwTypeName);

   158 	

   159 	for(TInt i=0; i<aSwTypesNum; ++i)

   160 		{

   161 		buf.AppendNum(i);

   162 		CLocalizedSoftwareTypeName *localizedName = CLocalizedSoftwareTypeName::NewL(buf, TLanguage(i+1));

   163 		CleanupStack::PushL(localizedName); // Use NewL for coverage

   164 		aLocalizedSwTypeNames.AppendL(localizedName);

   165 		CleanupStack::Pop(localizedName); // ownership is transferred

   166 		}

   167 	CleanupStack::PopAndDestroy(&buf);

   168 	}

   169 

   170 TInt AddSoftwareTypeL(RSoftwareComponentRegistry& aScrSession, const TDesC& aUniqueSwTypeName, TUid aSifPluginUid, RArray<TCustomAccessInfo> aInstallerSids, const TDesC& aBaseMimeTypeName, TInt aMimeTypeNum, const TDesC& aBaseSwTypeName, TInt aSwTypesNum, const TDesC& aLauncherExecutable, RScrAccessor::TAccessorOperationResult& aOpResult)

   171 	{

   172 	RPointerArray<HBufC> mimeTypesArray;

   173 	CleanupResetAndDestroyPushL(mimeTypesArray);

   174 	RPointerArray<CLocalizedSoftwareTypeName> localizedSwNames;

   175 	CleanupResetAndDestroyPushL(localizedSwNames);

   176 						

   177 	GenerateTestDataL(mimeTypesArray, aBaseMimeTypeName, aMimeTypeNum, localizedSwNames, aBaseSwTypeName, aSwTypesNum);

   178 	

   179 	RPointerArray<CLocalizedSoftwareTypeName> *plocalizedSwNames = 	&localizedSwNames;

   180 	if(!aSwTypesNum)

   181 		plocalizedSwNames = NULL;

   182 	

   183 	HBufC *mimeType2BChecked (0);

   184 	if(mimeTypesArray.Count() > 0)

   185 		mimeType2BChecked = mimeTypesArray[0]->AllocLC();

   186 	else

   187 		mimeType2BChecked = KNullDesC().AllocLC();

   188 	

   189 	Usif::CSoftwareTypeRegInfo* swType = Usif::CSoftwareTypeRegInfo::NewL(aUniqueSwTypeName);

   190 	CleanupStack::PushL(swType);

   191 	swType->SetSifPluginUid(aSifPluginUid);

   192 	for(TInt i=0;i<aInstallerSids.Count(); ++i)

   193 		{

   194 		swType->SetCustomAccessL(aInstallerSids[i]);

   195 		}

   196 	if(aMimeTypeNum)

   197 	    {

   198 	    for(TInt i=0;i<mimeTypesArray.Count(); ++i)

   199 	        {

   200 	        swType->SetMimeTypeL(mimeTypesArray[i]->Des());

   201 	        }

   202         }

   203 	

   204 	swType->SetLauncherExecutableL(aLauncherExecutable);

   205 	if(plocalizedSwNames)

   206 	    {

   207 	    for(TInt i=0;i<plocalizedSwNames->Count(); ++i)

   208 	        {

   209 	        swType->SetLocalizedSoftwareTypeNameL(plocalizedSwNames->operator [](i)->Locale(), plocalizedSwNames->operator [](i)->NameL());

   210 	        }

   211 	    }

   212 	

   213 	TRAPD(err, aScrSession.AddSoftwareTypeL(*swType));

   214 	VerifySoftwareTypeAdditionL(err, aOpResult, aScrSession, *mimeType2BChecked, aSifPluginUid);

   215 	CleanupStack::PopAndDestroy(4, &mimeTypesArray); // mimeTypesArray, localizedSwNames, mimeType2BChecked

   216 	return err;

   217 	}

   218 

   219 void CScrAccessSession::ServiceL(const RMessage2& aMessage)

   220 	{

   221 	TInt err(0);

   222 	TTime timer;

   223 	StartTimer(timer);

   224 	TInt actualTestDuration(0);

   225 	

   226 	RScrAccessor::TAccessorOperationResult opResult = RScrAccessor::EOpSucessful;

   227 	

   228 	TScrAccessMessages f = static_cast<TScrAccessMessages>(aMessage.Function());

   229 	

   230 	if(EAddSoftwareType == f || EDeleteSoftwareType == f)

   231 		{

   232 		User::LeaveIfError(Server().ScrSession().Connect());

   233 		// create transaction on SCR for mutable operations

   234 		Server().ScrSession().CreateTransactionL();

   235 		}

   236 	

   237 	switch (f)

   238 		{

   239 		case EAddSoftwareType:

   240 			{

   241 			RScrAccessor::TAccessorOperationType opType = static_cast<RScrAccessor::TAccessorOperationType>(aMessage.Int0());

   242 			

   243 			TUid localizedSifPluginUid = {0xA01B7222};

   244 			RArray<TCustomAccessInfo> locSidArray;

   245 			CleanupClosePushL(locSidArray);

   246 			               

   247 			TCustomAccessInfo id1(TSecureId(0x10285BC9), static_cast<TAccessMode>(1));

   248 			locSidArray.AppendL(id1);

   249 			                    

   250 			_LIT(KMimeTypeBaseNameLocalized, "test_mimetype_localizedinstaller");

   251 			_LIT(KSwTypeBaseLocalizableName, "test_localizedinstaller_name");

   252 			_LIT(KSwTypeUniqueNameLocalized, "test_localizedinstaller_uniquename");

   253 								

   254 			switch(opType)

   255 				{

   256 				case RScrAccessor::EAddNonLocalizedSoftwareType:

   257 					{	

   258 					TUid sifPluginUid = {0xA01B7211};

   259 			

   260 					RArray<TCustomAccessInfo> sidArray;

   261 					CleanupClosePushL(sidArray);

   262 					    

   263 					TCustomAccessInfo id1(TSecureId(0x10285BC9), static_cast<TAccessMode>(1));

   264 					TCustomAccessInfo id2(TSecureId(0xAAEEDD11), static_cast<TAccessMode>(1));

   265 					sidArray.AppendL(id1);

   266 					sidArray.AppendL(id2);

   267 					    

   268 					_LIT(KMimeTypeBaseName, "test_mimetype_nonlocalizedinstaller");

   269 					_LIT(KSwTypeUniqueName, "test_nonlocalizedinstaller_uniquename");

   270 										

   271 					err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueName, sifPluginUid, sidArray,  KMimeTypeBaseName, 2, KNullDesC, 0, KNullDesC, opResult);

   272 					CleanupStack::PopAndDestroy(&sidArray);

   273 					break;

   274 					}

   275 				case RScrAccessor::EAddLocalizedSoftwareType:

   276 					{

   277 					err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueNameLocalized, localizedSifPluginUid, locSidArray, KMimeTypeBaseNameLocalized, 2, KSwTypeBaseLocalizableName, 2, KNullDesC, opResult);

   278 					break;

   279 					}

   280 				case RScrAccessor::EAddSofwtareTypeWithoutMimeTypes:

   281 					{

   282 					TUid sifPluginUid = {0xA01B7333};

   283 					RArray<TCustomAccessInfo> sidArray;

   284 					CleanupClosePushL(sidArray);

   285 					                    

   286 					TCustomAccessInfo id1(TSecureId(0x10285BC9), static_cast<TAccessMode>(1));

   287 					sidArray.AppendL(id1);	

   288 					_LIT(KSwTypeUniqueName, "test_nomimeinstaller_uniquename");

   289 					

   290 					err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueName, sifPluginUid, sidArray, KNullDesC, 0, KNullDesC, 0, KNullDesC, opResult);

   291 					CleanupStack::PopAndDestroy(&sidArray);

   292 					break;

   293 					} 

   294 				case RScrAccessor::EAddLocalizedSoftwareTypeWithDifferentPluginUid:

   295 					{

   296 					TUid localizedDifferentSifPluginUid = {0xCC1B7333};

   297 					err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueNameLocalized, localizedDifferentSifPluginUid, locSidArray, KMimeTypeBaseNameLocalized, 2, KSwTypeBaseLocalizableName, 2, KNullDesC, opResult);

   298 					if(KErrAlreadyExists == err)

   299 						err = KErrNone; // The expected result is KErrAlreadyExists. So return no error to the test client.

   300 					break;

   301 					}

   302 				case RScrAccessor::EAddLocalizedSoftwareTypeWithExtraName:

   303 					{

   304 					err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueNameLocalized, localizedSifPluginUid, locSidArray, KMimeTypeBaseNameLocalized, 2, KSwTypeBaseLocalizableName, 3, KNullDesC, opResult);

   305 					if(KErrAlreadyExists == err)

   306 						err = KErrNone; // The expected result is KErrAlreadyExists. So return no error to the test client.

   307 					break;

   308 					}

   309 				case RScrAccessor::EAddLocalizedSoftwareTypeWithMissingName:

   310 					{

   311 					err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueNameLocalized, localizedSifPluginUid, locSidArray, KMimeTypeBaseNameLocalized, 2, KSwTypeBaseLocalizableName, 1, KNullDesC, opResult);

   312 					if(KErrAlreadyExists == err)

   313 						err = KErrNone; // The expected result is KErrAlreadyExists. So return no error to the test client.

   314 					break;

   315 					}

   316 				case RScrAccessor::EAddLocalizedSoftwareTypeWithExtraMime:

   317 					{

   318 					err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueNameLocalized, localizedSifPluginUid, locSidArray, KMimeTypeBaseNameLocalized, 3, KSwTypeBaseLocalizableName, 2, KNullDesC, opResult);

   319 					if(KErrAlreadyExists == err)

   320 						err = KErrNone; // The expected result is KErrAlreadyExists. So return no error to the test client.

   321 					break;

   322 					}

   323 				case RScrAccessor::EAddLocalizedSoftwareTypeWithMissingMime:

   324 					{

   325 					err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueNameLocalized, localizedSifPluginUid, locSidArray, KMimeTypeBaseNameLocalized, 1, KSwTypeBaseLocalizableName, 2, KNullDesC, opResult);

   326 					if(KErrAlreadyExists == err)

   327 						err = KErrNone; // The expected result is KErrAlreadyExists. So return no error to the test client.

   328 					break;

   329 					}

   330 				case RScrAccessor::EAddMultipleSidWithLauncherExecutable:

   331 				    {

   332 				    TUid sifPluginUid = {0xA01B7212};

   333 				    _LIT(KSwTypeUniqueName, "test_uniquename");

   334 				    _LIT(KMimeTypeBaseName, "test_mimetype");

   335 				    _LIT(KLauncherExecutable, "LauncherExecutable");

   336 				    RArray<TCustomAccessInfo> sidArray;

   337 				    CleanupClosePushL(sidArray);

   338 				                            

   339 				    TCustomAccessInfo id1(TSecureId(0x10285BC9), static_cast<TAccessMode>(1));

   340 				    TCustomAccessInfo id2(TSecureId(0xAAEEDD11), static_cast<TAccessMode>(1));

   341 				    TCustomAccessInfo id3(TSecureId(0xAAEEEE11), static_cast<TAccessMode>(1));

   342 

   343 				    sidArray.AppendL(id1);

   344 				    sidArray.AppendL(id2);

   345 				    sidArray.AppendL(id3);

   346 				    

   347 				    err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueName, sifPluginUid, sidArray, KMimeTypeBaseName, 1, KNullDesC, 0, KLauncherExecutable, opResult);

   348 				    CleanupStack::PopAndDestroy(&sidArray);

   349 				    break;

   350 				    }

   351 				} // switch(opType)

   352 			CleanupStack::PopAndDestroy(&locSidArray);

   353 			actualTestDuration = StopTimer(timer);

   354 			break;

   355 			}

   356 		case EDeleteSoftwareType:

   357 			{

   358 			_LIT(KSwTypeUniqueName, "test_nonlocalizedinstaller_uniquename");

   359 			_LIT(KMimeTypeBaseName, "test_mimetype_nonlocalizedinstaller");

   360 			RPointerArray<HBufC> deletedMimeTypes;

   361 			CleanupResetAndDestroyPushL(deletedMimeTypes);

   362 			TRAP(err, Server().ScrSession().DeleteSoftwareTypeL(KSwTypeUniqueName,deletedMimeTypes));

   363 			actualTestDuration = StopTimer(timer);

   364 				

   365 			// If the delete operation is successfull, check the returned MIME types deleted are as expected.

   366 			// If the delete operation fails, just return the error code to teh client.

   367 			if(KErrNone == err) 

   368 				{

   369 				RPointerArray<HBufC> mimeTypesArray;

   370 				CleanupResetAndDestroyPushL(mimeTypesArray);

   371 				RPointerArray<CLocalizedSoftwareTypeName> localizedSwNames;

   372 				GenerateTestDataL(mimeTypesArray, KMimeTypeBaseName, 2, localizedSwNames, KNullDesC, 0);

   373 

   374 				TInt expectedMimeTypesCount = mimeTypesArray.Count();

   375 				TInt retrievedMimeTypesCount = deletedMimeTypes.Count();

   376 				if(retrievedMimeTypesCount != expectedMimeTypesCount)

   377 					opResult = RScrAccessor::EOpFailUnexpectedMimeTypeNum;

   378 				else

   379 					{

   380 					for(TInt i=0; i<retrievedMimeTypesCount; ++i)

   381 						{

   382 						if(*(deletedMimeTypes[i]) != *(mimeTypesArray[i]))

   383 							opResult = RScrAccessor::EOpFailUnexpectedMimeTypeNum;;

   384 						} // for

   385 					} // if-else

   386 				

   387 				TRAP(err, Server().ScrSession().GetPluginUidL(KSwTypeUniqueName));

   388 				if(KErrNone == err)

   389 					{

   390 					// The plugin UID has been retrieved successfully. This is unexpected result.

   391 					opResult = RScrAccessor::EOpFailSwTypeStillExists;

   392 					}

   393 				else if(KErrSifUnsupportedSoftwareType == err)

   394 					{

   395 					// The plugin UID couldn't be found as expected. As the operation is successfull,

   396 					// return KErrNone to the client

   397 					err = KErrNone;

   398 					}

   399 				CleanupStack::PopAndDestroy(&mimeTypesArray);

   400 				} 

   401 			CleanupStack::PopAndDestroy(&deletedMimeTypes);

   402 			break;

   403 			}

   404 		case EDeleteFile:

   405 			{

   406 			HBufC *file = ReadDescFromMessageLC(aMessage, 0);

   407 			RFs fs;

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

   409 			CleanupClosePushL(fs);

   410 			err = fs.Delete(*file);

   411 			CleanupStack::PopAndDestroy(2, file); // file, fs

   412 			break;

   413 			}

   414 		case ECopyFile:

   415 			{

   416 			HBufC *sourceFile = ReadDescFromMessageLC(aMessage, 0);

   417 			HBufC *targetFile = ReadDescFromMessageLC(aMessage, 1);

   418 			RFs fs;

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

   420 			CleanupClosePushL(fs);

   421 			

   422 			CFileMan* fileManager = CFileMan::NewL(fs);

   423 			CleanupStack::PushL(fileManager);

   424 			err = fileManager->Copy(*sourceFile, *targetFile, 0);

   425 

   426 			// Reset the read-only attribute on the copied file

   427 			TTime time;

   428 			User::LeaveIfError(fileManager->Attribs(*targetFile, 0, KEntryAttReadOnly, time));		

   429 			CleanupStack::PopAndDestroy(4, sourceFile); // sourceFile, targetFile, fs, fileManager

   430 			break;

   431 			}

   432 		default:

   433 			{

   434 			PanicClient(aMessage, EPanicIllegalFunction);

   435 			break;

   436 			}

   437 		}

   438 	

   439 	if(EAddSoftwareType == f || EDeleteSoftwareType == f)

   440 		{

   441 		// create transaction on SCR for mutable operations

   442 		Server().ScrSession().CommitTransactionL();

   443 		

   444 		TPckg<TInt> timePckg(actualTestDuration);

   445 		TPckg<RScrAccessor::TAccessorOperationResult> opResultPckg(opResult);

   446 			

   447 		if(EDeleteSoftwareType == f)

   448 			{

   449 			aMessage.WriteL(0, opResultPckg);

   450 			aMessage.WriteL(1, timePckg);

   451 			}

   452 		else if (EAddSoftwareType == f)

   453 			{

   454 			aMessage.WriteL(1, opResultPckg);

   455 			aMessage.WriteL(2, timePckg);

   456 			}

   457 		}

   458 

   459 	aMessage.Complete(err);

   460 	}

   461 

   462 void CScrAccessSession::ServiceError(const RMessage2& aMessage, TInt aError)

   463 	{

   464 	if (aError == KErrBadDescriptor)

   465 		PanicClient(aMessage, EPanicBadDescriptor);

   466 	CSession2::ServiceError(aMessage,aError);

   467 	}

   468 

   469 

   470