1 /*

     2 * Copyright (c) 2008-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 * 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 

    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, TSecureId aInstallerSid, TSecureId aExecutionLayerSid, const TDesC& aBaseMimeTypeName, TInt aMimeTypeNum, const TDesC& aBaseSwTypeName, TInt aSwTypesNum, 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 	TRAPD(err, aScrSession.AddSoftwareTypeL(aUniqueSwTypeName, aSifPluginUid, aInstallerSid, aExecutionLayerSid, mimeTypesArray, plocalizedSwNames));

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

   191 	CleanupStack::PopAndDestroy(3, &mimeTypesArray); // mimeTypesArray, localizedSwNames, mimeType2BChecked

   192 	return err;

   193 	}

   194 

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

   196 	{

   197 	TInt err(0);

   198 	TTime timer;

   199 	StartTimer(timer);

   200 	TInt actualTestDuration(0);

   201 	

   202 	RScrAccessor::TAccessorOperationResult opResult = RScrAccessor::EOpSucessful;

   203 	

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

   205 	

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

   207 		{

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

   209 		// create transaction on SCR for mutable operations

   210 		Server().ScrSession().CreateTransactionL();

   211 		}

   212 	

   213 	switch (f)

   214 		{

   215 		case EAddSoftwareType:

   216 			{

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

   218 			

   219 			TUid localizedSifPluginUid = {0xA01B7222};

   220 			_LIT_SECURE_ID(localizedInstallerSid, 0x10285BC9);					

   221 			_LIT(KMimeTypeBaseNameLocalized, "test_mimetype_localizedinstaller");

   222 			_LIT(KSwTypeBaseLocalizableName, "test_localizedinstaller_name");

   223 			_LIT(KSwTypeUniqueNameLocalized, "test_localizedinstaller_uniquename");

   224 								

   225 			switch(opType)

   226 				{

   227 				case RScrAccessor::EAddNonLocalizedSoftwareType:

   228 					{	

   229 					TUid sifPluginUid = {0xA01B7211};

   230 					_LIT_SECURE_ID(installerSid, 0x10285BC9);

   231 					_LIT_SECURE_ID(executionLayerSid, 0xAAEEDD11);

   232 					

   233 					_LIT(KMimeTypeBaseName, "test_mimetype_nonlocalizedinstaller");

   234 					_LIT(KSwTypeUniqueName, "test_nonlocalizedinstaller_uniquename");

   235 										

   236 					err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueName, sifPluginUid, installerSid, executionLayerSid, KMimeTypeBaseName, 2, KNullDesC, 0, opResult);

   237 					break;

   238 					}

   239 				case RScrAccessor::EAddLocalizedSoftwareType:

   240 					{

   241 					err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueNameLocalized, localizedSifPluginUid, localizedInstallerSid, localizedInstallerSid, KMimeTypeBaseNameLocalized, 2, KSwTypeBaseLocalizableName, 2, opResult);

   242 					break;

   243 					}

   244 				case RScrAccessor::EAddSofwtareTypeWithoutMimeTypes:

   245 					{

   246 					TUid sifPluginUid = {0xA01B7333};

   247 					_LIT_SECURE_ID(installerSid, 0x10285BC9);

   248 										

   249 					_LIT(KSwTypeUniqueName, "test_nomimeinstaller_uniquename");

   250 					

   251 					err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueName, sifPluginUid, installerSid, installerSid, KNullDesC, 0, KNullDesC, 0, opResult);

   252 					break;

   253 					} 

   254 				case RScrAccessor::EAddLocalizedSoftwareTypeWithDifferentPluginUid:

   255 					{

   256 					TUid localizedDifferentSifPluginUid = {0xCC1B7333};

   257 					err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueNameLocalized, localizedDifferentSifPluginUid, localizedInstallerSid, localizedInstallerSid, KMimeTypeBaseNameLocalized, 2, KSwTypeBaseLocalizableName, 2, opResult);

   258 					if(KErrAlreadyExists == err)

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

   260 					break;

   261 					}

   262 				case RScrAccessor::EAddLocalizedSoftwareTypeWithExtraName:

   263 					{

   264 					err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueNameLocalized, localizedSifPluginUid, localizedInstallerSid, localizedInstallerSid, KMimeTypeBaseNameLocalized, 2, KSwTypeBaseLocalizableName, 3, opResult);

   265 					if(KErrAlreadyExists == err)

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

   267 					break;

   268 					}

   269 				case RScrAccessor::EAddLocalizedSoftwareTypeWithMissingName:

   270 					{

   271 					err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueNameLocalized, localizedSifPluginUid, localizedInstallerSid, localizedInstallerSid, KMimeTypeBaseNameLocalized, 2, KSwTypeBaseLocalizableName, 1, opResult);

   272 					if(KErrAlreadyExists == err)

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

   274 					break;

   275 					}

   276 				case RScrAccessor::EAddLocalizedSoftwareTypeWithExtraMime:

   277 					{

   278 					err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueNameLocalized, localizedSifPluginUid, localizedInstallerSid, localizedInstallerSid, KMimeTypeBaseNameLocalized, 3, KSwTypeBaseLocalizableName, 2, opResult);

   279 					if(KErrAlreadyExists == err)

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

   281 					break;

   282 					}

   283 				case RScrAccessor::EAddLocalizedSoftwareTypeWithMissingMime:

   284 					{

   285 					err = AddSoftwareTypeL(Server().ScrSession(), KSwTypeUniqueNameLocalized, localizedSifPluginUid, localizedInstallerSid, localizedInstallerSid, KMimeTypeBaseNameLocalized, 1, KSwTypeBaseLocalizableName, 2, opResult);

   286 					if(KErrAlreadyExists == err)

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

   288 					break;

   289 					}				

   290 				} // switch(opType)

   291 			actualTestDuration = StopTimer(timer);

   292 			break;

   293 			}

   294 		case EDeleteSoftwareType:

   295 			{

   296 			_LIT(KSwTypeUniqueName, "test_nonlocalizedinstaller_uniquename");

   297 			_LIT(KMimeTypeBaseName, "test_mimetype_nonlocalizedinstaller");

   298 			RPointerArray<HBufC> deletedMimeTypes;

   299 			CleanupResetAndDestroyPushL(deletedMimeTypes);

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

   301 			actualTestDuration = StopTimer(timer);

   302 				

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

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

   305 			if(KErrNone == err) 

   306 				{

   307 				RPointerArray<HBufC> mimeTypesArray;

   308 				CleanupResetAndDestroyPushL(mimeTypesArray);

   309 				RPointerArray<CLocalizedSoftwareTypeName> localizedSwNames;

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

   311 

   312 				TInt expectedMimeTypesCount = mimeTypesArray.Count();

   313 				TInt retrievedMimeTypesCount = deletedMimeTypes.Count();

   314 				if(retrievedMimeTypesCount != expectedMimeTypesCount)

   315 					opResult = RScrAccessor::EOpFailUnexpectedMimeTypeNum;

   316 				else

   317 					{

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

   319 						{

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

   321 							opResult = RScrAccessor::EOpFailUnexpectedMimeTypeNum;;

   322 						} // for

   323 					} // if-else

   324 				

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

   326 				if(KErrNone == err)

   327 					{

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

   329 					opResult = RScrAccessor::EOpFailSwTypeStillExists;

   330 					}

   331 				else if(KErrSifUnsupportedSoftwareType == err)

   332 					{

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

   334 					// return KErrNone to the client

   335 					err = KErrNone;

   336 					}

   337 				CleanupStack::PopAndDestroy(&mimeTypesArray);

   338 				} 

   339 			CleanupStack::PopAndDestroy(&deletedMimeTypes);

   340 			break;

   341 			}

   342 		case EDeleteFile:

   343 			{

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

   345 			RFs fs;

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

   347 			CleanupClosePushL(fs);

   348 			err = fs.Delete(*file);

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

   350 			break;

   351 			}

   352 		case ECopyFile:

   353 			{

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

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

   356 			RFs fs;

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

   358 			CleanupClosePushL(fs);

   359 			

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

   361 			CleanupStack::PushL(fileManager);

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

   363 

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

   365 			TTime time;

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

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

   368 			break;

   369 			}

   370 		default:

   371 			{

   372 			PanicClient(aMessage, EPanicIllegalFunction);

   373 			break;

   374 			}

   375 		}

   376 	

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

   378 		{

   379 		// create transaction on SCR for mutable operations

   380 		Server().ScrSession().CommitTransactionL();

   381 		

   382 		TPckg<TInt> timePckg(actualTestDuration);

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

   384 			

   385 		if(EDeleteSoftwareType == f)

   386 			{

   387 			aMessage.WriteL(0, opResultPckg);

   388 			aMessage.WriteL(1, timePckg);

   389 			}

   390 		else if (EAddSoftwareType == f)

   391 			{

   392 			aMessage.WriteL(1, opResultPckg);

   393 			aMessage.WriteL(2, timePckg);

   394 			}

   395 		}

   396 

   397 	aMessage.Complete(err);

   398 	}

   399 

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

   401 	{

   402 	if (aError == KErrBadDescriptor)

   403 		PanicClient(aMessage, EPanicBadDescriptor);

   404 	CSession2::ServiceError(aMessage,aError);

   405 	}

   406 

   407 

   408