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 * Defines the class which implements SCR's service requests.

    16 *

    17 */

    18 

    19 

    20 /**

    21  @file

    22  @internalComponent

    23  @released

    24 */

    25 

    26 #include "scrrequestimpl.h"

    27 #include "scrdatabase.h"

    28 #include "screntries.h"

    29 #include "scrserver.h"

    30 #include "scrcommon.h"

    31 #include "scrsubsession.h"

    32 #include "usiflog.h"

    33 #include "usiferror.h"

    34 #include <s32mem.h>

    35 #include <bautils.h>

    36 #include <scs/streamingarray.h>

    37 #include <scs/ipcstream.h>

    38 #include <scs/ipcstream.inl>

    39 #include <scs/cleanuputils.h>

    40 #include <e32hashtab.h>

    41 #include <usif/sts/sts.h>

    42 

    43 using namespace Usif;

    44 

    45 _LIT(KComponentIdColumnName, "ComponentId"); 

    46 _LIT(KCompFileIdColumnName, "CmpFileId"); 

    47 _LIT(KComponentPropertiesTable, "ComponentProperties");

    48 _LIT(KFilePropertiesTable, "FileProperties");

    49 

    50 /** Maximum number of log records could be recorded by SCR. */

    51 // It is estimated that a thousand log entries create 40K-100K log file.

    52 const TInt KMaxScrLogEntries = 1000;

    53 /** The file path of SCR log file. */

    54 _LIT(KScrLogFileName, "!:\\private\\10285bc0\\scr.log");

    55 /** The file path of SCR temporary log file. */

    56 _LIT(KScrTempLogFileName, "!:\\private\\10285bc0\\scr_tmp.log");

    57 	

    58 const TUint KDbInterfaceMajorVersion = 1;

    59 const TUint KDbInterfaceMinorVersion = 1;

    60 #ifdef _DEBUG

    61 const TUint KDbInterfaceBuildNumber = 1;

    62 #endif

    63 

    64 enum TScrPanicId

    65 	{

    66 	KScrIllegalCallSequence = 1,

    67 	KScrIllegalParameter = 2

    68 	};

    69 

    70 static void PanicClient(const RMessagePtr2& aMessage, TScrPanicId aPanic)

    71 	{

    72 	_LIT(KPanicMessage, "ScrServer");

    73     aMessage.Panic(KPanicMessage, aPanic);

    74     }

    75 

    76 HBufC* UpdateFilePathDriveLC(const TDesC& aFilePath, TChar aDrive)

    77 	{

    78 	HBufC *fileName = HBufC::NewLC(aFilePath.Length());

    79 	TPtr ptrFileName(fileName->Des());

    80 	ptrFileName.Copy(aFilePath);

    81 	ptrFileName[0] = aDrive;

    82 	return fileName; 

    83 	}	

    84 	

    85 ////////////////////////

    86 // CScrRequestImpl

    87 ////////////////////////

    88 

    89 CScrRequestImpl::CScrRequestImpl(RFs& aFs)

    90 	: iFs(aFs)

    91 	{

    92 	}

    93 

    94 CScrRequestImpl::~CScrRequestImpl()

    95 	{

    96 	delete iDbHandle;

    97 	delete iComponentEntry;

    98 	iProperties.ResetAndDestroy();

    99 	delete iSingleProperty;

   100 	iFileComponents.Close();

   101 	iVerCompIdList.ResetAndDestroy();

   102 	iDeletedMimeTypes.ResetAndDestroy();

   103 	iLogEntries.ResetAndDestroy();

   104 	iMatchingSupportedLanguageList.Close();

   105 	}

   106 

   107 CScrRequestImpl* CScrRequestImpl::CScrRequestImpl::NewL(RFs& aFs, RFile& aDatabaseFile, RFile& aJournalFile)

   108 	{

   109 	CScrRequestImpl *self = new(ELeave) CScrRequestImpl(aFs);

   110 	CleanupStack::PushL(self);

   111 	self->ConstructL(aDatabaseFile, aJournalFile);

   112 	CleanupStack::Pop(self);

   113 	return self;

   114 	}

   115 

   116 void CScrRequestImpl::ConstructL(RFile& aDatabaseFile, RFile& aJournalFile)

   117 	{

   118 	iDbHandle = CDatabase::NewL(aDatabaseFile, aJournalFile);

   119 	InitializeDbVersionL();

   120 	VerifyDbVersionCompatibilityL();

   121 	// Make sure that private directory exists - required for temporary and log files

   122 	_LIT(KPrivateDirPath, "!:\\private\\10285bc0\\");

   123 	HBufC* privateDirPath = UpdateFilePathDriveLC(KPrivateDirPath, iFs.GetSystemDriveChar());

   124 	TInt res = iFs.MkDirAll(*privateDirPath);

   125 	__ASSERT_ALWAYS(res == KErrNone || res == KErrAlreadyExists, User::Leave(res));

   126 	CleanupStack::PopAndDestroy(privateDirPath);

   127 	}

   128 

   129 HBufC* CScrRequestImpl::ReadDescLC(const RMessage2& aMessage, TInt aSlot)

   130 	{

   131 	TInt len = aMessage.GetDesLengthL(aSlot);

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

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

   134 	aMessage.ReadL(aSlot, ptrDesc);

   135 	return desc;

   136 	}

   137 

   138 HBufC8* CScrRequestImpl::ReadDesc8LC(const RMessage2& aMessage, TInt aSlot)

   139 	{

   140 	TInt len = aMessage.GetDesLengthL(aSlot);

   141 	HBufC8* desc = HBufC8::NewLC(len);

   142 	TPtr8 ptrDesc(desc->Des());

   143 	aMessage.ReadL(aSlot, ptrDesc);

   144 	return desc;

   145 	}

   146 

   147 HBufC* CScrRequestImpl::FormatStatementLC(const TDesC& aStatement, TInt aFormattedLength,...) const

   148 	{

   149 	VA_LIST list;

   150 	VA_START(list, aFormattedLength);

   151 	HBufC* statementStr = HBufC::NewLC(aStatement.Length() + aFormattedLength + 1);

   152 	TPtr statementStrPtr(statementStr->Des()); 

   153 	statementStrPtr.FormatList(aStatement, list);

   154 	VA_END(list);

   155 	

   156 	// SQLite requires the statement string to end with NULL char.

   157 	statementStrPtr.Append('\0');

   158 	return statementStr;

   159 	}

   160 

   161 void CScrRequestImpl::CreateTransactionL()

   162 	{

   163 	DEBUG_PRINTF(_L8("Create Transaction request received."));

   164 	_LIT(KBeginTransaction, "BEGIN IMMEDIATE;");

   165 	ExecuteStatementL(KBeginTransaction());	

   166 	DEBUG_PRINTF(_L8("Transaction has begun!"));

   167 	}

   168 

   169 void CScrRequestImpl::RollbackTransactionL()

   170 	{

   171 	DEBUG_PRINTF(_L8("Rollback Transaction request received."));

   172 	_LIT(KRollbackTransaction, "ROLLBACK;");

   173 	ExecuteStatementL(KRollbackTransaction());

   174 	DEBUG_PRINTF(_L8("Transaction has been rolled back successfuly!"));

   175 	}

   176 

   177 void CScrRequestImpl::CommitTransactionL()

   178 	{

   179 	DEBUG_PRINTF(_L8("Commit Transaction request received."));

   180 	_LIT(KCommitTransaction, "COMMIT;");

   181 	ExecuteStatementL(KCommitTransaction());

   182 	DEBUG_PRINTF(_L8("Transaction has been committed successfully!"));

   183 	}

   184 

   185 HBufC* CScrRequestImpl::GenerateGlobalIdL(const TDesC& aUniqueSwTypeName, const TDesC& aGlobalId) const

   186 	{ 

   187 	HBufC *globalIdBuf = HBufC::NewL(aUniqueSwTypeName.Length() + aGlobalId.Length() + 1); // 1 is extra memory to put NULL char

   188 	TPtr globalIdDes(globalIdBuf->Des());

   189 	

   190 	globalIdDes.Copy(aUniqueSwTypeName);

   191 	globalIdDes.Append('\0');

   192 	globalIdDes.Append(aGlobalId);

   193 	

   194 	return globalIdBuf;

   195 	}

   196 

   197 TComponentId CScrRequestImpl::CommonAddComponentL(const TDesC& aUniqueSwTypeName, const TDesC& aGlobalId)

   198 	{

   199 	DEBUG_PRINTF(_L8("Adding a base component."));

   200 	// Get the current time

   201 	TTime time;

   202 	time.HomeTime();

   203 	TDateTime datetime = time.DateTime();

   204 	TBuf<16> installTime;

   205 	// We cannot use TTime::FormatL, since it starts months and days with 01, which is not accepted by TTime::Set() which starts them from 0

   206 	installTime.Format(_L("%04d%02d%02d:%02d%02d%02d"), datetime.Year(), datetime.Month(), datetime.Day(), datetime.Hour(), datetime.Minute(), datetime.Second());

   207 	

   208 	// SoftwareTypeId is the hash of unique software type name. For more information, see CScrRequestImpl::AddSoftwareTypeL.

   209 	// In Components table, both SoftwareTypeId and unique SoftwareTypeName is stored so that the software type name of a component

   210 	// can be returned even if the corresponding installer (software type) has been uninstalled. The unique sofware type name

   211 	// might be used by the client to identify the installer required to uninstall the component.

   212 	TUint32 swTypeId = HashCaseSensitiveL(aUniqueSwTypeName);

   213 	

   214 	if(aGlobalId.CompareF(KNullDesC()))

   215 		{ // Global Id is supplied by client

   216 		HBufC *globalId = GenerateGlobalIdL(aUniqueSwTypeName, aGlobalId);

   217 		CleanupStack::PushL(globalId);

   218 		TUint32 globalIdHash = HashCaseSensitiveL(*globalId);

   219 		

   220 		_LIT(KInsertComponent,"INSERT INTO Components(SoftwareTypeId,SoftwareTypeName,GlobalIdHash,GlobalId,InstallTime) VALUES(?,?,?,?,?);");

   221 		TInt numberOfValues = 5;

   222 		ExecuteStatementL(KInsertComponent(), numberOfValues, EValueInteger, swTypeId, EValueString, &aUniqueSwTypeName, EValueInteger, globalIdHash, EValueString, globalId, EValueString, &installTime);

   223 		CleanupStack::PopAndDestroy(globalId);

   224 		}

   225 	else

   226 		{// Global Id is NOT supplied by client

   227 		_LIT(KInsertComponent,"INSERT INTO Components(SoftwareTypeId,SoftwareTypeName,InstallTime) VALUES(?,?,?);");

   228 		TInt numberOfValues = 3;

   229 		ExecuteStatementL(KInsertComponent(), numberOfValues, EValueInteger, swTypeId, EValueString, &aUniqueSwTypeName, EValueString, &installTime);

   230 		}

   231 	

   232 	DEBUG_PRINTF(_L8("The new component has been added to Components table successfully."));

   233 	return iDbHandle->LastInsertedIdL();

   234 	}

   235 

   236 void CScrRequestImpl::AddComponentLocalizablesL(TComponentId aCompId, TLanguage aLocale, const TDesC& aName, const TDesC& aVendor)

   237 	{

   238 	DEBUG_PRINTF4(_L("Adding the component(%d) localizables: name(%S) and vendor(%S)."), aCompId, &aName, &aVendor);

   239 	

   240 	if(!aName.CompareF(KNullDesC()))

   241 		{// Component name cannot be empty

   242 		DEBUG_PRINTF(_L8("Component name cannot be NULL string."));

   243 		User::Leave(KErrArgument);

   244 		}

   245 	

   246 	_LIT(KInsertComponentLocalizables, "INSERT INTO ComponentLocalizables(ComponentId,Locale,Name,Vendor) VALUES(?,?,?,?);");

   247 	TInt numberOfValues = 4;

   248 	ExecuteStatementL(KInsertComponentLocalizables(), numberOfValues, EValueInteger, aCompId, EValueInteger, aLocale, EValueString, &aName, EValueString, &aVendor);

   249 	

   250 	DEBUG_PRINTF(_L8("The component localizables have been added successfully."));

   251 	}

   252 

   253 void CScrRequestImpl::ComponentRollback(TAny* aParam)

   254 	{

   255 	TRollbackParams *param = static_cast<TRollbackParams*>(aParam);

   256 	_LIT(KDeleteComponents, "DELETE FROM Components WHERE ComponentId=?;");

   257 	TInt numberOfValues = 1;

   258 	TRAP_IGNORE(param->iReqImplHandle.ExecuteStatementL(KDeleteComponents, numberOfValues, EValueInteger, param->iIdColumnVal););

   259 	}

   260 	

   261 void CScrRequestImpl::ComponentLocalizablesRollback(TAny* aParam)

   262 	{

   263 	TRollbackParams *param = static_cast<TRollbackParams*>(aParam);

   264 	_LIT(KDeleteComponentLocalizables, "DELETE FROM ComponentLocalizables WHERE ComponentId=?;");

   265 	TInt numberOfValues = 1;

   266 	TRAP_IGNORE(param->iReqImplHandle.ExecuteStatementL(KDeleteComponentLocalizables, numberOfValues, EValueInteger, param->iIdColumnVal););

   267 	}

   268 

   269 void CScrRequestImpl::AddComponentL(const RMessage2& aMessage)

   270 	{

   271 	DEBUG_PRINTF(_L8("Adding a new component."));

   272 	// First check if the supplied operation type is valid

   273 	TScrComponentOperationType compOpType;

   274 	TPckg<TScrComponentOperationType> opTypePckg(compOpType);

   275 	aMessage.ReadL(3, opTypePckg, 0);

   276 		

   277 	if(compOpType != EScrCompInstall && compOpType != EScrCompUpgrade && compOpType != EScrCompHidden)

   278 		{

   279 		DEBUG_PRINTF2(_L("Unexpected component operation type (%d) was provided!"), static_cast<TInt>(compOpType));

   280 		User::Leave(KErrArgument);

   281 		}

   282 	

   283 	RIpcReadStream componentInfoReader;

   284 	CleanupClosePushL(componentInfoReader);

   285 	componentInfoReader.Open(aMessage, 1);

   286 	

   287 	RPointerArray<CLocalizableComponentInfo> componentInfoArray;

   288 	CleanupResetAndDestroyPushL(componentInfoArray);

   289 	InternalizePointersArrayL(componentInfoArray, componentInfoReader);

   290 	TInt arrayCount = componentInfoArray.Count();

   291 	// This check is done at the client side - if we get this condition here, this means that a rogue client-server call bypassed the R-class

   292 	__ASSERT_ALWAYS(arrayCount > 0, PanicClient(aMessage, KScrIllegalParameter));

   293 

   294 	HBufC *uniqueSwTypeName = GetSoftwareTypeNameFromMsgLC(aMessage);

   295 	HBufC *globalId = ReadDescLC(aMessage, 2);

   296 	TComponentId newComponentId = CommonAddComponentL(*uniqueSwTypeName, *globalId);

   297 	

   298 	// Add the newly added component into the cleanupstack so that it can be deleted in case of leaving.

   299 	TRollbackParams cleanupParam(newComponentId, *this);

   300 	CleanupStack::PushL(TCleanupItem(CScrRequestImpl::ComponentRollback, &cleanupParam));

   301 	// Add the component localizables cleanup into the cleanupstack so that they can be deleted in case of leaving.

   302 	CleanupStack::PushL(TCleanupItem(CScrRequestImpl::ComponentLocalizablesRollback, &cleanupParam));

   303 	

   304 	// For a log record, the component name is chosen for the current locale. If it doesn't exist, 

   305 	// then the non-localized component name is picked. If none of them exist, the first name in the names 

   306 	// array is used as default.

   307 	TInt componentNameIndexForLog (0);

   308 	TInt indexForCurrentLocale = KErrNotFound;

   309 	TInt indexForNonLocalized = KErrNotFound;

   310 	for(TInt i=0; i<arrayCount; ++i)

   311 		{

   312 		TLanguage locale(componentInfoArray[i]->Locale());

   313 		const TDesC& name = componentInfoArray[i]->NameL();

   314 		const TDesC& vendor = componentInfoArray[i]->VendorL();

   315 		AddComponentLocalizablesL(newComponentId, locale, name, vendor);

   316 		if(locale == User::Language())

   317 			indexForCurrentLocale = i;

   318 		else if(locale == KNonLocalized)

   319 			indexForNonLocalized = i;

   320 		}

   321 	CleanupStack::Pop(2, &cleanupParam); // cleanupitem for ComponentRollback, cleanupitem for ComponentLocalizablesRollback

   322 	

   323 	if(indexForCurrentLocale != KErrNotFound)

   324 		componentNameIndexForLog = indexForCurrentLocale;

   325 	else if(indexForNonLocalized != KErrNotFound)

   326 		componentNameIndexForLog = indexForNonLocalized;

   327 	

   328 	if(EScrCompHidden != compOpType)

   329 		{

   330 		CScrLogEntry *logRecord = CScrLogEntry::NewLC(componentInfoArray[componentNameIndexForLog]->NameL(), *uniqueSwTypeName, *globalId, KNullDesC, compOpType);

   331 		logRecord->iComponentId = newComponentId;

   332 		iLogEntries.Append(logRecord);

   333 		CleanupStack::Pop(logRecord); // Ownershipd is transferred

   334 		}

   335 	CleanupStack::PopAndDestroy(4, &componentInfoReader); // componentInfoReader, componentInfoArray, uniqueSwTypeName, globalId

   336 	

   337 	TPckg<TComponentId> componentIdDes(newComponentId);

   338 	aMessage.WriteL(3, componentIdDes);

   339 	}

   340 

   341 HBufC* CScrRequestImpl::ReadAndGetGlobalIdLC(const RMessage2& aMessage, TInt aSlot) const

   342 	{

   343 	// Read global id object from the message

   344 	CGlobalComponentId *globalId = ReadObjectFromMessageLC<CGlobalComponentId>(aMessage, aSlot);

   345 	HBufC *globalIdBuf = GenerateGlobalIdL(globalId->SoftwareTypeName(), globalId->GlobalIdName());

   346 	CleanupStack::PopAndDestroy(globalId);

   347 	CleanupStack::PushL(globalIdBuf);

   348 	return globalIdBuf;

   349 	}

   350 

   351 TUint32 CScrRequestImpl::HashGlobalIdsL(const TDesC& aDependantId, const TDesC& aSupplierId) const

   352 	{

   353 	RBuf concatGlobalIds;

   354 	concatGlobalIds.CreateL(aDependantId.Length() + aSupplierId.Length());

   355 	concatGlobalIds.CleanupClosePushL();

   356 	concatGlobalIds.Copy(aDependantId);

   357 	concatGlobalIds.Append(aSupplierId);

   358 	TUint32 globalIdsHash = HashCaseSensitiveL(concatGlobalIds);

   359 	CleanupStack::PopAndDestroy(&concatGlobalIds);

   360 	return globalIdsHash;

   361 	}

   362 

   363 void CScrRequestImpl::AddComponentDependencyL(const RMessage2& aMessage)

   364 	{

   365 	DEBUG_PRINTF(_L8("Adding a new component dependency."));

   366 	

   367 	CVersionedComponentId *verCompId = ReadObjectFromMessageLC<CVersionedComponentId>(aMessage, 1);

   368 	HBufC *suppGlobalId = GenerateGlobalIdL(verCompId->GlobalId().SoftwareTypeName(), verCompId->GlobalId().GlobalIdName());

   369 	CleanupStack::PushL(suppGlobalId);

   370 	TUint32 suppGlobalIdHash = HashCaseSensitiveL(*suppGlobalId);

   371 	

   372 	HBufC *depGlobalId = ReadAndGetGlobalIdLC(aMessage, 2);

   373 	TUint32 depGlobalIdHash = HashCaseSensitiveL(*depGlobalId);

   374 	

   375 	TUint32 globalIdsHash = HashGlobalIdsL(*depGlobalId, *suppGlobalId);

   376 	

   377 	const TDesC* versionFrom = verCompId->VersionFrom();

   378 	const TDesC* versionTo = verCompId->VersionTo();

   379 	

   380 	_LIT(KInsertDependencyFront, "INSERT INTO ComponentDependencies(GlobalIdHash,DependantGlobalIdHash,SupplierGlobalIdHash,DependantGlobalId,SupplierGlobalId");

   381 	_LIT(KInsertDependencyEnd, ") VALUES(?,?,?,?,?");

   382 

   383 	const TInt KMaxInsertDependencyLength = 180;     ///< Maximum length of a possible dependency insert statement (KInsertDependencyFront + KInsertDependencyEnd + some space for optional columns)

   384 	const TInt KMaxInsertDependencyValueLength = 30; ///< Maximum length of the end part of a possible dependency insert statement (KInsertDependencyEnd + some space for optional values).

   385 

   386 	TInt numberOfValues = 5; // 5->(GlobalIdHash, DependantGlobalIdHash, SupplierGlobalIdHash, DependantGlobalId, SupplierGlobalId)

   387 	RBuf insertStmtStr;

   388 	insertStmtStr.CreateL(KMaxInsertDependencyLength);

   389 	insertStmtStr.CleanupClosePushL();

   390 	insertStmtStr.Copy(KInsertDependencyFront());

   391 	

   392 	RBuf insertStmtEndStr;

   393 	insertStmtEndStr.CreateL(KMaxInsertDependencyValueLength);

   394 	insertStmtEndStr.CleanupClosePushL();

   395 	insertStmtEndStr.Copy(KInsertDependencyEnd());

   396 	

   397 	// VersionFrom and VersionTo values are optional. Hence, a dynamic insert statement will be created.

   398 	// insertStmtStr is initialized with the statement including mandatory columns. Then versionFrom/To

   399 	// values are checked. If any of them is provided, then the corresponding column name is added to the statement.

   400 	// insertStmtEndStr is constructed with a number of value characters(?) as new value chars will be added

   401 	// if new columns are added to the statement

   402 	// In the end, insertStmtEndStr is added to insertStmtStr in order to complete the dependency insert statement.

   403 	

   404 	const TDesC* firstVersionParam(0);

   405 	const TDesC* secondVersionParam(0);

   406 	

   407 	_LIT(KInsertValue, ",?");

   408 	if(versionFrom)

   409 		{

   410 		_LIT(KVersionFrom, ",VersionFrom");

   411 		insertStmtStr.Append(KVersionFrom());

   412 		insertStmtEndStr.Append(KInsertValue());

   413 		firstVersionParam = versionFrom;

   414 		++numberOfValues;

   415 		}

   416 	

   417 	if(versionTo)

   418 		{

   419 		_LIT(KVersionTo, ",VersionTo");

   420 		insertStmtStr.Append(KVersionTo());

   421 		insertStmtEndStr.Append(KInsertValue());

   422 		if(firstVersionParam)

   423 			{

   424 			secondVersionParam = versionTo;

   425 			}

   426 		else

   427 			{

   428 			firstVersionParam = versionTo;

   429 			}

   430 		++numberOfValues;

   431 		}

   432 	

   433 	// Append the end part of the statement to the front part.

   434 	insertStmtStr.Append(insertStmtEndStr);

   435 	// Close the statement

   436 	_LIT(KInsertClose,");");

   437 	insertStmtStr.Append(KInsertClose());

   438 	// SQLite requires the statement string to end with NULL char.

   439 	insertStmtStr.Append('\0');

   440 	// All parameters are supplied, but numberOfValues of them will be taken into account.

   441 	ExecuteStatementL(insertStmtStr, numberOfValues, EValueInteger, globalIdsHash, EValueInteger, depGlobalIdHash, EValueInteger, suppGlobalIdHash, EValueString, depGlobalId, EValueString, suppGlobalId, EValueString, firstVersionParam, EValueString, secondVersionParam);

   442 	

   443 	CleanupStack::PopAndDestroy(5, verCompId); // verCompId, suppGlobalId, depGlobalId, insertStmtStr, insertStmtEndStr

   444 	}

   445 

   446 CStatement* CScrRequestImpl::CreateGeneralPropertyStatementWithLocaleL(const TDesC& aStmtStr, TInt aIdColumnValue, TLanguage aLocale, const TDesC& aPropName, TBool aDoLocaleResolving) const

   447 	{

   448 	CStatement *stmt(0);

   449 	TInt numberOfValues = 3;

   450 	

   451 	if(KUnspecifiedLocale == aLocale)

   452 		{

   453 		// No locale is specified. Client wants SCR to find the property automatically.

   454 		// So, first look up the properties for the current locale and its downgraded languages.

   455 		ASSERT(aDoLocaleResolving); // We cannot get a situation where KUnspecifiedLocale is given with locale resolving disabled: it is an undefined state.

   456 		stmt = CreateStatementObjectWithLocaleL(aStmtStr, User::Language(), numberOfValues, EValueString, &aPropName, EValueInteger, aIdColumnValue, EValueLanguage);

   457 		

   458 		if(!stmt)

   459 			{

   460 			// No property is defined with the current locale. Look up the non-localized properties.

   461 			stmt = CreateStatementObjectWithLocaleL(aStmtStr, KNonLocalized, numberOfValues, EValueString, &aPropName, EValueInteger, aIdColumnValue, EValueLanguage);

   462 			}

   463 		}

   464 	else if(KNonLocalized == aLocale)

   465 		{

   466 		// Non-localized properties are requested. Look up the non-localized properties.

   467 		stmt = CreateStatementObjectWithLocaleL(aStmtStr, KNonLocalized, numberOfValues, EValueString, &aPropName, EValueInteger, aIdColumnValue, EValueLanguage);

   468 		}

   469 	else

   470 		{

   471 		// A particular language is specified. Look up the properties with for this particular language

   472 		// and its downgraded languages.

   473 		stmt = aDoLocaleResolving ? 

   474 			CreateStatementObjectWithLocaleL(aStmtStr, aLocale, numberOfValues, EValueString, &aPropName, EValueInteger, aIdColumnValue, EValueLanguage, aDoLocaleResolving) :

   475 			CreateStatementObjectWithLocaleNoDowngradeL(aStmtStr, aLocale, numberOfValues, EValueString, &aPropName, EValueInteger, aIdColumnValue, EValueLanguage, aDoLocaleResolving);

   476 		}

   477 	return stmt;

   478 	}

   479 

   480 TInt CScrRequestImpl::FindGeneralPropertyNoLocaleDowngradeL(const TDesC& aTableName, const TDesC& aIdColumnName, TInt aIdColumnValue, const TDesC& aPropertyName, TLanguage aLocale, TPropertyType& aPropertyType) const

   481 	{

   482 	_LIT(KFindProperty, "SELECT PropertyId,IntValue,StrValue,IsStr8Bit FROM %S WHERE Name=? AND %S=? AND Locale=?;");

   483 	TInt formattedLen = aTableName.Length() + aIdColumnName.Length();

   484 	HBufC *statementStr = FormatStatementLC(KFindProperty(), formattedLen, &aTableName, &aIdColumnName);

   485 

   486 	// As we do not require downgrading locales, the last parameter is EFalse

   487 	CStatement *stmtFind = CreateGeneralPropertyStatementWithLocaleL(*statementStr, aIdColumnValue, aLocale, aPropertyName, EFalse);

   488 	if(!stmtFind)

   489 		{ // the property does not exist, return

   490 		CleanupStack::PopAndDestroy(statementStr);

   491 		return KErrNotFound;

   492 		}

   493 	CleanupStack::PushL(stmtFind);

   494 	

   495 	// the property in question exists in the properties table 

   496 	TInt propertyId = stmtFind->IntColumnL(0);					// 0 -> PropertyId		

   497 	TBool isIntPropertyNull = stmtFind->IsFieldNullL(1); 	// 2 -> IntValue

   498 	TBool isStrPropertyNull = stmtFind->IsFieldNullL(2); 	// 3 -> StrValue

   499 			

   500 	if(!isIntPropertyNull)

   501 		{

   502 		aPropertyType = CScrRequestImpl::EPropertyInteger;

   503 		}

   504 	else if(!isStrPropertyNull)

   505 		{

   506 		TBool is8BitString = (stmtFind->IntColumnL(3) == 1);

   507 		aPropertyType = is8BitString ? CScrRequestImpl::EPropertyBinary : CScrRequestImpl::EPropertyLocalizable;

   508 		}

   509 	else // None of the columns is defined - corrupt DB 

   510 		{

   511 		DEBUG_PRINTF(_L8("Unexpected situation! Neither int value nor str value are defined for a property"));

   512 		User::Leave(KErrCorrupt);

   513 		}

   514 	CleanupStack::PopAndDestroy(2, statementStr); // stmtFind, statementStr

   515 	return propertyId;

   516 	}

   517 

   518 void CScrRequestImpl::BindStatementValuesL(CStatement& aStatement, TLanguage aLanguage, TInt aValuesNum, VA_LIST aList) const

   519 	{

   520 	TInt bindIdx(0);

   521 	while(aValuesNum--)

   522 		{

   523 		CScrRequestImpl::TValueType t = static_cast<CScrRequestImpl::TValueType>(VA_ARG(aList, TInt));

   524 		switch(t)

   525 			{

   526 			case EValueString:

   527 				{

   528 				const TDesC* strVal = VA_ARG(aList, const TDesC*);

   529 				aStatement.BindStrL(++bindIdx, *strVal);

   530 				break;

   531 				}

   532 			case EValueInteger:

   533 				{

   534 				TInt intVal = VA_ARG(aList, TInt);

   535 				aStatement.BindIntL(++bindIdx, intVal);

   536 				break;

   537 				}

   538 			case EValueInteger64:

   539 				{

   540 				TInt64 intVal64 = VA_ARG(aList, TInt64);

   541 				aStatement.BindInt64L(++bindIdx, intVal64);

   542 				break;

   543 				}

   544 			case EValueLanguage:

   545 				{

   546 				aStatement.BindIntL(++bindIdx, aLanguage);

   547 				break;

   548 				}

   549 			case EValueBinary:

   550 				{

   551 				const TDesC8* binaryVal = VA_ARG(aList, const TDesC8*);

   552 				aStatement.BindBinaryL(++bindIdx, *binaryVal);

   553 				break;

   554 				}				

   555 			default:

   556 				DEBUG_PRINTF2(_L8("Encountered unexpected value type (%d)!"), t);

   557 				ASSERT(0);

   558 			} // switch

   559 		} // while

   560 	} // End of the function

   561 

   562 void CScrRequestImpl::ExecuteStatementL(TRefByValue<const TDesC> aStatement, TInt aValuesNum,...)

   563 	{// TRefByValue is used to suppress rcvt compile warning

   564 	VA_LIST argList;

   565 	VA_START(argList, aValuesNum);

   566 	

   567 	CStatement *stmt = iDbHandle->PrepareStatementLC(aStatement);

   568 	BindStatementValuesL(*stmt, KLangNone, aValuesNum, argList);

   569 	stmt->ExecuteStatementL();

   570 	CleanupStack::PopAndDestroy(stmt);

   571 	

   572 	VA_END(argList);

   573 	}

   574 

   575 void CScrRequestImpl::SetGeneralLocalizablePropertyL(CScrRequestImpl::TPropertyType aPropType, TInt aPropertyId, const TDesC& aIdColumnName, TInt aIdColumnValue, const TDesC& aPropName, TLanguage aLocale, const TDesC& aPropValue)

   576 	{

   577 	switch(aPropType)

   578 		{

   579 		case CScrRequestImpl::EPropertyUndefined:

   580 			{// the property does NOT exist, insert a new one

   581 			_LIT(KInsertProperty, "INSERT INTO ComponentProperties(Name,Locale,%S,StrValue) VALUES(?,?,?,?);");

   582 			TInt formattedLen = aIdColumnName.Length();

   583 			HBufC *statementStr = FormatStatementLC(KInsertProperty(), formattedLen, &aIdColumnName );

   584 			TInt numberOfValues = 4;

   585 			ExecuteStatementL(*statementStr, numberOfValues, EValueString, &aPropName, EValueInteger, aLocale, EValueInteger, aIdColumnValue, EValueString, &aPropValue);

   586 			CleanupStack::PopAndDestroy(statementStr);

   587 			break;

   588 			}

   589 		case CScrRequestImpl::EPropertyLocalizable: 

   590 			{

   591 			// the property exists, update it

   592 			_LIT(KUpdateProperty, "UPDATE ComponentProperties SET StrValue=? WHERE PropertyId=?;");

   593 			TInt numberOfValues = 2;

   594 			ExecuteStatementL(KUpdateProperty(), numberOfValues, EValueString, &aPropValue, EValueInteger, aPropertyId);

   595 			break;

   596 			}

   597 		default:

   598 			DEBUG_PRINTF(_L8("The property type isn't localizable string and cannot be updated with this API."))

   599 			User::Leave(KErrAbort);

   600 		}

   601 	}

   602 

   603 void CScrRequestImpl::SetGeneralBinaryPropertyL(CScrRequestImpl::TPropertyType aPropType, TInt aPropertyId, const TDesC& aTableName, const TDesC& aIdColumnName, TInt aIdColumnValue, const TDesC& aPropName, const TDesC8& aPropValue)

   604 	{

   605 	switch(aPropType)

   606 		{

   607 		case CScrRequestImpl::EPropertyUndefined:

   608 			{// the property does NOT exist, insert a new one

   609 			_LIT(KInsertProperty, "INSERT INTO %S(Name,%S,StrValue,IsStr8Bit) VALUES(?,?,?,1);");

   610 			TInt formattedLen = aTableName.Length() + aIdColumnName.Length();

   611 			HBufC *statementStr = FormatStatementLC(KInsertProperty(), formattedLen, &aTableName, &aIdColumnName );

   612 			TInt numberOfValues = 3;

   613 			ExecuteStatementL(*statementStr, numberOfValues, EValueString, &aPropName, EValueInteger, aIdColumnValue, EValueBinary, &aPropValue);

   614 			CleanupStack::PopAndDestroy(statementStr);

   615 			break;

   616 			}

   617 		case CScrRequestImpl::EPropertyBinary: 

   618 			{

   619 			// the property exists, update it

   620 			_LIT(KUpdateProperty, "UPDATE %S SET StrValue=? WHERE PropertyId=?;");

   621 			HBufC *statementStr = FormatStatementLC(KUpdateProperty(), aTableName.Length(), &aTableName);

   622 			TInt numberOfValues = 2;

   623 			ExecuteStatementL(*statementStr, numberOfValues, EValueBinary, &aPropValue, EValueInteger, aPropertyId);

   624 			CleanupStack::PopAndDestroy(statementStr);

   625 			break;

   626 			}

   627 		default:

   628 			DEBUG_PRINTF(_L8("The property type isn't an 8-bit string and cannot be updated with this API."))

   629 			User::Leave(KErrAbort);

   630 		}

   631 	}

   632 

   633 void CScrRequestImpl::SetGeneralIntPropertyL(TPropertyType aPropType, TInt aPropertyId, const TDesC& aTableName, const TDesC& aIdColumnName , TInt aIdColumnValue, const TDesC& aPropName, TInt64 aPropValue)

   634 	{

   635 	switch(aPropType)

   636 		{

   637 		case CScrRequestImpl::EPropertyUndefined:

   638 			{// the property does NOT exist, insert a new one

   639 			_LIT(KInsertProperty, "INSERT INTO %S(Name,%S,IntValue) VALUES(?,?,?)");

   640 			TInt formattedLen = aTableName.Length() + aIdColumnName.Length();

   641 			HBufC* statementStr = FormatStatementLC(KInsertProperty(), formattedLen, &aTableName, &aIdColumnName );

   642 			TInt numberOfValues = 3;

   643 			ExecuteStatementL(*statementStr, numberOfValues,EValueString, &aPropName, EValueInteger, aIdColumnValue, EValueInteger64, aPropValue);

   644 			CleanupStack::PopAndDestroy(statementStr);

   645 			break;

   646 			}

   647 		case CScrRequestImpl::EPropertyInteger:

   648 			{// the property exists, update it

   649 			_LIT(KUpdateProperty, "UPDATE %S SET IntValue=? WHERE PropertyId=?;");

   650 			HBufC *statementStr = FormatStatementLC(KUpdateProperty(), aTableName.Length(), &aTableName);

   651 			TInt numberOfValues = 2;

   652 			ExecuteStatementL(*statementStr, numberOfValues, EValueInteger64, aPropValue, EValueInteger, aPropertyId);

   653 			CleanupStack::PopAndDestroy(statementStr);

   654 			break;

   655 			}

   656 		default:

   657 			DEBUG_PRINTF(_L8("The property type isn't integer and cannot be updated with this API."));

   658 			User::Leave(KErrAbort);

   659 		}

   660 	}

   661 

   662 template <class A> void VerifySetPropertyParamsL(HBufC* aPropName, A* aPropValue)

   663 	{

   664 	if (!aPropName || !aPropValue)

   665 		User::Leave(KErrArgument);	

   666 	}

   667 	

   668 void CScrRequestImpl::SetComponentLocalizablePropertyL(const RMessage2& aMessage)

   669 	{

   670 	DEBUG_PRINTF(_L8("Setting component string property."));

   671 	// N.B. Don't change the order of IPC parameter reading, otherwise fails in UREL mode.

   672 	HBufC *propName = ReadDescLC(aMessage, 1);

   673 	HBufC *propValue = ReadDescLC(aMessage, 2);

   674 	VerifySetPropertyParamsL(propName, propValue);

   675 

   676 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

   677 	TLanguage locale = TLanguage(aMessage.Int3());

   678 	

   679 	CScrRequestImpl::TPropertyType propType(CScrRequestImpl::EPropertyUndefined);

   680 	// The function name states that we don't want automatic locale resolving. If, e.g. we set a property for ELangAmerican, we don't want FindGeneralProperty to match existing value for ELangEnglish

   681 	TInt propertyId = FindGeneralPropertyNoLocaleDowngradeL(KComponentPropertiesTable(), KComponentIdColumnName(), componentId, *propName, locale, propType);

   682 	SetGeneralLocalizablePropertyL(propType, propertyId, KComponentIdColumnName(), componentId, *propName, locale, *propValue);

   683 	CleanupStack::PopAndDestroy(2, propName);

   684 	}

   685 

   686 void CScrRequestImpl::SetComponentBinaryPropertyL(const RMessage2& aMessage)

   687 	{

   688 	DEBUG_PRINTF(_L8("Setting component binary property."));

   689 	// N.B. Don't change the order of IPC parameter reading, otherwise fails in UREL mode.

   690 	HBufC *propName = ReadDescLC(aMessage, 1);

   691 	HBufC8 *propValue = ReadDesc8LC(aMessage, 2);

   692 	

   693 	VerifySetPropertyParamsL(propName, propValue);

   694 	

   695 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

   696 	

   697 	CScrRequestImpl::TPropertyType propType(CScrRequestImpl::EPropertyUndefined);

   698 	TInt propertyId = FindGeneralPropertyNoLocaleDowngradeL(KComponentPropertiesTable(), KComponentIdColumnName(), componentId, *propName, KLangNone, propType);

   699 	SetGeneralBinaryPropertyL(propType, propertyId, KComponentPropertiesTable(), KComponentIdColumnName(), componentId, *propName, *propValue);

   700 	CleanupStack::PopAndDestroy(2, propName);

   701 	}

   702 

   703 void CScrRequestImpl::SetComponentIntPropertyL(const RMessage2& aMessage)

   704 	{

   705 	DEBUG_PRINTF(_L8("Setting component integer property."));

   706 	// N.B. Don't change the order of IPC parameter reading, otherwise fails in UREL mode.

   707 	HBufC* propName = ReadDescLC(aMessage, 1);

   708 	

   709 	if (!propName)

   710 		User::Leave(KErrArgument);

   711 	

   712 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

   713 	TInt64 propValue = MAKE_TINT64(aMessage.Int2(), aMessage.Int3());	

   714 		

   715 	TPropertyType propType(CScrRequestImpl::EPropertyUndefined);

   716 	TInt propertyId = FindGeneralPropertyNoLocaleDowngradeL(KComponentPropertiesTable(), KComponentIdColumnName(), componentId, *propName, KLangNone, propType);

   717 	SetGeneralIntPropertyL(propType, propertyId, KComponentPropertiesTable(), KComponentIdColumnName(), componentId, *propName, propValue);

   718 	CleanupStack::PopAndDestroy(propName);

   719 	}

   720 

   721 TUint32 CScrRequestImpl::HashCaseInsensitiveL(const TDesC& aName)

   722 	{

   723 	RBuf temp;

   724 	temp.CreateMaxL(aName.Length());

   725 	temp.CleanupClosePushL();

   726 	temp.Copy(aName);

   727 	temp.LowerCase(); // The hashed column is case-insensitive. So, the hashed value must be

   728 					  // case-insensitive too. To achieve that we need to set to lower-case.	

   729 	TUint32 hashVal = HashCaseSensitiveL(temp);

   730 	CleanupStack::PopAndDestroy(&temp);

   731 	return hashVal;

   732 	}

   733 

   734 TUint32 CScrRequestImpl::HashCaseSensitiveL(const TDesC& aName)

   735 	{

   736 	TUint32 hashVal = 0;

   737 	Mem::Crc32(hashVal,aName.Ptr(),aName.Size());

   738 	return hashVal;

   739 	}

   740 

   741 TInt CScrRequestImpl::GetComponentFileIdL(const TDesC& aFileName, TComponentId aComponentId) const

   742 	{

   743 	DEBUG_PRINTF3(_L("Looking up a component(%d) file(%S)"), aComponentId, &aFileName);

   744 	

   745 	TUint32 hash = HashCaseInsensitiveL(aFileName);

   746 	_LIT(KFindComponentFile, "SELECT CmpFileId FROM ComponentsFiles WHERE ComponentId=? AND LocationHash=?;");

   747 	CStatement *stmtFind = iDbHandle->PrepareStatementLC(KFindComponentFile());

   748 	stmtFind->BindIntL(1, aComponentId);

   749 	stmtFind->BindIntL(2, hash);

   750 	

   751 	if(!stmtFind->ProcessNextRowL())

   752 		{

   753 		DEBUG_PRINTF3(_L("Component %d does not have File=%S!"), aComponentId, &aFileName);

   754 		CleanupStack::PopAndDestroy(stmtFind);

   755 		return KErrNotFound;

   756 		}

   757 	TInt componentFileId = stmtFind->IntColumnL(0);

   758 	CleanupStack::PopAndDestroy(stmtFind);

   759 	return componentFileId;

   760 	}

   761 

   762 TInt CScrRequestImpl::FindComponentFileL(const TDesC& aFileName, TComponentId aComponentId) const

   763 	{

   764 	TInt cmpFileId = GetComponentFileIdL(aFileName, aComponentId);

   765 	if(KErrNotFound == cmpFileId)

   766 		{

   767 		User::Leave(KErrNotFound);

   768 		}

   769 	return cmpFileId;

   770 	}

   771 

   772 TInt CScrRequestImpl::GetDriveFromFilePath(const TDesC& aFilePath, TDriveUnit& aDriveUnit) const

   773 	{

   774 	if(!iFs.IsValidName(aFilePath))

   775 		{// even if the file name validity is checked before registering the file, do double check

   776 		 // to be on the safe side. Because, if the file format is invalid, the rest of the code may panic.

   777 		DEBUG_PRINTF2(_L("The file (%S) doesn't have a valid name format!"), &aFilePath);

   778 		return KErrArgument;

   779 		}

   780 	

   781 	TParsePtrC fileParser(aFilePath);

   782 	TPtrC driveLetter(fileParser.Drive());

   783 	if(driveLetter == KNullDesC())

   784 		{

   785 		DEBUG_PRINTF2(_L("The file (%S) doesn't contain any drive letter!"), &aFilePath);

   786 		return KErrArgument;

   787 		}

   788 	aDriveUnit = driveLetter;

   789 	return KErrNone;

   790 	}

   791 

   792 TInt CScrRequestImpl::InstalledDrivesToBitmaskL(const TDriveList& aDriveList) const

   793 	{

   794 	TInt installedDrives(0);

   795 	for(TInt driveNum=EDriveA; driveNum<=EDriveZ; ++driveNum)

   796 		{

   797 		if(aDriveList[driveNum])

   798 			{

   799 			installedDrives |= 1<<driveNum;

   800 			}

   801 		}

   802 	return installedDrives;

   803 	}

   804 

   805 TInt CScrRequestImpl::GetInstalledDrivesBitmaskL(TComponentId aComponentId) const

   806 	{

   807 	// Get installed drives list from database

   808 	_LIT(KSelectInstalledDrivesBitmask, "SELECT InstalledDrives FROM Components WHERE ComponentId=?;");

   809 	CStatement *stmt = iDbHandle->PrepareStatementLC(KSelectInstalledDrivesBitmask);

   810 	stmt->BindIntL(1, aComponentId);

   811 	if(!stmt->ProcessNextRowL())

   812 		{

   813 		DEBUG_PRINTF2(_L8("Component (%d) couldn't be found in the SCR database."), aComponentId);

   814 		User::Leave(KErrNotFound);

   815 		}

   816 	TInt res = stmt->IntColumnL(0);

   817 	CleanupStack::PopAndDestroy(stmt);

   818 	return res;

   819 	}

   820 

   821 TBool CScrRequestImpl::HasFilesOnDriveL(TDriveUnit aDrive, TComponentId aComponentId)

   822 	{

   823 	CStatement *stmt = OpenFileListStatementL(aComponentId);

   824 	CleanupStack::PushL(stmt);

   825 	HBufC *nextFilePath(NULL);

   826 	TBool returnValue(EFalse);

   827 	

   828 	while ( returnValue == EFalse && (nextFilePath = GetNextFilePathL(*stmt)) != NULL)

   829 		{

   830 		TDriveUnit fileDrive;

   831 		TInt res = GetDriveFromFilePath(*nextFilePath, fileDrive);

   832 		// Files with invalid paths are ignored

   833 		if (res == KErrNone && fileDrive == aDrive)

   834 			{

   835 			returnValue = ETrue;

   836 			}

   837 		delete nextFilePath;			

   838 		}

   839 		

   840 	CleanupStack::PopAndDestroy(stmt);

   841 	return returnValue;

   842 	}

   843 	

   844 void CScrRequestImpl::UpdateInstalledDrivesL(TComponentId aComponentId, const TDesC& aFilePath, TFileOperationType aType)

   845 	{

   846 	TDriveUnit drive;

   847 	User::LeaveIfError(GetDriveFromFilePath(aFilePath, drive));

   848 	

   849 	TInt driveNum = static_cast<TInt>(drive);	

   850 	TInt oldDrivesBitmask = GetInstalledDrivesBitmaskL(aComponentId);

   851 

   852 	TInt newDrivesBitmask = oldDrivesBitmask;

   853 	// Update the list of installed drives

   854 	if(aType == EFileRegistered)

   855 		{

   856 		newDrivesBitmask |= 0x1 << driveNum;

   857 		}

   858 	else // aType == EFileUnregistered

   859 		{

   860 		TBool hasOtherFilesOnTheDrive = HasFilesOnDriveL(drive, aComponentId);

   861 		if (!hasOtherFilesOnTheDrive)

   862 			{

   863 			// Do a logical AND with a bitmask which looks like 111110111111

   864 			TInt andBitmask = ~(0x1 << driveNum);

   865 			newDrivesBitmask &= andBitmask;

   866 			}

   867 		}

   868 

   869 	if (newDrivesBitmask != oldDrivesBitmask)

   870 		{

   871 		// Write back the updated installed drives and list 

   872 		_LIT(KUpdateInstalledDrives, "UPDATE Components SET InstalledDrives=? WHERE ComponentId=?;");

   873 		TInt numberOfValues = 2;

   874 		ExecuteStatementL(KUpdateInstalledDrives, numberOfValues, EValueInteger, newDrivesBitmask, EValueInteger, aComponentId);

   875 		}

   876 	}

   877 

   878 void CScrRequestImpl::RegisterComponentFileL(const RMessage2& aMessage)

   879    	{

   880 	DEBUG_PRINTF(_L8("Registering component file."));

   881    	

   882    	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

   883    	HBufC* fileName = ReadFileNameFromMsgLC(aMessage);

   884  	TBool considerFileInDrivesList = aMessage.Int2();	

   885    	TUint32 hash = HashCaseInsensitiveL(*fileName);

   886 	TDriveUnit drive(*fileName);

   887    	TVolumeInfo volInfo;

   888    	

   889    	_LIT(KInsertFile, "INSERT INTO ComponentsFiles(ComponentId,LocationHash,Location) VALUES(?,?,?);");

   890    	TInt numberOfValues = 3;

   891    	ExecuteStatementL(KInsertFile(), numberOfValues, EValueInteger, componentId, EValueInteger, hash, EValueString, fileName);

   892    	// Reflect this file addition in the installed drives field of the components table

   893 	// Or the drive list is updated in case of a FILENULL operation on a removable drive

   894    	// If this step fails (for example, this file name is incorrect) then we cannot register the file

   895  	if (KErrNone == iFs.Volume(volInfo, drive) || considerFileInDrivesList)

   896  		UpdateInstalledDrivesL(componentId, *fileName, EFileRegistered);

   897  	

   898    	CleanupStack::PopAndDestroy(fileName);

   899    	}

   900 

   901 void CScrRequestImpl::SetFileStrPropertyL(const RMessage2& aMessage)

   902 	{

   903 	DEBUG_PRINTF(_L8("Setting file string property."));

   904 	

   905 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);	

   906 	HBufC* fileName  = ReadFileNameFromMsgLC(aMessage);

   907 	

   908 	TInt compFileId = FindComponentFileL(*fileName, componentId);

   909 		

   910 	HBufC* propName  = ReadDescLC(aMessage, 2);

   911 	TPropertyType propType(CScrRequestImpl::EPropertyUndefined);

   912 	TInt propertyId = FindGeneralPropertyNoLocaleDowngradeL(KFilePropertiesTable(), KCompFileIdColumnName(), compFileId, *propName, KLangNone, propType);

   913 	

   914 	HBufC8* propValue = ReadDesc8LC(aMessage, 3);

   915 	SetGeneralBinaryPropertyL(propType, propertyId, KFilePropertiesTable(), KCompFileIdColumnName(), compFileId, *propName, *propValue);

   916 	CleanupStack::PopAndDestroy(3, fileName);

   917 	}

   918 

   919 void CScrRequestImpl::SetFileIntPropertyL(const RMessage2& aMessage)

   920 	{

   921 	DEBUG_PRINTF(_L8("Setting integer file property."));

   922 		

   923 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

   924 	HBufC* fileName  = ReadFileNameFromMsgLC(aMessage);

   925 	TInt compFileId = FindComponentFileL(*fileName, componentId);

   926 	

   927 	HBufC* propName  = ReadDescLC(aMessage, 2);

   928 	TPropertyType propType(CScrRequestImpl::EPropertyUndefined);

   929 	TInt propertyId = FindGeneralPropertyNoLocaleDowngradeL(KFilePropertiesTable(), KCompFileIdColumnName(), compFileId, *propName, KLangNone, propType);

   930 	

   931 	TInt propValue   = aMessage.Int3();

   932 	SetGeneralIntPropertyL(propType, propertyId, KFilePropertiesTable(), KCompFileIdColumnName(), compFileId, *propName, propValue);

   933 	CleanupStack::PopAndDestroy(2, fileName);

   934 	}

   935 

   936 void CScrRequestImpl::SetComponentLocalizableL(TComponentId aComponentId, TLanguage aLocale, const TDesC& aColumnName, const TDesC& aName, const TDesC& aVendor)

   937 	{

   938 	_LIT(KFindComponentLocalizable, "SELECT CompLocalId FROM ComponentLocalizables WHERE ComponentId=? AND Locale=?;");

   939 	TInt numberOfValues = 2;

   940 	CStatement *stmt = CreateStatementObjectWithLocaleL(KFindComponentLocalizable, aLocale, numberOfValues, EValueInteger, aComponentId, EValueLanguage);	

   941 	

   942 	if(!stmt)

   943 		{// Add a new name for this component

   944 		AddComponentLocalizablesL(aComponentId, aLocale, aName, aVendor);

   945 		}

   946 	else

   947 		{// Exists, update the localizable field of the component

   948 		CleanupStack::PushL(stmt);

   949 		TInt compLocId = stmt->IntColumnL(0);

   950 		_LIT(KUpdateComponentName, "UPDATE ComponentLocalizables SET %S=? WHERE CompLocalId=?;");

   951 		HBufC *statementStr = FormatStatementLC(KUpdateComponentName, aColumnName.Length(), &aColumnName);

   952 		const TDesC *value = aName.Length() ? &aName : &aVendor;

   953 		TInt numberOfValues = 2;

   954 		ExecuteStatementL(*statementStr, numberOfValues, EValueString, value, EValueInteger, compLocId);

   955 		CleanupStack::PopAndDestroy(2, stmt); // stmt, statementStr

   956 		}

   957 	}

   958 

   959 void CScrRequestImpl::SetComponentNameL(const RMessage2& aMessage)

   960 	{

   961 	DEBUG_PRINTF(_L8("Setting component name."));

   962 	

   963 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

   964 	HBufC *componentName = ReadDescLC(aMessage, 1);

   965 	if (!componentName->CompareF(KNullDesC()))

   966 		{// Component name cannot be empty

   967 		DEBUG_PRINTF(_L8("Component name cannot be set or modified to a NULL string."));

   968 		User::Leave(KErrArgument);

   969 		}	

   970 		

   971 	TLanguage locale = TLanguage(aMessage.Int2());

   972 	_LIT(KComponentNameField,"Name");

   973 	SetComponentLocalizableL(componentId, locale, KComponentNameField, *componentName, KNullDesC());

   974 	CleanupStack::PopAndDestroy(componentName);

   975 	}

   976 

   977 void CScrRequestImpl::SetVendorNameL(const RMessage2& aMessage)

   978 	{

   979 	DEBUG_PRINTF(_L8("Setting vendor name."));

   980 	

   981 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

   982 	HBufC *vendorName = ReadDescLC(aMessage, 1);

   983 	TLanguage locale = TLanguage(aMessage.Int2());

   984 	_LIT(KComponentVendorField,"Vendor");

   985 	SetComponentLocalizableL(componentId, locale, KComponentVendorField, KNullDesC(), *vendorName);

   986 	CleanupStack::PopAndDestroy(vendorName);

   987 	}

   988 

   989 void CScrRequestImpl::ReadAndSetCommonComponentPropertyL(const RMessage2& aMessage, const TDesC& aPropertyColumn)

   990 	{

   991 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

   992 	TInt propertyValue = aMessage.Int1();

   993 	

   994 	_LIT(KUpdateCommonProperty, "UPDATE Components SET %S=? WHERE ComponentId=?;");

   995 	TInt formattedLen = aPropertyColumn.Length();

   996 	HBufC *statementStr = FormatStatementLC(KUpdateCommonProperty(), formattedLen, &aPropertyColumn );

   997 	TInt numberOfValues = 2;

   998 	ExecuteStatementL(*statementStr, numberOfValues, EValueInteger, propertyValue, EValueInteger, componentId);

   999 	CleanupStack::PopAndDestroy(statementStr);

  1000 	}

  1001 

  1002 void CScrRequestImpl::SetIsComponentRemovableL(const RMessage2& aMessage)

  1003 	{

  1004 	DEBUG_PRINTF(_L8("Setting the component's removable attribute."));

  1005 	_LIT(KColumnNameRemovable, "Removable");

  1006 	ReadAndSetCommonComponentPropertyL(aMessage, KColumnNameRemovable);

  1007 	}

  1008 

  1009 void CScrRequestImpl::SetIsComponentDrmProtectedL(const RMessage2& aMessage)

  1010 	{

  1011 	DEBUG_PRINTF(_L8("Setting the component's DRM protected attribute."));

  1012 	_LIT(KColumnNameDrmProtected, "DRMProtected");

  1013 	ReadAndSetCommonComponentPropertyL(aMessage, KColumnNameDrmProtected);	

  1014 	}

  1015 

  1016 void CScrRequestImpl::SetIsComponentHiddenL(const RMessage2& aMessage)

  1017 	{

  1018 	DEBUG_PRINTF(_L8("Setting the component's hidden attribute."));

  1019 	_LIT(KColumnNameHidden, "Hidden");

  1020 	ReadAndSetCommonComponentPropertyL(aMessage, KColumnNameHidden);		

  1021 	}

  1022 

  1023 void CScrRequestImpl::SetIsComponentKnownRevokedL(const RMessage2& aMessage)

  1024 	{

  1025 	DEBUG_PRINTF(_L8("Setting the component's known-revoked attribute."));

  1026 	_LIT(KColumnNameKnownRevoked, "KnownRevoked");

  1027 	ReadAndSetCommonComponentPropertyL(aMessage, KColumnNameKnownRevoked);	

  1028 	}

  1029 

  1030 void CScrRequestImpl::SetIsComponentOriginVerifiedL(const RMessage2& aMessage)

  1031 	{

  1032 	DEBUG_PRINTF(_L8("Setting the component's removable attribute."));

  1033 	_LIT(KColumnNameOriginVerified, "OriginVerified");

  1034 	ReadAndSetCommonComponentPropertyL(aMessage, KColumnNameOriginVerified);	

  1035 	}

  1036 		

  1037 void CScrRequestImpl::SetComponentSizeL(const RMessage2& aMessage)

  1038 	{

  1039 	DEBUG_PRINTF(_L8("Setting the component's install-time size."));

  1040 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

  1041 	TInt64 componentSize = MAKE_TINT64(aMessage.Int1(), aMessage.Int2());

  1042 	if (componentSize < 0)

  1043 		{

  1044 		DEBUG_PRINTF2(_L8("Received incorrect component size: %d."), componentSize);

  1045 		User::Leave(KErrArgument);

  1046 		}

  1047 	_LIT(KUpdateComponentSize, "UPDATE Components SET Size=? WHERE ComponentId=?;");

  1048 	TInt numberOfValues = 2;

  1049 	ExecuteStatementL(KUpdateComponentSize, numberOfValues, EValueInteger64, componentSize, EValueInteger, componentId);

  1050 	}

  1051 

  1052 TBool FindLogEntryWithComponentId(const TComponentId *aKey, const CScrLogEntry& aEntry)

  1053 	{

  1054 	return (*aKey == aEntry.ComponentId()); 

  1055 	}

  1056 

  1057 void CScrRequestImpl::SetComponentVersionL(const RMessage2& aMessage)

  1058 	{

  1059 	DEBUG_PRINTF(_L8("Setting component version."));

  1060 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

  1061 	HBufC *version = ReadDescLC(aMessage, 1);

  1062 	

  1063 	_LIT(KUpdateVersion, "UPDATE Components SET Version=? WHERE ComponentId=?;");

  1064 	TInt numberOfValues = 2;

  1065 	ExecuteStatementL(KUpdateVersion, numberOfValues, EValueString, version, EValueInteger, componentId);

  1066 	

  1067 	TInt logIdx = iLogEntries.Find(componentId, FindLogEntryWithComponentId);

  1068 	if(KErrNotFound == logIdx)

  1069 		{

  1070 		CleanupStack::PopAndDestroy(version);

  1071 		return;

  1072 		}

  1073 	DeleteObjectZ(iLogEntries[logIdx]->iVersion);

  1074 	iLogEntries[logIdx]->iVersion = version; // Ownership is transferred

  1075 	CleanupStack::Pop(version);

  1076 	}

  1077 

  1078 void CScrRequestImpl::DeleteComponentPropertyL(const RMessage2& aMessage)

  1079 	{

  1080 	DEBUG_PRINTF(_L8("Deleting component property."));

  1081 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

  1082 	HBufC *name = ReadDescLC(aMessage, 1);

  1083 	

  1084 	_LIT(KDeleteComponentProperty, "DELETE FROM ComponentProperties WHERE Name=? AND ComponentId=?;");

  1085 	TInt numberOfValues = 2;

  1086 	ExecuteStatementL(KDeleteComponentProperty, numberOfValues, EValueString, name, EValueInteger, componentId);

  1087 	CleanupStack::PopAndDestroy(name);

  1088 	}

  1089 

  1090 void CScrRequestImpl::DeleteFilePropertyL(const RMessage2& aMessage)

  1091 	{

  1092 	DEBUG_PRINTF(_L8("Deleting file property."));

  1093 	

  1094 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

  1095 	HBufC* fileName  = ReadFileNameFromMsgLC(aMessage);

  1096 	

  1097 	TInt compFileId = FindComponentFileL(*fileName, componentId);

  1098 	HBufC *propName = ReadDescLC(aMessage, 2);

  1099 	

  1100 	_LIT(KDeleteFileProperty, "DELETE FROM FileProperties WHERE CmpFileId=? AND Name=?;");

  1101 	TInt numberOfValues = 2;

  1102 	ExecuteStatementL(KDeleteFileProperty, numberOfValues, EValueInteger, compFileId, EValueString, propName);

  1103 	CleanupStack::PopAndDestroy(2, fileName);

  1104 	}

  1105 

  1106 void CScrRequestImpl::UnregisterComponentFileL(const RMessage2& aMessage)

  1107 	{

  1108 	DEBUG_PRINTF(_L8("Unregistering a component file."));

  1109 	

  1110 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

  1111 	HBufC* fileName  = ReadFileNameFromMsgLC(aMessage);

  1112 	

  1113 	TInt compFileId = GetComponentFileIdL(*fileName, componentId);

  1114 	if (compFileId == KErrNotFound)

  1115 		{

  1116 		CleanupStack::PopAndDestroy(fileName);

  1117 		return; // If the file is not registered, we do not return an error - this sort of condition is better enforced at upper layers 

  1118 		}

  1119 		

  1120 	_LIT(KDeleteComponentFileProperties, "DELETE from FileProperties WHERE CmpFileId=?;");

  1121 	TInt numberOfValues = 1;

  1122 	ExecuteStatementL(KDeleteComponentFileProperties, numberOfValues, EValueInteger, compFileId);

  1123 	DEBUG_PRINTF3(_L("Properties of the file(%S) of the component(%d) have been deleted."), fileName, componentId);

  1124 

  1125 	_LIT(KUnregisterComponentFile, "DELETE FROM ComponentsFiles WHERE CmpFileId=?;");

  1126 	ExecuteStatementL(KUnregisterComponentFile, numberOfValues, EValueInteger, compFileId);

  1127 

  1128 	// Reflect this file deletion in the installed drives field of the components table

  1129 	UpdateInstalledDrivesL(componentId, *fileName, EFileUnregistered);

  1130 	CleanupStack::PopAndDestroy(fileName);

  1131 	}

  1132 

  1133 void ReadNullableStringFromStatementL(CStatement& aStmt, TPtrC& aValue, TInt aFieldNum)

  1134 	{