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 * 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 "scrrepository.h"

    35 #include <s32mem.h>

    36 #include <bautils.h>

    37 #include <scs/streamingarray.h>

    38 #include <scs/ipcstream.h>

    39 #include <scs/ipcstream.inl>

    40 #include <scs/cleanuputils.h>

    41 #include <e32hashtab.h>

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

    43 

    44 using namespace Usif;

    45 

    46 _LIT(KComponentIdColumnName, "ComponentId"); 

    47 _LIT(KCompFileIdColumnName, "CmpFileId"); 

    48 _LIT(KAppIdColumnName, "AppUid");

    49 _LIT(KComponentPropertiesTable, "ComponentProperties");

    50 _LIT(KFilePropertiesTable, "FileProperties");

    51 _LIT(KFileOwnershipInfoTable, "FileOwnershipInfo");

    52 _LIT(KServiceInfoTable, "ServiceInfo");

    53 _LIT(KLocalizableAppInfoTable, "LocalizableAppInfo");

    54 _LIT(KViewDataTable, "ViewData");

    55 _LIT(KAppRegistrationInfoTable, "AppRegistrationInfo");

    56 _LIT(KAppPropertiesTable, "AppProperties");

    57 

    58 

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

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

    61 const TInt KMaxScrLogEntries = 1000;

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

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

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

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

    66 	

    67 const TUint KDbInterfaceMajorVersion = 1;

    68 const TUint KDbInterfaceMinorVersion = 1;

    69 #ifdef _DEBUG

    70 const TUint KDbInterfaceBuildNumber = 1;

    71 #endif

    72 

    73 enum TScrPanicId

    74 	{

    75 	KScrIllegalCallSequence = 1,

    76 	KScrIllegalParameter = 2

    77 	};

    78 

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

    80 	{

    81 	_LIT(KPanicMessage, "ScrServer");

    82     aMessage.Panic(KPanicMessage, aPanic);

    83     }

    84 

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

    86 	{

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

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

    89 	ptrFileName.Copy(aFilePath);

    90 	ptrFileName[0] = aDrive;

    91 	return fileName; 

    92 	}	

    93 	

    94 ////////////////////////

    95 // CScrRequestImpl

    96 ////////////////////////

    97 

    98 CScrRequestImpl::CScrRequestImpl(RFs& aFs)

    99 	: iFs(aFs)

   100 	{

   101 	}

   102 

   103 CScrRequestImpl::~CScrRequestImpl()

   104 	{

   105 	delete iDbHandle;

   106 	delete iComponentEntry;

   107 	iProperties.ResetAndDestroy();

   108 	delete iSingleProperty;

   109 	iFileComponents.Close();

   110 	iVerCompIdList.ResetAndDestroy();

   111 	iDeletedMimeTypes.ResetAndDestroy();

   112 	iLogEntries.ResetAndDestroy();

   113 	iMatchingSupportedLanguageList.Close();

   114 	

   115     //Delete the instance of CScrRepository, if present.

   116     CScrRepository::DeleteRepositoryInstance();

   117 	}

   118 

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

   120 	{

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

   122 	CleanupStack::PushL(self);

   123 	self->ConstructL(aDatabaseFile, aJournalFile);

   124 	CleanupStack::Pop(self);

   125 	return self;

   126 	}

   127 

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

   129 	{

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

   131 	InitializeDbVersionL();

   132 	VerifyDbVersionCompatibilityL();

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

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

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

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

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

   138 	CleanupStack::PopAndDestroy(privateDirPath);

   139 	}

   140 

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

   142 	{

   143 	TInt len = aMessage.GetDesLengthL(aSlot);

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

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

   146 	aMessage.ReadL(aSlot, ptrDesc);

   147 	return desc;

   148 	}

   149 

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

   151 	{

   152 	TInt len = aMessage.GetDesLengthL(aSlot);

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

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

   155 	aMessage.ReadL(aSlot, ptrDesc);

   156 	return desc;

   157 	}

   158 

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

   160 	{

   161 	VA_LIST list;

   162 	VA_START(list, aFormattedLength);

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

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

   165 	statementStrPtr.FormatList(aStatement, list);

   166 	VA_END(list);

   167 	

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

   169 	statementStrPtr.Append('\0');

   170 	return statementStr;

   171 	}

   172 

   173 void CScrRequestImpl::CreateTransactionL()

   174 	{

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

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

   177 	ExecuteStatementL(KBeginTransaction());	

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

   179 	}

   180 

   181 void CScrRequestImpl::RollbackTransactionL()

   182 	{

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

   184 	_LIT(KRollbackTransaction, "ROLLBACK;");

   185 	ExecuteStatementL(KRollbackTransaction());

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

   187 	}

   188 

   189 void CScrRequestImpl::CommitTransactionL()

   190 	{

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

   192 	_LIT(KCommitTransaction, "COMMIT;");

   193 	ExecuteStatementL(KCommitTransaction());

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

   195 	}

   196 

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

   198 	{ 

   199 	DEBUG_PRINTF(_L8("Generating Global ID."));

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

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

   202 	

   203 	globalIdDes.Copy(aUniqueSwTypeName);

   204 	globalIdDes.Append('\0');

   205 	globalIdDes.Append(aGlobalId);

   206 	

   207 	return globalIdBuf;

   208 	}

   209 

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

   211 	{

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

   213 	// Get the current time

   214 	TTime time;

   215 	time.HomeTime();

   216 	TDateTime datetime = time.DateTime();

   217 	TBuf<16> installTime;

   218 	// 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

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

   220 	

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

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

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

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

   225 	TUint32 swTypeId = HashCaseSensitiveL(aUniqueSwTypeName);

   226 	

   227 	if(aGlobalId.CompareF(KNullDesC()))

   228 		{ // Global Id is supplied by client

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

   230 		CleanupStack::PushL(globalId);

   231 		TUint32 globalIdHash = HashCaseSensitiveL(*globalId);

   232 		

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

   234 		TInt numberOfValues = 5;

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

   236 		CleanupStack::PopAndDestroy(globalId);

   237 		}

   238 	else

   239 		{// Global Id is NOT supplied by client

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

   241 		TInt numberOfValues = 3;

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

   243 		}

   244 	

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

   246 	return iDbHandle->LastInsertedIdL();

   247 	}

   248 

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

   250 	{

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

   252 	

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

   254 		{// Component name cannot be empty

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

   256 		User::Leave(KErrArgument);

   257 		}

   258 	

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

   260 	TInt numberOfValues = 4;

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

   262 	

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

   264 	}

   265 

   266 void CScrRequestImpl::ComponentRollback(TAny* aParam)

   267 	{

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

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

   270 	TInt numberOfValues = 1;

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

   272 	}

   273 	

   274 void CScrRequestImpl::ComponentLocalizablesRollback(TAny* aParam)

   275 	{

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

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

   278 	TInt numberOfValues = 1;

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

   280 	}

   281 

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

   283 	{

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

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

   286 	TScrComponentOperationType compOpType;

   287 	TPckg<TScrComponentOperationType> opTypePckg(compOpType);

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

   289 		

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

   291 		{

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

   293 		User::Leave(KErrArgument);

   294 		}

   295 	

   296 	RIpcReadStream componentInfoReader;

   297 	CleanupClosePushL(componentInfoReader);

   298 	componentInfoReader.Open(aMessage, 1);

   299 	

   300 	RPointerArray<CLocalizableComponentInfo> componentInfoArray;

   301 	CleanupResetAndDestroyPushL(componentInfoArray);

   302 	InternalizePointersArrayL(componentInfoArray, componentInfoReader);

   303 	TInt arrayCount = componentInfoArray.Count();

   304 	// 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

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

   306 

   307 	HBufC *uniqueSwTypeName = GetSoftwareTypeNameFromMsgLC(aMessage);

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

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

   310 	

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

   312 	TRollbackParams cleanupParam(newComponentId, *this);

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

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

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

   316 	

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

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

   319 	// array is used as default.

   320 	TInt componentNameIndexForLog (0);

   321 	TInt indexForCurrentLocale = KErrNotFound;

   322 	TInt indexForNonLocalized = KErrNotFound;

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

   324 		{

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

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

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

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

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

   330 			indexForCurrentLocale = i;

   331 		else if(locale == KNonLocalized)

   332 			indexForNonLocalized = i;

   333 		}

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

   335 	

   336 	if(indexForCurrentLocale != KErrNotFound)

   337 		componentNameIndexForLog = indexForCurrentLocale;

   338 	else if(indexForNonLocalized != KErrNotFound)

   339 		componentNameIndexForLog = indexForNonLocalized;

   340 	

   341 	if(EScrCompHidden != compOpType)

   342 		{

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

   344 		logRecord->iComponentId = newComponentId;

   345 		iLogEntries.AppendL(logRecord);

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

   347 		}

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

   349 	

   350 	TPckg<TComponentId> componentIdDes(newComponentId);

   351 	aMessage.WriteL(3, componentIdDes);

   352 	

   353 	DEBUG_PRINTF(_L8("New component added successfully."));

   354 	}

   355 

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

   357 	{

   358 	// Read global id object from the message

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

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

   361 	CleanupStack::PopAndDestroy(globalId);

   362 	CleanupStack::PushL(globalIdBuf);

   363 	return globalIdBuf;

   364 	}

   365 

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

   367 	{

   368 	RBuf concatGlobalIds;

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

   370 	concatGlobalIds.CleanupClosePushL();

   371 	concatGlobalIds.Copy(aDependantId);

   372 	concatGlobalIds.Append(aSupplierId);

   373 	TUint32 globalIdsHash = HashCaseSensitiveL(concatGlobalIds);

   374 	CleanupStack::PopAndDestroy(&concatGlobalIds);

   375 	return globalIdsHash;

   376 	}

   377 

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

   379 	{

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

   381 	

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

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

   384 	CleanupStack::PushL(suppGlobalId);

   385 	TUint32 suppGlobalIdHash = HashCaseSensitiveL(*suppGlobalId);

   386 	

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

   388 	TUint32 depGlobalIdHash = HashCaseSensitiveL(*depGlobalId);

   389 	

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

   391 	

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

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

   394 	

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

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

   397 

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

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

   400 

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

   402 	RBuf insertStmtStr;

   403 	insertStmtStr.CreateL(KMaxInsertDependencyLength);

   404 	insertStmtStr.CleanupClosePushL();

   405 	insertStmtStr.Copy(KInsertDependencyFront());

   406 	

   407 	RBuf insertStmtEndStr;

   408 	insertStmtEndStr.CreateL(KMaxInsertDependencyValueLength);

   409 	insertStmtEndStr.CleanupClosePushL();

   410 	insertStmtEndStr.Copy(KInsertDependencyEnd());

   411 	

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

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

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

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

   416 	// if new columns are added to the statement

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

   418 	

   419 	const TDesC* firstVersionParam(0);

   420 	const TDesC* secondVersionParam(0);

   421 	

   422 	_LIT(KInsertValue, ",?");

   423 	if(versionFrom)

   424 		{

   425 		_LIT(KVersionFrom, ",VersionFrom");

   426 		insertStmtStr.Append(KVersionFrom());

   427 		insertStmtEndStr.Append(KInsertValue());

   428 		firstVersionParam = versionFrom;

   429 		++numberOfValues;

   430 		}

   431 	

   432 	if(versionTo)

   433 		{

   434 		_LIT(KVersionTo, ",VersionTo");

   435 		insertStmtStr.Append(KVersionTo());

   436 		insertStmtEndStr.Append(KInsertValue());

   437 		if(firstVersionParam)

   438 			{

   439 			secondVersionParam = versionTo;

   440 			}

   441 		else

   442 			{

   443 			firstVersionParam = versionTo;

   444 			}

   445 		++numberOfValues;

   446 		}

   447 	

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

   449 	insertStmtStr.Append(insertStmtEndStr);

   450 	// Close the statement

   451 	_LIT(KInsertClose,");");

   452 	insertStmtStr.Append(KInsertClose());

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

   454 	insertStmtStr.Append('\0');

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

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

   457 	

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

   459 	

   460 	DEBUG_PRINTF(_L8("New component dependency added successfully."));

   461 	}

   462 

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

   464 	{

   465 	CStatement *stmt(0);

   466 	TInt numberOfValues = 3;

   467 	

   468 	if(KUnspecifiedLocale == aLocale)

   469 		{

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

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

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

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

   474 		

   475 		if(!stmt)

   476 			{

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

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

   479 			}

   480 		}

   481 	else if(KNonLocalized == aLocale)

   482 		{

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

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

   485 		}

   486 	else

   487 		{

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

   489 		// and its downgraded languages.

   490 		stmt = aDoLocaleResolving ? 

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

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

   493 		}

   494 	return stmt;

   495 	}

   496 

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

   498 	{

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

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

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

   502 

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

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

   505 	if(!stmtFind)

   506 		{ // the property does not exist, return

   507 		CleanupStack::PopAndDestroy(statementStr);

   508 		return KErrNotFound;

   509 		}

   510 	CleanupStack::PushL(stmtFind);

   511 	

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

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

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

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

   516 			

   517 	if(!isIntPropertyNull)

   518 		{

   519 		aPropertyType = CScrRequestImpl::EPropertyInteger;

   520 		}

   521 	else if(!isStrPropertyNull)

   522 		{

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

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

   525 		}

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

   527 		{

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

   529 		User::Leave(KErrCorrupt);

   530 		}

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

   532 	return propertyId;

   533 	}

   534 

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

   536 	{

   537 	TInt bindIdx(0);

   538 	while(aValuesNum--)

   539 		{

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

   541 		switch(t)

   542 			{

   543 			case EValueString:

   544 				{

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

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

   547 				break;

   548 				}

   549 			case EValueInteger:

   550 				{

   551 				TInt intVal = VA_ARG(aList, TInt);

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

   553 				break;

   554 				}

   555 			case EValueInteger64:

   556 				{

   557 				TInt64 intVal64 = VA_ARG(aList, TInt64);

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

   559 				break;

   560 				}

   561 			case EValueLanguage:

   562 				{

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

   564 				break;

   565 				}

   566 			case EValueBinary:

   567 				{

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

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

   570 				break;

   571 				}				

   572 			default:

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

   574 				ASSERT(0);

   575 			} // switch

   576 		} // while

   577 	} // End of the function

   578 

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

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

   581 	VA_LIST argList;

   582 	VA_START(argList, aValuesNum);

   583 	

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

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

   586 	stmt->ExecuteStatementL();

   587 	CleanupStack::PopAndDestroy(stmt);

   588 	

   589 	VA_END(argList);

   590 	}

   591 

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

   593 	{

   594 	switch(aPropType)

   595 		{

   596 		case CScrRequestImpl::EPropertyUndefined:

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

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

   599 			TInt formattedLen = aIdColumnName.Length();

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

   601 			TInt numberOfValues = 4;

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

   603 			CleanupStack::PopAndDestroy(statementStr);

   604 			break;

   605 			}

   606 		case CScrRequestImpl::EPropertyLocalizable: 

   607 			{

   608 			// the property exists, update it

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

   610 			TInt numberOfValues = 2;

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

   612 			break;

   613 			}

   614 		default:

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

   616 			User::Leave(KErrAbort);

   617 		}

   618 	}

   619 

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

   621 	{

   622 	switch(aPropType)

   623 		{

   624 		case CScrRequestImpl::EPropertyUndefined:

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

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

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

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

   629 			TInt numberOfValues = 3;

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

   631 			CleanupStack::PopAndDestroy(statementStr);

   632 			break;

   633 			}

   634 		case CScrRequestImpl::EPropertyBinary: 

   635 			{

   636 			// the property exists, update it

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

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

   639 			TInt numberOfValues = 2;

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

   641 			CleanupStack::PopAndDestroy(statementStr);

   642 			break;

   643 			}

   644 		default:

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

   646 			User::Leave(KErrAbort);

   647 		}

   648 	}

   649 

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

   651 	{

   652 	switch(aPropType)

   653 		{

   654 		case CScrRequestImpl::EPropertyUndefined:

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

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

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

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

   659 			TInt numberOfValues = 3;

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

   661 			CleanupStack::PopAndDestroy(statementStr);

   662 			break;

   663 			}

   664 		case CScrRequestImpl::EPropertyInteger:

   665 			{// the property exists, update it

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

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

   668 			TInt numberOfValues = 2;

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

   670 			CleanupStack::PopAndDestroy(statementStr);

   671 			break;

   672 			}

   673 		default:

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

   675 			User::Leave(KErrAbort);

   676 		}

   677 	}

   678 

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

   680 	{

   681 	if (!aPropName || !aPropValue)

   682 		User::Leave(KErrArgument);	

   683 	}

   684 	

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

   686 	{

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

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

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

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

   691 	VerifySetPropertyParamsL(propName, propValue);

   692 

   693 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

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

   695 	

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

   697 	// 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

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

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

   700 	CleanupStack::PopAndDestroy(2, propName);

   701 	}

   702 

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

   704 	{

   705 	DEBUG_PRINTF(_L8("Setting component binary 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 	HBufC8 *propValue = ReadDesc8LC(aMessage, 2);

   709 	

   710 	VerifySetPropertyParamsL(propName, propValue);

   711 	

   712 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

   713 	

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

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

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

   717 	CleanupStack::PopAndDestroy(2, propName);

   718 	}

   719 

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

   721 	{

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

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

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

   725 	

   726 	if (!propName)

   727 		User::Leave(KErrArgument);

   728 	

   729 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

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

   731 		

   732 	TPropertyType propType(CScrRequestImpl::EPropertyUndefined);

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

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

   735 	CleanupStack::PopAndDestroy(propName);

   736 	}

   737 

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

   739 	{

   740 	RBuf temp;

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

   742 	temp.CleanupClosePushL();

   743 	temp.Copy(aName);

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

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

   746 	TUint32 hashVal = HashCaseSensitiveL(temp);

   747 	CleanupStack::PopAndDestroy(&temp);

   748 	return hashVal;

   749 	}

   750 

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

   752 	{

   753 	TUint32 hashVal = 0;

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

   755 	return hashVal;

   756 	}

   757 

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

   759 	{

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

   761 	

   762 	TUint32 hash = HashCaseInsensitiveL(aFileName);

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

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

   765 	stmtFind->BindIntL(1, aComponentId);

   766 	stmtFind->BindIntL(2, hash);

   767 	

   768 	if(!stmtFind->ProcessNextRowL())

   769 		{

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

   771 		CleanupStack::PopAndDestroy(stmtFind);

   772 		return KErrNotFound;

   773 		}

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

   775 	CleanupStack::PopAndDestroy(stmtFind);

   776 	return componentFileId;

   777 	}

   778 

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

   780 	{

   781 	TInt cmpFileId = GetComponentFileIdL(aFileName, aComponentId);

   782 	if(KErrNotFound == cmpFileId)

   783 		{

   784 		User::Leave(KErrNotFound);

   785 		}

   786 	return cmpFileId;

   787 	}

   788 

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

   790 	{

   791 	if(!iFs.IsValidName(aFilePath))

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

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

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

   795 		return KErrArgument;

   796 		}

   797 	

   798 	TParsePtrC fileParser(aFilePath);

   799 	TPtrC driveLetter(fileParser.Drive());

   800 	if(driveLetter == KNullDesC())

   801 		{

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

   803 		return KErrArgument;

   804 		}

   805 	aDriveUnit = driveLetter;

   806 	return KErrNone;

   807 	}

   808 

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

   810 	{

   811 	TInt installedDrives(0);

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

   813 		{

   814 		if(aDriveList[driveNum])

   815 			{

   816 			installedDrives |= 1<<driveNum;

   817 			}

   818 		}

   819 	return installedDrives;

   820 	}

   821 

   822 TInt CScrRequestImpl::GetInstalledDrivesBitmaskL(TComponentId aComponentId) const

   823 	{

   824 	// Get installed drives list from database

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

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

   827 	stmt->BindIntL(1, aComponentId);

   828 	if(!stmt->ProcessNextRowL())

   829 		{

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

   831 		User::Leave(KErrNotFound);

   832 		}

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

   834 	CleanupStack::PopAndDestroy(stmt);

   835 	return res;

   836 	}

   837 

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

   839 	{

   840 	CStatement *stmt = OpenFileListStatementL(aComponentId);

   841 	CleanupStack::PushL(stmt);

   842 	HBufC *nextFilePath(NULL);

   843 	TBool returnValue(EFalse);

   844 	

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

   846 		{

   847 		TDriveUnit fileDrive;

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

   849 		// Files with invalid paths are ignored

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

   851 			{

   852 			returnValue = ETrue;

   853 			}

   854 		delete nextFilePath;			

   855 		}

   856 		

   857 	CleanupStack::PopAndDestroy(stmt);

   858 	return returnValue;

   859 	}

   860 	

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

   862 	{

   863 	TDriveUnit drive;

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

   865 	

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

   867 	TInt oldDrivesBitmask = GetInstalledDrivesBitmaskL(aComponentId);

   868 

   869 	TInt newDrivesBitmask = oldDrivesBitmask;

   870 	// Update the list of installed drives

   871 	if(aType == EFileRegistered)

   872 		{

   873 		newDrivesBitmask |= 0x1 << driveNum;

   874 		}

   875 	else // aType == EFileUnregistered

   876 		{

   877 		TBool hasOtherFilesOnTheDrive = HasFilesOnDriveL(drive, aComponentId);

   878 		if (!hasOtherFilesOnTheDrive)

   879 			{

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

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

   882 			newDrivesBitmask &= andBitmask;

   883 			}

   884 		}

   885 

   886 	if (newDrivesBitmask != oldDrivesBitmask)

   887 		{

   888 		// Write back the updated installed drives and list 

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

   890 		TInt numberOfValues = 2;

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

   892 		}

   893 	}

   894 

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

   896    	{

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

   898    	

   899    	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

   900    	HBufC* fileName = ReadFileNameFromMsgLC(aMessage);

   901  	TBool considerFileInDrivesList = aMessage.Int2();	

   902    	TUint32 hash = HashCaseInsensitiveL(*fileName);

   903 	TDriveUnit drive(*fileName);

   904    	TVolumeInfo volInfo;

   905    	

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

   907    	TInt numberOfValues = 3;

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

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

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

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

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

   913  		UpdateInstalledDrivesL(componentId, *fileName, EFileRegistered);

   914  	

   915    	CleanupStack::PopAndDestroy(fileName);

   916    	}

   917 

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

   919 	{

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

   921 	

   922 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);	

   923 	HBufC* fileName  = ReadFileNameFromMsgLC(aMessage);

   924 	

   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 	HBufC8* propValue = ReadDesc8LC(aMessage, 3);

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

   933 	CleanupStack::PopAndDestroy(3, fileName);

   934 	}

   935 

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

   937 	{

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

   939 		

   940 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

   941 	HBufC* fileName  = ReadFileNameFromMsgLC(aMessage);

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

   943 	

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

   945 	TPropertyType propType(CScrRequestImpl::EPropertyUndefined);

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

   947 	

   948 	TInt propValue   = aMessage.Int3();

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

   950 	CleanupStack::PopAndDestroy(2, fileName);

   951 	}

   952 

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

   954 	{

   955 	DEBUG_PRINTF(_L8("Setting component Localizable."));

   956 	

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

   958 	TInt numberOfValues = 2;

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

   960 	

   961 	if(!stmt)

   962 		{// Add a new name for this component

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

   964 		}

   965 	else

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

   967 		CleanupStack::PushL(stmt);

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

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

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

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

   972 		TInt numberOfValues = 2;

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

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

   975 		}

   976 	}

   977 

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

   979 	{

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

   981 	

   982 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

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

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

   985 		{// Component name cannot be empty

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

   987 		User::Leave(KErrArgument);

   988 		}	

   989 		

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

   991 	_LIT(KComponentNameField,"Name");

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

   993 	CleanupStack::PopAndDestroy(componentName);

   994 	}

   995 

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

   997 	{

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

   999 	

  1000 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

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

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

  1003 	_LIT(KComponentVendorField,"Vendor");

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

  1005 	CleanupStack::PopAndDestroy(vendorName);

  1006 	}

  1007 

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

  1009 	{

  1010 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

  1011 	TInt propertyValue = aMessage.Int1();

  1012 	

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

  1014 	TInt formattedLen = aPropertyColumn.Length();

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

  1016 	TInt numberOfValues = 2;

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

  1018 	CleanupStack::PopAndDestroy(statementStr);

  1019 	}

  1020 

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

  1022 	{

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

  1024 	_LIT(KColumnNameRemovable, "Removable");

  1025 	ReadAndSetCommonComponentPropertyL(aMessage, KColumnNameRemovable);

  1026 	}

  1027 

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

  1029 	{

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

  1031 	_LIT(KColumnNameDrmProtected, "DRMProtected");

  1032 	ReadAndSetCommonComponentPropertyL(aMessage, KColumnNameDrmProtected);	

  1033 	}

  1034 

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

  1036 	{

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

  1038 	_LIT(KColumnNameHidden, "Hidden");

  1039 	ReadAndSetCommonComponentPropertyL(aMessage, KColumnNameHidden);		

  1040 	}

  1041 

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

  1043 	{

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

  1045 	_LIT(KColumnNameKnownRevoked, "KnownRevoked");

  1046 	ReadAndSetCommonComponentPropertyL(aMessage, KColumnNameKnownRevoked);	

  1047 	}

  1048 

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

  1050 	{

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

  1052 	_LIT(KColumnNameOriginVerified, "OriginVerified");

  1053 	ReadAndSetCommonComponentPropertyL(aMessage, KColumnNameOriginVerified);	

  1054 	}

  1055 		

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

  1057 	{

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

  1059 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

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

  1061 	if (componentSize < 0)

  1062 		{

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

  1064 		User::Leave(KErrArgument);

  1065 		}

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

  1067 	TInt numberOfValues = 2;

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

  1069 	}

  1070 

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

  1072 	{

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

  1074 	}

  1075 

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

  1077 	{

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

  1079 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

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

  1081 	

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

  1083 	TInt numberOfValues = 2;

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

  1085 	

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

  1087 	if(KErrNotFound == logIdx)

  1088 		{

  1089 		CleanupStack::PopAndDestroy(version);

  1090 		return;

  1091 		}

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

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

  1094 	CleanupStack::Pop(version);

  1095 	}

  1096 

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

  1098 	{

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

  1100 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

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

  1102 	

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

  1104 	TInt numberOfValues = 2;

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

  1106 	CleanupStack::PopAndDestroy(name);

  1107 	}

  1108 

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

  1110 	{

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

  1112 	

  1113 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

  1114 	HBufC* fileName  = ReadFileNameFromMsgLC(aMessage);

  1115 	

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

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

  1118 	

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

  1120 	TInt numberOfValues = 2;

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

  1122 	CleanupStack::PopAndDestroy(2, fileName);

  1123 	}

  1124 

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

  1126 	{

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

  1128 	

  1129 	TComponentId componentId = GetComponentIdFromMsgL(aMessage);

  1130 	HBufC* fileName  = ReadFileNameFromMsgLC(aMessage);

  1131 	

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

  1133 	if (compFileId == KErrNotFound)

  1134 		{