/*
* Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
* Implements the SCR session class which is server-side session object.
*
*/
/**
@file
@internalComponent
@released
*/
#include "scrserver.h"
#include "scrsubsession.h"
#include "scrrequestimpl.h"
#include "usiflog.h"
#include "usiferror.h"
using namespace Usif;
//
// CScrSession
//
CScrSession::CScrSession(CScrServer& aServer)
/**
Intializes the SCR session object with the server handle.
*/
: CScsSession(aServer)
{
DEBUG_PRINTF(_L8("SCR session construction!"));
}
CScrSession::~CScrSession()
/**
Destructor for the SCR session object.
*/
{
DEBUG_PRINTF(_L8("SCR session destruction!"));
CScrServer *server = static_cast<CScrServer*>(&iServer);
// Take care to close all outstanding subsesions first, as we wouldn't be able to roll-back with open statements
TRAP_IGNORE(CScsSession::CloseAllSubsessionsL());
// Now roll-back transaction in case it wasn't committed or rolled back explicitly
if(server->IsTransactionOwner(this))
{
TRAPD(err, server->RequestImpL()->RollbackTransactionL());
if(KErrNone != err)
{
TRAP_IGNORE(server->ReconnectL());
}
server->SetTransactionOwner(NULL);
}
// Any error during writing log entries can be ignored as it is done in the destructor of SCR session
// and error logs are already written inside the function.
TRAP_IGNORE(server->RequestImpL()->FlushLogEntriesArrayL());
}
CScrSession* CScrSession::NewL(CScrServer &aServer, const RMessage2& aMessage)
/**
Factory function allocates new instance of CScrSession.
@param aServer SCR Server object.
@param aMessage Standard server-side handle to message. Not used.
@return Newly created instance of CScrSession which is owned by the caller.
*/
{
DEBUG_PRINTF2(_L("A new SCR session for the process(0x%x) is being created."), aMessage.SecureId().iId);
(void)aMessage; // Happy the compiler in release mode
CScrSession* self = new (ELeave) CScrSession(aServer);
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(self);
return self;
}
void CancelTransaction(TAny* aParam)
{
CScrServer *server = static_cast<CScrServer*>(aParam);
TRAP_IGNORE(server->RequestImpL()->RollbackTransactionL());
server->SetTransactionOwner(NULL);
}
TBool CScrSession::DoServiceL(TInt aFunction, const RMessage2& aMessage)
/**
Implement CScsSession by handling the supplied message.
@param aFunction Function identifier without SCS code.
@param aMessage Standard server-side handle to message. Not used.
*/
{
TScrSessionFunction f = static_cast<TScrSessionFunction>(aFunction);
CScrServer *server = static_cast<CScrServer*>(&iServer);
TBool isImplicitTransaction = EFalse;
MutatingOperationsPreambleL(*server, f, isImplicitTransaction);
if(isImplicitTransaction)
{
CleanupStack::PushL(TCleanupItem(CancelTransaction, server));
}
switch(f)
{
case ECreateTransaction:
server->RequestImpL()->CreateTransactionL();
server->SetTransactionOwner(this);
break;
case ERollbackTransaction:
server->RequestImpL()->RollbackTransactionL();
server->SetTransactionOwner(NULL);
break;
case ECommitTransaction:
server->RequestImpL()->CommitTransactionL();
server->SetTransactionOwner(NULL);
break;
case EAddComponent:
server->RequestImpL()->AddComponentL(aMessage);
break;
case ESetComponentLocalizableProperty:
server->RequestImpL()->SetComponentLocalizablePropertyL(aMessage);
break;
case ESetComponentNumericProperty:
server->RequestImpL()->SetComponentIntPropertyL(aMessage);
break;
case ESetComponentBinaryProperty:
server->RequestImpL()->SetComponentBinaryPropertyL(aMessage);
break;
case ERegisterComponentFile:
server->RequestImpL()->RegisterComponentFileL(aMessage);
break;
case ESetFileStringProperty:
server->RequestImpL()->SetFileStrPropertyL(aMessage);
break;
case ESetFileNumericProperty:
server->RequestImpL()->SetFileIntPropertyL(aMessage);
break;
case ESetComponentName:
server->RequestImpL()->SetComponentNameL(aMessage);
break;
case ESetComponentVendor:
server->RequestImpL()->SetVendorNameL(aMessage);
break;
case ESetComponentVersion:
server->RequestImpL()->SetComponentVersionL(aMessage);
break;
case ESetIsComponentRemovable:
server->RequestImpL()->SetIsComponentRemovableL(aMessage);
break;
case ESetIsComponentDrmProtected:
server->RequestImpL()->SetIsComponentDrmProtectedL(aMessage);
break;
case ESetIsComponentHidden:
server->RequestImpL()->SetIsComponentHiddenL(aMessage);
break;
case ESetIsComponentKnownRevoked:
server->RequestImpL()->SetIsComponentKnownRevokedL(aMessage);
break;
case ESetIsComponentOriginVerified:
server->RequestImpL()->SetIsComponentOriginVerifiedL(aMessage);
break;
case ESetComponentSize:
server->RequestImpL()->SetComponentSizeL(aMessage);
break;
case EDeleteComponentProperty:
server->RequestImpL()->DeleteComponentPropertyL(aMessage);
break;
case EDeleteFileProperty:
server->RequestImpL()->DeleteFilePropertyL(aMessage);
break;
case EUnregisterComponentFile:
server->RequestImpL()->UnregisterComponentFileL(aMessage);
break;
case EDeleteComponent:
server->RequestImpL()->DeleteComponentL(aMessage);
break;
case EGetSingleComponentSize:
server->RequestImpL()->GetComponentEntrySizeL(aMessage);
break;
case EGetSingleComponentData:
server->RequestImpL()->GetComponentEntryDataL(aMessage);
break;
case EGetFilePropertiesSize:
server->RequestImpL()->GetFilePropertiesSizeL(aMessage);
break;
case EGetFilePropertiesData:
server->RequestImpL()->GetFilePropertiesDataL(aMessage);
break;
case EGetSingleFilePropertySize:
server->RequestImpL()->GetSingleFilePropertySizeL(aMessage);
break;
case EGetSingleFilePropertyData:
server->RequestImpL()->GetSingleFilePropertyDataL(aMessage);
break;
case EGetFileComponentsSize:
server->RequestImpL()->GetFileComponentsSizeL(aMessage);
break;
case EGetFileComponentsData:
server->RequestImpL()->GetFileComponentsDataL(aMessage);
break;
case EGetComponentPropertiesSize:
server->RequestImpL()->GetComponentPropertiesSizeL(aMessage);
break;
case EGetComponentPropertiesData:
server->RequestImpL()->GetComponentPropertiesDataL(aMessage);
break;
case EGetComponentSinglePropertySize:
server->RequestImpL()->GetComponentSinglePropertySizeL(aMessage);
break;
case EGetComponentSinglePropertyData:
server->RequestImpL()->GetComponentSinglePropertyDataL(aMessage);
break;
case EGetIsMediaPresent:
server->RequestImpL()->GetIsMediaPresentL(aMessage);
break;
case ESetScomoState:
server->RequestImpL()->SetScomoStateL(aMessage);
break;
case EGetPluginUidWithMimeType:
server->RequestImpL()->GetPluginUidWithMimeTypeL(aMessage);
break;
case EGetPluginUidWithComponentId:
server->RequestImpL()->GetPluginUidWithComponentIdL(aMessage);
break;
case EGetComponentIdListSize:
server->RequestImpL()->GetComponentIdListSizeL(aMessage);
break;
case EGetComponentIdListData:
server->RequestImpL()->GetComponentIdListDataL(aMessage);
break;
case EGetComponentFilesCount:
server->RequestImpL()->GetComponentFilesCountL(aMessage);
break;
case EAddComponentDependency:
server->RequestImpL()->AddComponentDependencyL(aMessage);
break;
case EDeleteComponentDependency:
server->RequestImpL()->DeleteComponentDependencyL(aMessage);
break;
case EGetLocalComponentId:
server->RequestImpL()->GetComponentIdL(aMessage);
break;
case EGetComponentWithGlobalIdSize:
server->RequestImpL()->GetComponentWithGlobalIdSizeL(aMessage);
break;
case EGetComponentWithGlobalIdData:
server->RequestImpL()->GetComponentWithGlobalIdDataL(aMessage);
break;
case EGetSupplierComponentsSize:
server->RequestImpL()->GetSupplierComponentsSizeL(aMessage);
break;
case EGetSupplierComponentsData:
server->RequestImpL()->GetSupplierComponentsDataL(aMessage);
break;
case EGetDependantComponentsSize:
server->RequestImpL()->GetDependantComponentsSizeL(aMessage);
break;
case EGetDependantComponentsData:
server->RequestImpL()->GetDependantComponentsDataL(aMessage);
break;
case EAddSoftwareType:
server->RequestImpL()->AddSoftwareTypeL(aMessage);
break;
case EDeleteSoftwareType:
server->RequestImpL()->DeleteSoftwareTypeL(aMessage);
break;
case EGetDeletedMimeTypes:
server->RequestImpL()->GetDeletedMimeTypesL(aMessage);
break;
case EGetIsComponentOrphaned:
server->RequestImpL()->GetIsComponentOrphanedL(aMessage);
break;
case EGetLogFileHandle:
server->RequestImpL()->GetLogFileHandleL(aMessage);
//RMessage2 object is closed by both TransferToClient() and SCS framework.
//return EFalse to prevent SCS to close the message object.
return EFalse;
case EGetIsComponentOnReadOnlyDrive:
server->RequestImpL()->GetIsComponentOnReadOnlyDriveL(aMessage);
break;
case EGetIsComponentPresent:
server->RequestImpL()->GetIsComponentPresentL(aMessage);
break;
case ESetIsComponentPresent:
server->RequestImpL()->SetIsComponentPresentL(aMessage);
break;
case EGetComponentSupportedLocalesListSize:
server->RequestImpL()->GetComponentSupportedLocalesListSizeL(aMessage);
break;
case EGetComponentSupportedLocalesListData:
server->RequestImpL()->GetComponentSupportedLocalesListDataL(aMessage);
break;
case EGetLocalizedComponentSize:
server->RequestImpL()->GetComponentLocalizedEntrySizeL(aMessage);
break;
case EGetLocalizedComponentData:
server->RequestImpL()->GetComponentLocalizedEntryDataL(aMessage);
break;
case EAddApplicationEntry:
server->RequestImpL()->AddApplicationEntryL(aMessage);
break;
case EDeleteApplicationEntries:
server->RequestImpL()->DeleteAllAppsWithinPackageL(aMessage);
break;
case EDeleteApplicationEntry:
server->RequestImpL()->DeleteApplicationEntryL(aMessage);
break;
case EGetComponentIdForApp:
server->RequestImpL()->GetComponentIdForAppL(aMessage);
break;
case EGetAppUidsForComponentSize:
server->RequestImpL()->GetAppUidsForComponentSizeL(aMessage);
break;
case EGetAppUidsForComponentData:
server->RequestImpL()->GetAppUidsForComponentDataL(aMessage);
break;
case EGenerateNonNativeAppUid:
server->RequestImpL()->GenerateNonNativeAppUidL(aMessage);
break;
case EGetApplicationLaunchersSize:
server->RequestImpL()->GetApplicationLaunchersSizeL(aMessage);
break;
case EGetApplicationLaunchersData:
server->RequestImpL()->GetApplicationLaunchersDataL(aMessage);
break;
default:
User::Leave(KErrNotSupported);
break;
}//End of switch.
if(isImplicitTransaction)
{
MutatingOperationsPostambleL(*server);
CleanupStack::Pop(server);
}
return ETrue;
}//End of function DoServiceL
void CScrSession::ApplySubsessionConstraintL(CScrServer& aServer)
{// Check whether or not write operation is allowed. if a subsession is in progress
// a mutating operation is not allowed to make the subsession results consistent.
if(aServer.SubsessionCount() > 0)
{
DEBUG_PRINTF(_L8("Subsession in progress. Database write access was rejected!"));
User::Leave(KErrScrReadOperationInProgress);
}
}
void CScrSession::ApplyTransactionConstraintL(CScrServer& aServer, TBool& aCreateImplicitTransaction)
{// Check whether a transaction is in progress and owned by this session.
// A mutating operation is not allowed if the transaction owned by another session.
if(aServer.IsTransactionInProgress())
{// A transaction is already in progress, check if it is owned by this session.
if(!aServer.IsTransactionOwner(this))
{
DEBUG_PRINTF(_L8("Transaction in progress owned by another session. Database write access was rejected!"));
User::Leave(KErrScrWriteOperationInProgress);
}
aCreateImplicitTransaction = EFalse;
}
else if(aCreateImplicitTransaction)
{// No transaction is in progress. Start an implicit transaction to improve
// the performance of mutating APIs. The implicit transaction must be
// committed when the API request is completed successfully, or rolled back
// if a failure occurs while performing the request.
aServer.RequestImpL()->CreateTransactionL();
aServer.SetTransactionOwner(this);
}
}
void CScrSession::MutatingOperationsPreambleL(CScrServer& aServer, TScrSessionFunction aFunction, TBool& aIsTransactionImplicit)
{
// In SCR server, there can be ONLY ONE active TRANSACTION. Concurrent and nested
// transactions are not supported. A transaction can committed/cancelled only by
// its owning session. While a transaction in progress, other sessions can invoke
// query APIs, but not mutating APIs. Only the owning session can invoke APIs altering
// database data. Moreover, a reading session (subsession) cannot be created while a transaction
// is in progress unless the transaction is owned by this session. A transaction cannot be created if a reading subsession exits.
switch(aFunction)
{
case ECreateTransaction:
{
if(aServer.IsTransactionInProgress())
{// A new transaction cannot be started if there is another in progress
User::Leave(KErrScrWriteOperationInProgress);
}
if(aServer.SubsessionCount() && !aServer.IsTheOnlySubsessionOwner(this))
{// If there is a subsession owned by another session, it is not allowed to start a new transaction.
// Beacuse it is also not allowed to create a subsession if a transaction owned by another session is in progress.
User::Leave(KErrScrReadOperationInProgress);
}
break;
}
case ERollbackTransaction:
case ECommitTransaction:
{
if(!aServer.IsTransactionOwner(this))
{
DEBUG_PRINTF(_L8("There is no active transaction owned by this session!"));
User::Leave(KErrScrNoActiveTransaction);
}
break;
}
case ESetComponentLocalizableProperty:
case ESetComponentNumericProperty:
case ESetComponentBinaryProperty:
case ESetFileStringProperty:
case ESetFileNumericProperty:
case ESetComponentName:
case ESetComponentVendor:
case ESetComponentVersion:
case ESetIsComponentRemovable:
case ESetIsComponentDrmProtected:
case ESetIsComponentHidden:
case ESetIsComponentKnownRevoked:
case ESetIsComponentOriginVerified:
case ESetComponentSize:
case EDeleteComponentProperty:
case EDeleteFileProperty:
case EAddComponentDependency:
case EDeleteComponentDependency:
case ESetIsComponentPresent:
{
ApplySubsessionConstraintL(aServer);
// These mutating operations consist of a single mutating database statement.
// So, no need to create an implicit transaction
TBool createImplicitTransaction = EFalse;
ApplyTransactionConstraintL(aServer,createImplicitTransaction);
break;
}
case EAddComponent:
case ERegisterComponentFile:
case EUnregisterComponentFile:
case EDeleteComponent:
case EAddSoftwareType:
case EDeleteSoftwareType:
case EGetDeletedMimeTypes:
case EAddApplicationEntry:
case EDeleteApplicationEntries:
case EDeleteApplicationEntry:
{
ApplySubsessionConstraintL(aServer);
// These mutating operations consist of two or more mutating database statements.
// Therefore, an implicit transaction is begun if an explicit one doesn't exist.
TBool createImplicitTransaction = ETrue;
ApplyTransactionConstraintL(aServer,createImplicitTransaction);
aIsTransactionImplicit = createImplicitTransaction;
break;
}
default:
// Other operations do NOT require write permission. Do nothing.
break;
}
}
void CScrSession::MutatingOperationsPostambleL(CScrServer& aServer)
{
// This function is called to commit the implicit transaction opened for a specific mutating request.
aServer.RequestImpL()->CommitTransactionL();
aServer.SetTransactionOwner(NULL);
}
CScsSubsession* CScrSession::DoCreateSubsessionL(TInt aFunction, const RMessage2& /*aMessage*/)
/**
Override CScsSession::DoCreateSubsessionL by allocating a new SCR subsession object.
@param aFunction Function identifier without SCS code.
@param aMessage Standard server-side handle to message.
@return New, initialized instance of CScrSubsession, ownership is transferred.
*/
{
TScrSessionFunction f = static_cast<TScrSessionFunction>(aFunction);
CScrServer *server = static_cast<CScrServer*>(&iServer);
if(server->IsTransactionInProgress() && !server->IsTransactionOwner(this))
{
DEBUG_PRINTF(_L8("Transaction from another session is in progress. Subsession cannot be created!"));
User::Leave(KErrScrWriteOperationInProgress);
}
switch(f)
{
case ESubSessCreateComponentsView:
return CComponentViewSubsession::NewL(*this);
case ESubSessCreateFileList:
return CFileListSubsession::NewL(*this);
case ESubSessCreateAppInfoView:
return CAppInfoViewSubsession::NewL(*this);
case ESubSessCreateAppRegInfo:
return CApplicationRegInfoSubsession::NewL(*this);
case ESubSessCreateRegInfoForApp:
return CRegInfoForApplicationSubsession::NewL(*this);
case ESubSessCreateAppRegistryView:
return CAppRegistrySubsession::NewL(*this);
default:
User::Leave(KErrNotSupported);
/*lint -unreachable */
return 0; // avoid compiler warning
}
}