diff -r 000000000000 -r 3ce708148e4d applicationmanagement/server/src/ApplicationManagementServer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/applicationmanagement/server/src/ApplicationManagementServer.cpp Thu Dec 17 08:40:12 2009 +0200 @@ -0,0 +1,3871 @@ +/* + * Copyright (c) 2000 Nokia Corporation and/or its subsidiary(-ies). + * All rights reserved. + * This component and the accompanying materials are made available + * under the terms of "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: Implementation of applicationmanagement components + * + */ + +#define __INCLUDE_CAPABILITY_NAMES__ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "ApplicationManagementConst.h" +#include "ampskeys.h" +#include +#include "amprivateCRKeys.h" +#include +#include +#include +#include + +#include "ApplicationManagementCommon.h" +#include "ApplicationManagementClientServer.h" +#include "ApplicationManagementServer.h" +#include "AMDeploymentComponent.h" +#include "amsmlhelper.h" +#include "ApplicationManagementUtility.h" +#include "ApplicationManagementUtilityFactory.h" + +#include "debug.h" + +#include "coemain.h" +#include +#include "SyncService.h" +#include "AMPreInstallApp.h" +#include + +using namespace NApplicationManagement; + +#ifdef __AM_CONNECT_INSTALLER_ONSTARTUP_ + +#pragma message("AM Connecting installer at startup") +#else +#pragma message("AM Connecting installer when needed") +#endif + +// Needed only for jad+jar installation +_LIT( KInstallDir, "c:\\temp\\" ); +_LIT8(KMIDletJarURL, "MIDlet-Jar-URL"); + +//OMA SCOMO Specific +_LIT8(KDownloadState, "./SCOMO/Download/"); +_LIT8(KDeliveredState, "./SCOMO/Inventory/Delivered/"); +_LIT8(KDeployedState, "./SCOMO/Inventory/Deployed/"); + +// ------------------------------------------------------------------------------------------------ +// CShutDown::CShutdown() +// ------------------------------------------------------------------------------------------------ + +inline CShutdown::CShutdown() : + CTimer(-1) + { + CActiveScheduler::Add(this); + } + +// ------------------------------------------------------------------------------------------------ +// CShutDown::ConstructL() +// ------------------------------------------------------------------------------------------------ + +inline void CShutdown::ConstructL() + { + CTimer::ConstructL(); + } + +// ------------------------------------------------------------------------------------------------ +// CShutDown::Start() +// ------------------------------------------------------------------------------------------------ + +inline void CShutdown::Start() + { + RDEBUG( "ApplicationManagementServer: starting shutdown timeout" ); + After(KApplicationManagementShutdownDelay); + } + +// ------------------------------------------------------------------------------------------------ +// CShutDown::RunL() +// ------------------------------------------------------------------------------------------------ + +void CShutdown::RunL() + { + RDEBUG( "ApplicationManagementServer timeout ... closing" ); + CActiveScheduler::Stop(); + } + +// ------------------------------------------------------------------------------------------------ +// CShutDown::Start() +// ------------------------------------------------------------------------------------------------ + +inline void CShutdown::Stop() + { + RDEBUG( "ApplicationManagementServer: Stop" ); + CActiveScheduler::Stop(); + } + + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::CreateServiceL() +// ------------------------------------------------------------------------------------------------ +CApaAppServiceBase* CApplicationManagementServer::CreateServiceL( + TUid aServiceType) const + { + RDEBUG( "ApplicationManagementServer CreateServiceL" ); + if (aServiceType.iUid == KAMServiceUid) + { + return ((CApaAppServiceBase*) (new (ELeave) CApplicationManagementSession)); + } + else + { + return CAknAppServer::CreateServiceL(aServiceType); + } + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::SendServerToBackground() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::SendServerToBackground() + { + + RDEBUG( "ApplicationManagementServer SendServerToBackground - Start " ); + TApaTaskList taskList(CEikonEnv::Static()->WsSession() ); + TApaTask task = taskList.FindApp(TUid::Uid(KAppMgmtServerUid)); + + TInt id = CEikonEnv::Static()->RootWin().Identifier(); + + RDEBUG_2( "CApplicationManagementServer:::SendServerToBackground %d", id ); + + task.SetWgId(id); + + if (task.Exists()) + { + RDEBUG( "ApplicationManagementServer SendServerToBackground - Start 1" ); + task.SendToBackground(); + } + RDEBUG( "ApplicationManagementServer SendServerToBackground - End " ); + TInt amServerEnabled = 0; + RProperty::Set(KUidPSApplicationManagementKeys, KAMServerUIEnabled, + amServerEnabled); + RDEBUG( "ApplicationManagementServer SendServerToBackground - End 2 " ); + + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::BringServertoForeground() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::BringServertoForeground() + { + + RDEBUG( "CApplicationManagementServer:::BringServertoForeground " ); + TApaTaskList taskList(CEikonEnv::Static()->WsSession() ); + TApaTask task = taskList.FindApp(TUid::Uid(KAppMgmtServerUid)); + + TInt id = CEikonEnv::Static()->RootWin().Identifier(); + + RDEBUG_2( "CApplicationManagementServer:::BringServertoForeground %d", id ); + + task.SetWgId(id); + if (task.Exists()) + { + RDEBUG( "ApplicationManagementServer SendServerToBackground - BringServertoForeground " ); + task.BringToForeground(); + } + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::BringServertoForeground() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::BringDMUItoForeground() + { + RDEBUG( "ApplicationManagementServer DownloadComplete - DM UI Broughtto foreground Start " ); + + TApaTaskList taskList(CEikonEnv::Static()->WsSession() ); + TApaTask task = taskList.FindApp(KPSUidNSmlDMSyncApp); + + const TInt id = task.WgId(); + task.SetWgId(id); + RDEBUG_2( "CApplicationManagementServer:::BringDMUItoForeground %d", id ); + + if (task.Exists()) + { + RDEBUG( "ApplicationManagementServer DownloadComplete - DM UI Broughtto foreground " ); + task.BringToForeground(); + } + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::ComponentDownloadComplete() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::ComponentDownloadComplete( + CDeploymentComponent *aComponent, TInt iapid, HBufC8 *aServerId) + { + TInt err = KErrNone; + TRAP( err, DownloadCompleteL( aComponent, iapid, aServerId )); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::DownloadCompleteL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::DownloadCompleteL( + CDeploymentComponent *aComponent, TInt iapid, HBufC8 *aServerId) + { + RDEBUG( "ApplicationManagementServer DownloadComplete - start" ); + __ASSERT_DEBUG( aComponent, User::Invariant() ); + iStorage->UpdateL( *aComponent); + TInt errdownload = KErrNone; + TInt errInstall = KErrNone; + TInt status = KStatusSuccess; + if ( !aComponent->DownloadFailed() ) + { + CDeploymentComponent *old = DoDataUpdateCheckL( *aComponent); + TDownloadTarget trgt = aComponent->DownloadTarget(); + switch (trgt) + { + case EDeliver: + { + break; + } + case EInstall: + case EInstallAndActivate: + { + TRAP(errInstall,DoTheInstallL( *aComponent)); + if (trgt == EInstall && errInstall == KErrNone) + { + iStorage->DeactivateL( *aComponent); + } + /* to avoid duplicates in deployed tree if user delivered upgrade package + * by using "Install/InstallActivate" operation. if upgrade package is delivered + * by Update/UpdateandActivate" , this been handled in next switch case + */ + + break; + } + + case EUpdate: + case EUpdateAndActivate: + { + if (old) + { + FullUpdateL( *aComponent, *old); + if (trgt == EUpdate) + { + iStorage->DeactivateL( *aComponent); + } + } + break; + } + default: + { + break; + } + } + + } + else + { + errdownload = aComponent->DownloadStatus(); + } + + RDEBUG( "ApplicationManagementServer DownloadComplete - Start Send to background" ); + //Download Completed/ Failed or installation success/ failure Send server to Background. + + SendServerToBackground(); + + // Bring DM UI to foreground provided operation is in non silent mode. + TInt operNonSilent = KErrNotFound; + + RProperty::Get(KUidPSApplicationManagementKeys, KAMOperationNonSilent, + operNonSilent); + + if (operNonSilent==1 || operNonSilent==KErrNotFound) + { + RDEBUG( "ApplicationManagementServer DownloadComplete - DM UI Bring " ); + BringDMUItoForeground(); + } + + iOMASCOMOEnabled = IsOMASCOMOEnabledL(); + + + if (iOMASCOMOEnabled) + { + + + status = GetErrorStatus(errdownload,errInstall); + + TInt ASyncSupported = -1; + + CRepository *repository = CRepository::NewLC( KUidPSApplicationManagementKeys ); + repository->Get(KAsyncEnabled, ASyncSupported); + CleanupStack::PopAndDestroy(); + + // For Sync Reporting + if (!ASyncSupported) + { + + // Update Central Repository with proper error code for Sync + + + CRepository *repository= CRepository::NewLC ( KUidPSApplicationManagementKeys ) ; + repository->Set(KAMSyncStatus, status); + CleanupStack::PopAndDestroy(); + + RProperty counter; + + TInt r=counter.Attach(KUidPSApplicationManagementKeys, + KSyncNotifier, EOwnerThread); + User::LeaveIfError(r); + + TInt err = counter.Set(KErrCancel); + User::LeaveIfError(err); + counter.Close(); + + } + else// Do AsyncReporting + { + + // Get deployement component entries + TInt internalid = aComponent->InternalId(); + + TBuf8<256> targetURI; + + TDeploymentComponentState state = aComponent->State(); + + if (state == EDCSDownload) + { + targetURI.Append(KDownloadState); + targetURI.Append(aComponent->UserId()); + } + else + if (state == EDCSDelivered) + { + targetURI.Append(KDeliveredState); + targetURI.Append(aComponent->UserId()); + + } + else + if (state == EDCSActive|| state == EDCSInactive) + { + targetURI.Append(KDeployedState); + targetURI.Append(aComponent->UserId()); + } + + //Save Entry to database with status and target URI of deployment component + + TInt index; + iAMServerDB->SaveToDatabaseL(index, internalid, status, + targetURI, iapid); + + EnableDMNetworkMonL(iapid, aServerId); + } + + } + if (iDownloadMngr->DownloadCount() == 0) + { + + RDEBUG_2( "CApplicationManagementServer::ConstructL - ERROR leaving cannot connect installer: %d", iSessionCount ); + + // Is session count is not modified whenever there is error then at the end of download complete decrement + // the session count. + + if(status != KStatusSuccess && iSessionCount != 0 ) + { + iSessionCount--; + } + + if (iSessionCount == 0) + { + iShutdown.Stop(); + } + } + + RDEBUG( "ApplicationManagementServer DownloadComplete - end" ); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::IsOMASCOMOEnabledL() +// ------------------------------------------------------------------------------------------------ + +TBool CApplicationManagementServer::IsOMASCOMOEnabledL() + { + TInt adapterValue; + + CRepository *repository = CRepository::NewLC ( KCRUidPrivateApplicationManagementKeys ) ; + repository->Get(KAMAdapterValue, adapterValue); + CleanupStack::PopAndDestroy(); + + if(adapterValue ==0 || adapterValue == 1) + return EFalse; + else + return ETrue; + + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::GetErrorStatus() +// ------------------------------------------------------------------------------------------------ +TInt CApplicationManagementServer::GetErrorStatus(TInt aErrorDownload, TInt aErrorInstall) +{ + TInt status = KStatusSuccess; + + if (aErrorDownload!=KErrNone) + { + if (aErrorDownload == KStatusUserCancelled || aErrorDownload + == KStatusDowloadFailedOOM || aErrorDownload + == KStatusUnSupportedEnvironment || aErrorDownload + ==KStatusAlternateDownldAuthFail || aErrorDownload == KStatusAltDowldUnavailable) + { + status = aErrorDownload; + } + else + status = KStatusDownloadFailed; + } + + else + if (aErrorInstall!=KErrNone) + { + if (aErrorInstall == SwiUI::KSWInstErrSecurityFailure) + status = KStatusPkgValidationFailed; + if (aErrorInstall == SwiUI::KSWInstErrInsufficientMemory) + status = KStatusInstallFailedOOM; + else + status = KStatusInstallFailed; + + } + + return status; + +} + + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::EnableDMNetworkMonL() +// ------------------------------------------------------------------------------------------------ +void CApplicationManagementServer::EnableDMNetworkMonL(TInt iapid, HBufC8 *aServerId) +{ + TInt retryenabled = 1; + _LIT( KNetMon,"\\dmnetworkmon.exe" ); + + // Enable DM Network Monitoring for retry of Generic alert in case of N/W loss + + CRepository *repository= CRepository::NewLC ( KCRUidDeviceManagementInternalKeys ); + repository->Set(KDevManEnableDMNetworkMon, retryenabled); + repository->Set(KDevManServerIdKey, *aServerId); + repository->Set(KDevManIapIdKey, iapid); + CleanupStack::PopAndDestroy(); + + // create NetMon EXE + RProcess rp; + TInt err = rp.Create(KNetMon,KNullDesC); + User::LeaveIfError(err); + TRequestStatus stat; + rp.Rendezvous(stat); + + if (stat!=KRequestPending) + rp.Kill(0); // abort startup + else + rp.Resume(); // logon OK - start the server + TInt r=(rp.ExitType()==EExitPanic) ? KErrGeneral : stat.Int(); + rp.Close(); + + +} + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::CApplicationManagementServer +// ------------------------------------------------------------------------------------------------ + +inline CApplicationManagementServer::CApplicationManagementServer() + { + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::AddSession() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::AddSession() + { + // A new session is being created + RDEBUG( "ApplicationManagementServer: CApplicationManagementServer::AddSession" ); + ++iSessionCount; + + // Cancel the shutdown timer if it was running + iShutdown.Cancel(); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::DropSession() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::DropSession() + { + // A session is being destroyed + RDEBUG( "ApplicationManagementServer: CApplicationManagementServer::DropSession" ); + + // Start the shutdown timer if it is the last session + if ( --iSessionCount == 0) + { + if (iDownloadMngr->DownloadCount() > 0) + { + RDEBUG( "ApplicationManagementServer: CApplicationManagementServer::DropSession download in progress" ); + } + else + { + iShutdown.Start(); + } + } + } + +// ----------------------------------------------------------------------------------------------------------- +// CApplicationManagementServer::AddDownloadL( CDeploymentComponent *aComponent ) +// ----------------------------------------------------------------------------------------------------------- + +void CApplicationManagementServer::AddDownloadL( + CDeploymentComponent *aComponent) + { + __ASSERT_DEBUG( aComponent, User::Invariant() ); + iDownloadMngr->AddDownloadL(aComponent); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::NewLC +// ------------------------------------------------------------------------------------------------ + +CApplicationManagementServer* CApplicationManagementServer::NewL() + { + + CApplicationManagementServer* self=new(ELeave) CApplicationManagementServer; + + return self; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::CreateServiceSecurityCheckL +// ------------------------------------------------------------------------------------------------ + +CPolicyServer::TCustomResult CApplicationManagementServer::CreateServiceSecurityCheckL( + TUid aServiceType, const RMessage2& aMsg, TInt& aAction, + TSecurityInfo& aMissing) + { + TInt32 trustRange = EAddTrust; + TInt32 performRFS = EPerformRfs; + TInt32 last = ELast; + + if ( (aServiceType.iUid >= trustRange) + && (aServiceType.iUid < performRFS )) + { + if (aMsg.HasCapability(TCapability(ECapabilityTrustedUI) ) ) + { + return CPolicyServer::EPass; + } + else + { + return CPolicyServer::EFail; + } + } + + else + if ( (aServiceType.iUid >= performRFS) && (aServiceType.iUid < last)) + + { + if (aMsg.HasCapability(TCapability(ECapabilityDiskAdmin)) + && (aMsg.SecureId().iId == 0x101f9a02 )) + { + return CPolicyServer::EPass; + } + else + { + return CPolicyServer::EFail; + } + } + + else + if (aServiceType.iUid == last) + { + return CPolicyServer::EFail; + } + + else + { + return CAknAppServer::CreateServiceSecurityCheckL( + aServiceType, aMsg, aAction, aMissing); + } + + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::~CApplicationManagementServer +// ------------------------------------------------------------------------------------------------ + +CApplicationManagementServer::~CApplicationManagementServer() + { + RDEBUG_3("CApplicationManagementServer::~CApplicationManagementServer 0x%X - 0x%X", reinterpret_cast(this ), + reinterpret_cast(this)+sizeof( CApplicationManagementServer ) ); + FeatureManager::UnInitializeLib(); + iInstaller.Close(); + delete iStorage; + + delete iUtility; + delete iAMServerDB; + + RProperty::Delete(KUidPSApplicationManagementKeys, KAMServerUIEnabled); + + RProperty::Delete(KUidPSApplicationManagementKeys, KAMOperationNonSilent); + + RProperty::Delete(KUidPSApplicationManagementKeys, KSyncNotifier); + + RProperty::Delete(KUidPSApplicationManagementKeys, KDMUINotClosed); + + + iInstallFile.Close(); + iInstallRFs.Close(); + + delete iDownloadMngr; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::HandleAllClientsClosed +// ------------------------------------------------------------------------------------------------ +void CApplicationManagementServer::HandleAllClientsClosed() + { + // Do Nothing + RDEBUG( "CApplicationManagementServer::HandleAllClientsClosed" ); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::ConstructL +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::ConstructL(const TDesC &aServerName) + { + + // 2nd phase construction - ensure the timer and server objects are running + RDEBUG( "CApplicationManagementServer::ConstructL - Start" ); + + iOMASCOMOEnabled = ETrue; + + CAknAppServer::ConstructL(aServerName); + TRAPD( errf, FeatureManager::InitializeLibL() ) + ; + if (errf != KErrNone) + { + User::Leave(errf); + } + + RDEBUG( "CApplicationManagementServer::ConstructL - start" ); + + iStorage = CDeliveryComponentStorage::NewL(); + + iUtility + = ApplicationManagementUtilityFactory::CreateManagementUtilityL(); + iDownloadMngr = CAMDownloadManager::NewL( *this); + iAMServerDB = CAMDownloaddb::NewL(); + + // Define P&S Keys + RProperty::Define(KUidPSApplicationManagementKeys, KAMServerUIEnabled, + RProperty::EInt); + + RProperty::Define(KUidPSApplicationManagementKeys, KAMOperationNonSilent, + RProperty::EInt); + + RProperty::Define(KUidPSApplicationManagementKeys, KSyncNotifier, + RProperty::EInt); + + RProperty::Define(KUidPSApplicationManagementKeys, KDMUINotClosed, + RProperty::EInt); + + RProperty syncproperty; + + //Ignore error status + syncproperty.Attach(KUidPSApplicationManagementKeys, KSyncNotifier, + EOwnerThread); + syncproperty.Set(KErrNone); + syncproperty.Close(); + + SendServerToBackground(); + +#ifdef __AM_CONNECT_INSTALLER_ONSTARTUP_ + TInt err( iInstaller.Connect() ); + if ( err != KErrNone ) + { + RDEBUG_2( "CApplicationManagementServer::ConstructL - ERROR leaving cannot connect installer: %d", err ); + User::LeaveIfError( err ); + } +#endif + RDEBUG( "CApplicationManagementServer::ConstructL - end" ); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::StartShutDownTimer() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::StartShutDownTimerL() + { + + RDEBUG( "CApplicationManagementServer::ConstructL - end" ); + + iShutdown.ConstructL(); + // ensure that the server still exits even if the 1st client fails to connect + iShutdown.Start(); + + RDEBUG( "CApplicationManagementServer::ConstructL - end" ); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::CustomSecurityCheckL() +// ------------------------------------------------------------------------------------------------ + +CPolicyServer::TCustomResult CApplicationManagementServer::CustomSecurityCheckL( + const RMessage2& /*aMsg*/, TInt& /*aAction*/, TSecurityInfo& /*aMissing*/) + { + return EPass; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::InstallCompleteL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::InstallCompleteL( + const CDeploymentComponent& aCompo, const TBool &aInstallSuccess) + { + RDEBUG_2("CApplicationManagementServer::InstallCompleteL start (%d)", aInstallSuccess); + iInstallFile.Close(); + + // if java jad + jar install, remove files from c:\temp directory + if (CDeploymentComponent::IsJavaMimeL(aCompo.MetaData().MimeType() ) && CDeploymentComponent::IsJavaMimeL(aCompo.Data().MimeType() ) ) + { + TFileName fn, fn2; + GenerateTempFileNameL(iInstallRFs, aCompo, fn, fn2); + RDEBUG_3("CApplicationManagementServer::InstallCompleteL delete files: (%S) (%S)", &fn, &fn2); + User::LeaveIfError(iInstallRFs.Delete(fn) ); + User::LeaveIfError(iInstallRFs.Delete(fn2) ); + } + + if (aInstallSuccess) + { + // Remove temporary files from private directory + const_cast(aCompo).ResetDataL(iInstallRFs); + } + + iInstallRFs.Close(); + + iInstallInProgress = EFalse; +#ifndef __AM_CONNECT_INSTALLER_ONSTARTUP_ + iInstaller.Close() ; +#endif + RDEBUG("CApplicationManagementServer::InstallCompleteL end"); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::GenerateTempJarFileNameL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::GenerateTempJarFileNameL(RFs &aFs, + const TDesC& aMetaSource, TFileName &aFileName) const + { + if (aMetaSource != KNullDesC) + { + RFile file; + User::LeaveIfError(file.Open(aFs, aMetaSource, EFileRead) ); + CleanupClosePushL(file); + TFileName temp; + temp = ReadJarFileNameL(file); + GenerateTempFileNameL(aFs, temp, aFileName); + CleanupStack::PopAndDestroy( &file); + } + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::GenerateTempFileNameL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::GenerateTempFileNameL(const RFs &aFs, + const TDesC& aSource, TFileName &aFileName) const + { + if (aSource != KNullDesC) + { + aFileName.Copy(KInstallDir); + TParse p; + User::LeaveIfError(aFs.Parse(aSource, p) ); + aFileName.Append(p.NameAndExt() ); + } + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::GenerateTempFileNameL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::GenerateTempFileNameL(RFs &aFs, + const CDeploymentComponent& aCompo, TFileName& aSource, + TFileName &aMetaSource, TFileName &aFileName, + TFileName &aMetaFileName) const + { + if ( !BaflUtils::FolderExists(aFs, KInstallDir) ) + { + aFs.MkDirAll(KInstallDir); + } + + aMetaSource.Copy(aCompo.MetaData().DataFileName() ); + GenerateTempFileNameL(aFs, aMetaSource, aMetaFileName); + aSource.Copy(aCompo.Data().DataFileName() ); + GenerateTempJarFileNameL(aFs, aMetaSource, aFileName); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::GenerateTempFileNameL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::GenerateTempFileNameL(RFs &aFs, + const CDeploymentComponent& aCompo, TFileName &aFileName, + TFileName &aMetaFileName) const + { + TFileName ftemp, msource; + GenerateTempFileNameL(aFs, aCompo, ftemp, msource, aFileName, + aMetaFileName); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::ReadJarFileNameL() +// ------------------------------------------------------------------------------------------------ + +TFileName CApplicationManagementServer::ReadJarFileNameL(RFile& aFile) const + { + TFileName jarFileName; + HBufC8* lineBuffer = HBufC8::NewLC(KMaxFileName+72); // lets hope all lines fit to this + TPtr8 linePtr(lineBuffer->Des() ); + TInt length(0); + aFile.Size(length); + HBufC8* data = HBufC8::NewLC(length); + TPtr8 ptr(data->Des() ); + aFile.Read(ptr); + RDesReadStream stream(*data); + CleanupClosePushL(stream); + TInt colonIndex = -1; + TInt err(KErrNone); + TInt found(KErrNotFound); + const TInt KJadNameValueSeparator = 0x3A; //':' + + for (;;) + { + TRAP( err, ReadLineL(stream, linePtr) ); + if (err == KErrNone) + { + RDEBUG8_2("Read line: (%S)", &linePtr); + found = linePtr.Find(KMIDletJarURL); + if (found != KErrNotFound && found == 0) // found + { + TPtrC8 filename(linePtr); + colonIndex = linePtr.Locate(KJadNameValueSeparator); + if (colonIndex != KErrNotFound) + { + filename.Set(linePtr.Mid(colonIndex+1)); // get jar filename, format is: MIDlet-Jar-URL: bomber.jar + jarFileName.Copy(filename); + jarFileName.Trim(); + break; + } + } + } + else + { + User::Leave(err); + } + } + CleanupStack::PopAndDestroy(3, lineBuffer); // stream, data + return jarFileName; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::ReadLineL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::ReadLineL(RReadStream& aStream, + TDes8& aLineBuffer) const + { + TBuf8<1> input; + const TUint32 LF = 10; + const TUint32 CR = 13; + TBool endOfLine(EFalse); + TInt errRead(KErrNone); + + // reset + aLineBuffer.Zero(); + + while ( !endOfLine) + { + TRAP(errRead, aStream.ReadL(input, 1)); + + if (errRead == KErrEof) + { + // EOF + User::Leave(KErrEof); + } + // check special characters + if (input[0] == LF) + { + // End of line + endOfLine = ETrue; + } + else + if (input[0] == CR) + { + // Only end of line if not followed by a LF + } + else + { + // We put any other character in the buffer + if (aLineBuffer.Length() < aLineBuffer.MaxLength()) + { + aLineBuffer.Append(input[0]); + } + } + } + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::PrepareInstallL() +// ------------------------------------------------------------------------------------------------ + +TBool CApplicationManagementServer::PrepareInstallL( + const CDeploymentComponent &aComponent, TFileName &aFileName) + { + RDEBUG( "CApplicationManagementServer::PrepareInstallL" ); + TBool res(ETrue); + +#ifndef __AM_CONNECT_INSTALLER_ONSTARTUP_ + TInt err(iInstaller.Connect() ); + if (err != KErrNone) + { + RDEBUG_2( "CApplicationManagementServer::PrepareInstallL - ERROR leaving cannot connect installer: %d", err ); + User::LeaveIfError(err); + } + CleanupClosePushL(iInstaller); +#endif + + RDEBUG( "CApplicationManagementServer::PrepareInstallL - connected to installer" ); + // Copy data file name (install file) + if (aComponent.Data().DataFileName().Length() > 0) + { + aFileName.Copy(aComponent.Data().DataFileName() ); + } + else + { + // data file has not been created for component! + User::Leave(KErrNotFound); + } + // Open RFs session + User::LeaveIfError(iInstallRFs.Connect() ); + User::LeaveIfError(iInstallRFs.ShareProtected() ); + + // set installoptions and correct mime type + using namespace SwiUI; + iInstallOptions = aComponent.InstallOpts().iOptions; + TInstallReq req; + if (aComponent.Data().MimeType() == SwiUI::KSisMimeType) + { + //convert if MIME type is application/vnd.symbian.install to x-epoc/x-sisx-app + //as installer doesn't support application/vnd.symbian.install MIME type from S60 3rd edition onwards. + req.iMIME = SwiUI::KSisxMimeType; + } + else + { + req.iMIME = aComponent.Data().MimeType(); + } + + if (CDeploymentComponent::IsJavaMimeL(aComponent.MetaData().MimeType() ) ) { + // Check if both jad and jar files already exist in the phone + if (CDeploymentComponent::IsJavaMimeL(aComponent.Data().MimeType() ) && aComponent.MetaData().MimeType() == SwiUI::KJadMIMEType) { + // Move both files to temporary location and use jad to install java application + CFileMan *fm = CFileMan::NewL(iInstallRFs); + CleanupStack::PushL(fm); + TFileName source, metasource, metatarget; + aFileName.Copy(KNullDesC8() ); // reset + GenerateTempFileNameL(iInstallRFs, aComponent, source, metasource, + aFileName, metatarget); + + RDEBUG_2( "CApplicationManagementServer::PrepareInstallL - temp jar file '%S'", &aFileName ); + RDEBUG_2( "CApplicationManagementServer::PrepareInstallL - temp jad file '%S'", &metatarget ); + + // Copy datafile (jar) + TInt copyer(fm->Copy(source, aFileName) ); + + // Copy metadatafile (jad) + TInt copyer2(fm->Copy(metasource, metatarget) ); + + CleanupStack::PopAndDestroy(fm); + + RDEBUG_3( "CApplicationManagementServer::PrepareInstallL - (%d)-(%d)", copyer, copyer2 ); + + if (copyer == KErrNone && copyer2 == KErrNone) + { + res = ETrue; + aFileName = metatarget; + req.iMIME = aComponent.MetaData().MimeType(); + } + else + { + User::Leave(KErrWrite); + } + } + else + if (aComponent.MetaData().MimeType() == SwiUI::KJadMIMEType) + { + aFileName.Copy(aComponent.MetaData().DataFileName() ); + req.iMIME = aComponent.MetaData().MimeType(); + RDEBUG_2( "CApplicationManagementServer::PrepareInstallL - Using Jad file to install java application: %S", &aFileName ); + } + } + + if (aComponent.GetIAP() > -1) + { + req.iIAP = aComponent.GetIAP(); + RDEBUG_2( "CApplicationManagementServer::PrepareInstallL: setting iap to %d", req.iIAP ); + } + else + { + TInt iap = KErrNotFound; + TRAPD( err, SmlHelper::GetDefaultIAPFromDMProfileL( iap ) ) + ; + if (err == KErrNone) + { + req.iIAP = iap; + RDEBUG_2(" -> using DM profile default IAP: %d", iap); + } + else + { + RDEBUG_2("**** ERROR while fetching DM profile default iap: %d", err ); + } + } + + iInstallReq = SwiUI::TInstallReqPckg(req); + RDEBUG8_2( "CApplicationManagementServer::PrepareInstallL: mime type is (%S)", &req.iMIME); + RDEBUG_2( "CApplicationManagementServer::PrepareInstallL - Using temp file '%S'", &aFileName ); + + User::LeaveIfError(iInstallFile.Open(iInstallRFs, aFileName, EFileRead) ); + TInt sz; + User::LeaveIfError(iInstallFile.Size(sz) ); + if ( !(sz > 0)) + { + res = EFalse; + RDEBUG( "CApplicationManagementServer::PrepareInstallL - ERROR size of source file is 0!" ); + } + +#ifndef __AM_CONNECT_INSTALLER_ONSTARTUP_ + CleanupStack::Pop( &iInstaller); +#endif + + RDEBUG( "CApplicationManagementServer::PrepareInstallL end" ); + return res; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::InstallL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::InstallL( + const CDeploymentComponent &aComponent, TRequestStatus &aStatus) + { + RDEBUG( "CApplicationManagementServer::InstallL (async): begin" ); + + if (iInstallInProgress == EFalse) + { + TFileName fn; + if (PrepareInstallL(aComponent, fn) ) + { + RDEBUG_3( "CApplicationManagementServer::InstallL: Install '%S' sizeof opts: %d", &fn, sizeof (aComponent.InstallOpts())); + + // Silent or Non Silent Installation is choosen based on DM session started in silent or non silent + + TInt err = KErrNone; + TInt nonSilentOperation = KErrNotFound; + RProperty::Get(KUidPSApplicationManagementKeys, + KAMOperationNonSilent, nonSilentOperation); + + if (!nonSilentOperation) + { + TRAP( err ,iInstaller.SilentInstall( aStatus, iInstallFile, iInstallReq, iInstallOptions ) ); + } + else + { + TRAP( err ,iInstaller.Install( aStatus, iInstallFile, iInstallReq ) ); + } + + RDEBUG_2( "CApplicationManagementServer::InstallL: status: %d", err); + User::LeaveIfError(err); + iInstallInProgress = ETrue; + } + else + { + RDEBUG( "CApplicationManagementServer::InstallL - PrepareInstallL failed, leaving" ); + User::Leave(KErrArgument); + } + } + else + { + RDEBUG( "CApplicationManagementServer::InstallL (async): previous install still in progress...bailing out" ); + TRequestStatus * status = &aStatus; + User::RequestComplete(status, KErrInUse); + } + RDEBUG( "CApplicationManagementServer::InstallL (async): end" ); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::PrepareInstallL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::InstallL( + const CDeploymentComponent &aComponent) + { + RDEBUG( "CApplicationManagementServer::InstallL: begin" ); + + if (iInstallInProgress == EFalse) + { + TFileName fn; + if (PrepareInstallL(aComponent, fn) ) + { + iInstallInProgress = ETrue; + RDEBUG_2( "CApplicationManagementServer::InstallL: Install '%S' ", &fn); + SwiUI::TInstallOptionsPckg pkg(aComponent.InstallOpts().iOptions); + TRAPD( err ,iInstaller.SilentInstall( fn, pkg ) ) + ; + User::LeaveIfError(err); + iInstallInProgress = EFalse; + } + else + { + RDEBUG( "CApplicationManagementServer::InstallL - PrepareInstallL failed, leaving" ); + User::Leave(KErrArgument); + } + } + RDEBUG( "CApplicationManagementServer::InstallL: end" ); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::UninstallL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::UninstallL( + const CDeploymentComponent &aComponent, TRequestStatus &aStatus) + { + RDEBUG( "CApplicationManagementServer::UninstallL: begin" ); + if (iInstallInProgress == EFalse) + { + TInt err(iInstaller.Connect() ); + User::LeaveIfError(err); + RDEBUG_2( "CApplicationManagementServer::UninstallL: UninstallL '0x%X' ", aComponent.Uid()); + using namespace SwiUI; + iUninstallOptions = aComponent.UninstallOpts(); + + TInt nonSilentOperation = KErrNotFound; + + RProperty::Get(KPSUidNSmlDMSyncApp, KSilentSession, + nonSilentOperation); + + iOMASCOMOEnabled = IsOMASCOMOEnabledL(); + + if (!iOMASCOMOEnabled) + nonSilentOperation = 0; + if (!nonSilentOperation) + { + TRAP( err ,iInstaller.SilentUninstall( aStatus, aComponent.Uid(), + iUninstallOptions, aComponent.MimeType() ) ); + } + else + { + TRAP( err ,iInstaller.Uninstall( aStatus, aComponent.Uid(), aComponent.MimeType() ) ); + CSyncService *syncService = + CSyncService::NewL(NULL, KDevManServiceStart); + if (syncService) + { + syncService->EnableProgressNoteL(EFalse); + } + + delete syncService; + } + + RDEBUG_2( "CApplicationManagementServer::UninstallL: UninstallL result '0x%X'", err ); + User::LeaveIfError(err); + iInstallInProgress = ETrue; + } + else + { + RDEBUG( "CApplicationManagementServer::UninstallL: previous uninstall still in progress...bailing out" ); + TRequestStatus * status = &aStatus; + User::RequestComplete(status, KErrInUse); + } + + RDEBUG( "CApplicationManagementServer::UninstallL: end" ); + } +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::PerformRFSL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::PerformRFSL() + { + RDEBUG( "CApplicationManagementServer::PerformRFSL: begin" ); + const RComponentIdArray &arrt = iStorage->GetComponentIds(); + TCertInfoPckg *corcert= NULL; + for (TInt i( 0); i < arrt.Count(); i++) + { + RDEBUG_3( "CApplicationManagementServer::PerformRFSL processing dc %d of %d", i, arrt.Count() ); + CDeploymentComponent &c = iStorage->ComponentL(arrt[i]); + + const RCertArray &certs = iStorage->Certificates(); + TInt index = c.Owner(); + TCertInfoPckg *certp = NULL; + if (index >= 0) + { + certp = certs[ c.Owner() ]; + } + if ( !corcert && certp) + { + if (CheckCertL( (*certp)() ) ) + { + corcert = certp; + RDEBUG_2( "CApplicationManagementServer::PerformRFSL Found CORP Cert! Removing %d ", i ); + RemoveInternalL(c); + } + else + { + RDEBUG_2( "CApplicationManagementServer::PerformRFSL skipping %d because not corp dc", i ); + } + } + else + { + if (corcert == certp) + { + RDEBUG_2( "CApplicationManagementServer::PerformRFSL Removing %d ", i ); + RemoveInternalL(c); + } + else + { + RDEBUG_2( "CApplicationManagementServer::PerformRFSL skipping %d because not corp dc", i ); + } + } + } + RDEBUG( "CApplicationManagementServer::PerformRFSL: end" ); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::RemoveInternalL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::RemoveInternalL( + const CDeploymentComponent &aCompo, TBool aDoUninstall /* = ETrue */) + { + RDEBUG_2("CApplicationManagementServer: RemoveInternalL - Remove id: (%d)", aCompo.InternalId() ); + + aCompo.SetStatusNode(EDelivered_RemoveProgress); + TInt err(KErrNone); + TDeploymentComponentState st(aCompo.State() ); + if (st == EDCSDelivered || st == EDCSDownload) + { + TRAP(err,iStorage->RemoveL( aCompo.InternalId() )); + } + else + if (st == EDCSActive || st == EDCSInactive) + { + if (aDoUninstall) + { + if (aCompo.Uid() != TUid::Null() ) + { + //TInt err= KErrNone; + + TInt nonSilentOperation = KErrNotFound; + + RProperty::Get(KPSUidNSmlDMSyncApp, KSilentSession, + nonSilentOperation); + + iOMASCOMOEnabled = IsOMASCOMOEnabledL(); + + if (!iOMASCOMOEnabled) + nonSilentOperation = 0; + + if (nonSilentOperation!=0) + { + + BringServertoForeground(); + + TInt amServerEnabled = 1; + err = RProperty::Set(KUidPSApplicationManagementKeys, + KAMServerUIEnabled, amServerEnabled); + User::LeaveIfError(err); // invalid + + } + + TRequestStatus s; + TRAP(err,UninstallL( aCompo, s )); + User::WaitForRequest(s); + iInstallInProgress = EFalse; + // Capturing Installer errors,if any + err = s.Int(); + + TInt amServerEnabled = 0; + RProperty::Set(KUidPSApplicationManagementKeys, + KAMServerUIEnabled, amServerEnabled); + //User::LeaveIfError(err); // invalid + + SendServerToBackground(); + + // Bring DM UI to foreground + if (nonSilentOperation!=0) + { + BringDMUItoForeground(); + } + + if (s.Int() == KErrNone) + { + RDEBUG("CApplicationManagementServer::RemoveInternalL Uninstalled"); + } + else + if (s.Int() == KErrNotFound) + { + RDEBUG( "CApplicationManagementServer: RemoveInternalL WARNING component was not found by uninstaller" ); + } + else + { + RDEBUG_2("CApplicationManagementServer: RemoveInternalL ERROR uninstall failed %d", s.Int() ); + + } + } + else + { + RDEBUG( "CApplicationManagementServer: RemoveInternalL ERROR component is deployed but has null uid - it cannot be uninstalled!" ); + } + } + else + { + RDEBUG_2("CApplicationManagementServer: RemoveInternalL - Skipped uninstall of %d", aCompo.InternalId() ); + } + /* + * if (unstall is sucesss) then remove component from storage + * + */ + if (err == KErrNone) + { + iStorage->RemoveL(aCompo.InternalId() ); + } + } + else + { + RDEBUG_2("CApplicationManagementServer: RemoveInternalL ERROR called with illegal state component id %d", aCompo.State() ); + User::Leave(KErrArgument); + } + /* + * if error set state to remove failed + * Finally call userleaveiferror() + * */ + if (err != KErrNone) + { + aCompo.SetStatusNode(EDelivered_RemoveFailed); + } + User::LeaveIfError(err); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::CheckCertL() +// ------------------------------------------------------------------------------------------------ + +TBool CApplicationManagementServer::CheckCertL(const TCertInfo &aInfo) const + { + TBool go(EFalse); + + if (FeatureManager::FeatureSupported( KFeatureIdSapPolicyManagement) ) + { + // #ifdef __SAP_POLICY_MANAGEMENT + RPolicyEngine peng; + + // The management session + // + TInt err(peng.Connect() ); + + if (err == KErrNone) + { + CleanupClosePushL(peng); + RPolicyRequest rq; + err = rq.Open(peng) ; + if (err == KErrNone) + { + CleanupClosePushL(rq); + + TRequestContext rc; + + using namespace PolicyEngineXACML; + using namespace NPolicyConstants; + + rc.AddSubjectAttributeL(KTrustedSubject, aInfo); + rc.AddResourceAttributeL(KResourceId, KApplicationManagement, + KStringDataType); + + TResponse resp; + err = rq.MakeRequest(rc, resp); + if (err == KErrNone) + { + if (resp.GetResponseValue() == EResponsePermit +#ifdef _DEBUG + || resp.GetResponseValue() + == EResponseNotApplicable +#endif + ) + { + go = ETrue; + } + else + { + RDEBUG_2( "CApplicationManagementSession::CheckCertL; Policy response denies access! %d", resp.GetResponseValue()); + } + } + else + { + RDEBUG_2( "CApplicationManagementSession::CheckCertL; ERROR making policy request! %d", err); + } + CleanupStack::PopAndDestroy( &rq) ; + } + else + { + RDEBUG_2( "CApplicationManagementSession::CheckCertL; ERROR Failed to open policy engine session! %d", err); + } + CleanupStack::PopAndDestroy( &peng) ; + } + else + { + RDEBUG_2( "CApplicationManagementSession::CheckCertL; ERROR Failed to connect policy engine! %d", err); + } + User::LeaveIfError(err); + } + else + { + RDEBUG( "CApplicationManagementSession::CheckCertL; No PolicyManagement by featmgr-> cert ok!" ); + go = ETrue; + } + return go; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::HasUidL() +// ------------------------------------------------------------------------------------------------ + +TBool CApplicationManagementServer::HasUidL(const TUid &aUid, + CDeploymentComponent *& aCompo, CDeploymentComponent *aIgnored /* = NULL */) + { + TBool found(EFalse); + const RComponentIdArray &arrt = iStorage->GetComponentIds(); + TInt count(arrt.Count() ); + for (TInt i( 0); i < count; i++) + { + CDeploymentComponent &compo = iStorage->ComponentL(arrt[i]); + if (compo.Uid() == aUid) + { + if ( &compo != aIgnored) + { + aCompo = &compo; + found = ETrue; + RDEBUG_3( "ApplicationManagementServer: UidExistsL 0x%X - Found NOT ignored %d", aUid.iUid, compo.InternalId() ); + } + else + { + RDEBUG( "ApplicationManagementServer: UidExistsL - Found ignored " ); + } + } + } + if ( !found) + { + found = FindInstalledSisUidL(aUid); + if ( !found) + { + found = FindInstalledJavaUidL(aUid); + } + } + return found; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::FindInstalledSisUidL() +// ------------------------------------------------------------------------------------------------ + +TBool CApplicationManagementServer::FindInstalledSisUidL(const TUid &aUid) const + { + TBool found(EFalse); + Swi::RSisRegistrySession sisses; + TInt r(sisses.Connect() ); + User::LeaveIfError(r) ; + CleanupClosePushL(sisses); + + RArray uids; + sisses.InstalledUidsL(uids); + CleanupClosePushL(uids); + + TInt uidc(uids.Count() ); + for (TInt j( 0); found == EFalse && j < uidc; j++) + { + if (uids[j] == aUid) + { + found = ETrue; + } + } + CleanupStack::PopAndDestroy( &uids); + CleanupStack::PopAndDestroy( &sisses); + + return found; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::FindInstalledJavaUidL() +// ------------------------------------------------------------------------------------------------ + +TBool CApplicationManagementServer::FindInstalledJavaUidL(const TUid &aUid) const + { + TBool found(EFalse); + iUtility->RefreshJavaRegistryL(); + found = iUtility->FindInstalledJavaUidL(aUid); + return found; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::FindNewUid() +// ------------------------------------------------------------------------------------------------ + +TUid CApplicationManagementServer::FindNewUid(const RArray &aUidsOrig, + const RArray &aUidsNew) const + { + TUid ret(TUid::Null() ); + TInt c1(aUidsOrig.Count() ); + TInt c2(aUidsNew.Count() ); + if (c2 >= c1) + { + for (TInt i(c2 - 1); i >= 0 && !ret.iUid; i--) + { + if (aUidsOrig.Find(aUidsNew[i]) == KErrNotFound) + { + ret = aUidsNew[i]; + } + + } + } + return ret; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::JavaUidsL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::JavaUidsL(RArray &aUids) const + { + iUtility->RefreshJavaRegistryL(); + iUtility->JavaUidsL(aUids); + } + +void CApplicationManagementServer::CheckforDuplicateMidletsL( + TMidletParameters& amidletParameters) + { + RDEBUG( "CApplicationManagementServer::CheckforDuplicateMidletsL: Start"); + const RComponentIdArray &arrt = iStorage->GetComponentIds(); + TInt cont(arrt.Count() ); + for (TInt i( 0); i < cont; i++) + { + CDeploymentComponent &compo = iStorage->ComponentL(arrt[i]); + if (((compo.State() == EDCSActive) || (compo.State() == EDCSInactive )) + && (compo.MidletName()== amidletParameters.iMidletName) + && (compo.MidletVendor()== amidletParameters.iMidletVenorName)) + { + //remove old one + iStorage->RemoveL(compo.InternalId() ); + } + } + + RDEBUG( "CApplicationManagementServer::CheckforDuplicateMidletsL: End"); + } +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::JavaInstallL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::JavaInstallL(CDeploymentComponent &aCompo) + { + RDEBUG( "CApplicationManagementServer::JavaInstallL: Start"); + + TRequestStatus s; + TInt err(KErrNone); + // set state to install progress + aCompo.SetStatusNode(EDelivered_InstallProgress); + TRAP(err,InstallL( aCompo,s )); + if (err != KErrNone) + { + aCompo.SetStatusNode(EDelivered_InstalledFailedWithData); + User::Leave(err); + } + User::WaitForRequest(s); + SendServerToBackground(); + if (s != KErrNone) + { + RDEBUG_2( "ApplicationManagementSession: JavaInstallL failed with code %d", + s.Int() ); + // set state to install failed with data + aCompo.SetStatusNode(EDelivered_InstalledFailedWithData); + User::Leave(s.Int() ); + } + else + { + TMidletParameters midletParameters; + iUtility->RefreshJavaRegistryL(); + //Ignore if any error comes + TRAPD(err,iUtility->GetInstalledMidletParametersL(midletParameters)) + ; + TRAP(err,CheckforDuplicateMidletsL(midletParameters)); + + if (err != KErrNone) + { + aCompo.SetStatusNode(EDelivered_InstalledFailedWithData); + User::Leave(err); + } + else + { + aCompo.SetStatusNode(EIdle); + } + aCompo.SetUid(midletParameters.iMidletUid); + + RDEBUG( "CApplicationManagementServer::JavaInstallL: Step1"); + if (aCompo.ComponentVersion() == KNullDesC8) + { + aCompo.SetVersionL(midletParameters.bufVersion); + + } + + TBool status = EFalse; + + //Since "C" drive is not removable + + if (midletParameters.iDrive!=EDriveC) + { + status = IsInstalledAppRemovableL(midletParameters.iDrive); + } + if (status) + { + RDEBUG( "IsInstalledAppRemovableL(midletParameters.iDrive); True"); + } + else + { + RDEBUG( "IsInstalledAppRemovableL(midletParameters.iDrive); False"); + } + + //check for status drive + aCompo.SetAppRemovableStatus(status); + } + + RDEBUG( "CApplicationManagementServer::JavaInstallL: End"); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::SisInstallL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::SisInstallL( + const CDeploymentComponent &aCompo) + { + TRequestStatus s; + // set state to install progress + aCompo.SetStatusNode(EDelivered_InstallProgress); + TInt err(KErrNone); + TRAP(err,InstallL( aCompo,s )); + if (err != KErrNone) + { + aCompo.SetStatusNode(EDelivered_InstalledFailedWithData); + User::Leave(err); + } + User::WaitForRequest(s); + if (s != KErrNone) + { + RDEBUG_2("ApplicationManagementSession: SisInstallL failed with code %d", + s.Int() ); + // set state to install failed with data + aCompo.SetStatusNode(EDelivered_InstalledFailedWithData); + User::Leave(s.Int() ); + } + else + { + // set state to install sucessful + aCompo.SetStatusNode(EIdle); + RDEBUG("ApplicationManagementSession: SisInstallL successfull" ); + } + RDEBUG( "CApplicationManagementServer::SisInstallL: End"); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::DoTheInstallL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::DoTheInstallL(CDeploymentComponent &aCompo) + { + RDEBUG( "CApplicationManagementServer::DoTheInstallL: Start"); + TInt error(KErrNone); + if (CDeploymentComponent::IsJavaMimeL(aCompo.Data().MimeType() ) + || CDeploymentComponent::IsJavaMimeL(aCompo.MetaData().MimeType() ) ) + { + TRAP( error, JavaInstallL( aCompo ) ); + } + else + { + TRAP( error, SisInstallL( aCompo ) ); + SetSisAppVersionAndDriveL(aCompo); + } + + SendServerToBackground(); + + if (error == KErrNone) + { + InstallCompleteL(aCompo, ETrue); + CDeploymentComponent *old = DoDataUpdateCheckL(aCompo); + if (old) + { + if (aCompo.State() == EDCSDelivered) + { + if (old->State() == EDCSActive || old->State()== EDCSInactive) + { + RDEBUG("AMSession: DoTheInstallL ** deleting old node **" ); + iStorage->RemoveL(old->InternalId() ); + } + } + } + iStorage->InstalledL(aCompo); + } + else + { + InstallCompleteL(aCompo, EFalse); + User::Leave(error); + } + RDEBUG( "CApplicationManagementServer::DoTheInstallL: End"); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::DoDataUpdateCheckL() +// ------------------------------------------------------------------------------------------------ + +CDeploymentComponent *CApplicationManagementServer::DoDataUpdateCheckL( + CDeploymentComponent &aCompo) + { + CDeploymentComponent *old= NULL; + if (aCompo.Uid() != TUid::Null() && HasUidL(aCompo.Uid(), old, &aCompo) ) + { + // check for Uid component.. Legacy code removed. + } + return old; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::SetDataL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::SetDataL(CDeploymentComponent &aCompo, + const TDesC8 &aData, const TDesC8 &aMime) + { + aCompo.SetDataL(aData, aMime); + DoDataUpdateCheckL(aCompo); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::FullUpdateL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::FullUpdateL(const TUint32 sid, + const TUint32 tid) + { + CDeploymentComponent &scompo = iStorage->ComponentL(sid); + CDeploymentComponent &tcompo = iStorage->ComponentL(tid); + FullUpdateL(scompo, tcompo); + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::FullUpdateL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::FullUpdateL(CDeploymentComponent &scompo, + const CDeploymentComponent &tcompo) + { + if (scompo.State() == EDCSDelivered) + { + if (tcompo.State() == EDCSActive || tcompo.State() == EDCSInactive) + { + TRequestStatus s2; + InstallL(scompo, s2); + User::WaitForRequest(s2); + if (s2 != KErrNone) + { + RDEBUG_2( "ApplicationManagementSession: FullUpdateL failed with code %d", s2.Int() ); + User::Leave(s2.Int() ); + } + else + { + InstallCompleteL(scompo); + // Before deleting old node ,copy node values which are not set in new node from old node + if (scompo.ComponentId()== KNullDesC8) + scompo.SetIdL(tcompo.ComponentId()); + + if (scompo.ComponentName()== KNullDesC8) + scompo.SetNameL(tcompo.ComponentName()); + + if (scompo.ComponentVersion()== KNullDesC8) + scompo.SetVersionL(tcompo.ComponentVersion()); + + //Tag tcompo state for deletion. Cant delete now, since nsmldmtree woudnt be updated + //Remove the const'ness since state needs to be updated. + + iStorage->SetDeploymentComponentState(const_cast (tcompo),EDCSDelete); + + iStorage->InstalledL( scompo ); + RDEBUG( "ApplicationManagementSession: FullUpdateL ok" ); + } + } + else + { + RDEBUG_2( "ApplicationManagementSession: ERROR FullUpdateL called for illegal state component: %d!", scompo.State() ); + User::Leave(KErrArgument); + } + } + else + { + RDEBUG( "ApplicationManagementSession: ERROR FullUpdateL called for illegal state message!" ); + User::Leave(KErrArgument); + } + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementServer::IsDataFileB64EncodedL() +// ------------------------------------------------------------------------------------------------------------------- +TBool CApplicationManagementServer::IsDataFileB64EncodedL(RFile &aFile, + TInt& aLength) + { + RDEBUG("CApplicationManagementServer::IsDataFileB64EncodedL() : start"); + TBool encoded = ETrue; // assume b64 encoded + TInt bufSize(KBase64BufSize); + TInt offset(0); + HBufC8 *dataBuf = HBufC8::NewLC(bufSize); + TPtr8 dataPtr = dataBuf->Des(); + aFile.Size(aLength); + aFile.Seek(ESeekStart, offset); + + while (encoded) + { + aFile.Read(dataPtr); + if ( !dataPtr.Length() ) + { + break; + } + offset = 0; + aFile.Seek(ESeekCurrent, offset); + RDEBUG_2("OFFSET: %d", offset); + encoded = CheckB64Encode(dataPtr); + } + RDEBUG_2("Encoded: %d", encoded); + CleanupStack::PopAndDestroy(dataBuf); + offset = 0; + aFile.Seek(ESeekStart, offset); + + RDEBUG("CApplicationManagementServer::IsDataFileB64EncodedL() : end"); + return encoded; + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementServer::CheckB64Encode( const TDesC8& aData ) +// ------------------------------------------------------------------------------------------------------------------- +TBool CApplicationManagementServer::CheckB64Encode(const TDesC8& aData) + { + TInt inputIndex = 0; + TInt inputLen = aData.Length(); + + while (inputIndex < inputLen) + { + const TUint8& p = aData[ inputIndex ]; + + if ((p >= 48 && p <= 57) || (p >= 65 && p <= 90) || (p >= 97 && p + <= 122) || p == 43 || p == 47 || p == 61 || p == 10 || p + == 13) + { + } + else + { + return EFalse; + } + + inputIndex++; + + } + + return ETrue; + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::GetAMServerDownloadDBL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::GetAMServerDownloadDBL(TUint32 internalid, + TInt& finalresult, TDes8& aTargetURI) + { + RDEBUG( "CApplicationManagementServer::GetAMServerDownloadDBL(): Step1" ); + + TBuf<50> internalidbuf; + + RDEBUG( "CApplicationManagementServer::GetAMServerDownloadDBL(): Step2" ); + internalidbuf.Num(internalid); + + RDEBUG( "CApplicationManagementServer::GetAMServerDownloadDBL(): Step3" ); + + RPointerArray aItemArray; + + RDEBUG( "CApplicationManagementServer::GetAMServerDownloadDBL(): Step4" ); + + iAMServerDB->GetEntryForLUIDL(aItemArray, internalidbuf); + + RDEBUG( "CApplicationManagementServer::GetAMServerDownloadDBL(): Step5" ); + + if (aItemArray.Count()!=0) + { + RDEBUG( "CApplicationManagementServer::GetAMServerDownloadDBL(): Step6" ); + + finalresult = aItemArray[0]->iResult; + + RDEBUG( "CApplicationManagementServer::GetAMServerDownloadDBL(): Step7" ); + + if (finalresult < KErrNone) + User::Leave(KErrGeneral); + + RDEBUG( "CApplicationManagementServer::GetAMServerDownloadDBL(): Step8" ); + + if (*aItemArray[0]->iTargetURI == KNullDesC8()) + User::Leave(KErrGeneral); + + RDEBUG( "CApplicationManagementServer::GetAMServerDownloadDBL(): Step9" ); + aTargetURI.Copy(*aItemArray[0]->iTargetURI); + + } + RDEBUG( "CApplicationManagementServer::GetAMServerDownloadDBL(): Step10" ); + aItemArray.ResetAndDestroy(); + + } + +// ------------------------------------------------------------------------------------------------ +// CApplicationManagementServer::DeleteGenericAlertForIDL() +// ------------------------------------------------------------------------------------------------ + +void CApplicationManagementServer::DeleteGenericAlertForIDL(TUint32 internalid) + { + iAMServerDB->DeleteFromDatabaseL(internalid); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementServer::DecodeB64DataFileL( RFile& aDataFile, RFile& aDestinationFile ) +// ------------------------------------------------------------------------------------------------------------------- +void CApplicationManagementServer::DecodeB64DataFileL(RFile& aSourceFile, + RFile& aDestinationFile) + { + RDEBUG( "CApplicationManagementServer::DecodeB64DataFileL(): Start" ); + // Create buffers + //TInt b64bufferSize = 131072; + TInt decodedBufferSize = ( (KBase64BufSize*3) / 4 + 16 ); + HBufC8 *dataBuf = HBufC8::NewLC(KBase64BufSize); + TPtr8 dataPtr = dataBuf->Des(); + HBufC8* targetBuf = HBufC8::NewLC(decodedBufferSize); + TPtr8 targetPtr(targetBuf->Des() ); + + TInt offset(0); + TInt length(0); + TBool reading(ETrue); + aSourceFile.Size(length); + RDEBUG_2( "CApplicationManagementServer::DecodeB64DataFileL(): b64 file total size: (%d)", length ); + aSourceFile.Seek(ESeekStart, offset); + + // Initialize decoder + TImCodecB64 B64Coder; + B64Coder.Initialise(); + + while (reading) + { + aSourceFile.Read(dataPtr); + if ( !dataPtr.Length() ) + { + // EOF + break; + } + offset = 0; + aSourceFile.Seek(ESeekCurrent, offset); + RDEBUG_2("OFFSET: %d", offset); + + // decode data + B64Coder.Decode(dataPtr, targetPtr); + // write decoded data to temporary file + aDestinationFile.Write(targetPtr); + } + CleanupStack::PopAndDestroy(targetBuf); + CleanupStack::PopAndDestroy(dataBuf); + + offset = 0; + aDestinationFile.Seek(ESeekStart, offset); + RDEBUG( "CApplicationManagementServer::DecodeB64DataFileL(): end" ); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementServer::DecodeB64DataLC( const TDesC8& aData ) +// ------------------------------------------------------------------------------------------------------------------- +HBufC8* CApplicationManagementServer::DecodeB64DataLC(const TDesC8 &aData) + { + RDEBUG( "CApplicationManagementServer::DecodeB64DataLC(): Start" ); + TImCodecB64 B64Coder; + B64Coder.Initialise(); + HBufC8 *target = HBufC8::NewLC( (aData.Length() * 3 ) / 4 + 16); + TPtr8 targetPtr(target->Des() ); + B64Coder.Decode(aData, targetPtr); + RDEBUG( "CApplicationManagementServer::DecodeB64DataLC(): End" ); + return target; + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementServer::EncodeDataL( const TDesC8& aData, CBufBase &aTarget ) +// ------------------------------------------------------------------------------------------------------------------- +void CApplicationManagementServer::EncodeDataL(const TDesC8& aData, + CBufBase &aTarget) + { + TInt outLen(aData.Length() * 2); + aTarget.ExpandL(0, outLen); + TImCodecB64 B64Coder; + B64Coder.Initialise(); + TPtr8 target(aTarget.Ptr(0) ); + TInt decoded(B64Coder.Encode(aData, target) ); + TInt s(target.Length() ); + aTarget.ResizeL(s); + // TInt s2( aTarget.Size()); + aTarget.Compress(); + // TInt s3( aTarget.Size() ); + if ( !decoded) + { + RDEBUG( "CApplicationManagementServer::EncodeDataL(): Encoding b64 failed?" ); + } + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::CApplicationManagementSession +// ------------------------------------------------------------------------------------------------------------------- +inline CApplicationManagementSession::CApplicationManagementSession() + { + RDEBUG_2( "CApplicationManagementSession::CApplicationManagementSession 0x%x", this); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::CApplicationManagementSession +// ------------------------------------------------------------------------------------------------------------------- + +inline CApplicationManagementSession::CApplicationManagementSession( + const TCertInfo &aInfo) : + iCertInfo(aInfo) + { + RDEBUG( "CApplicationManagementSession::CApplicationManagementSession (cert) " ); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::Server() +// ------------------------------------------------------------------------------------------------------------------- + +inline CApplicationManagementServer& CApplicationManagementSession::Server() const + { + return *static_cast( const_cast(CSession2::Server())); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::CreateL() +// ------------------------------------------------------------------------------------------------------------------- +// 2nd phase construct for sessions - called by the CServer framework + +void CApplicationManagementSession::CreateL() + { + RDEBUG_2( "ApplicationManagementSession: CApplicationManagementSession::CreateL: 0x%x", this ); + + Server().AddSession(); + CAknAppServiceBase::CreateL(); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::~CApplicationManagementSession() +// ------------------------------------------------------------------------------------------------------------------- + +CApplicationManagementSession::~CApplicationManagementSession() + { + RDEBUG_3("CApplicationManagementSession::~CApplicationManagementSession 0x%X - 0x%X", reinterpret_cast(this), + reinterpret_cast(this)+sizeof( CApplicationManagementSession ) ); + RDEBUG_2("CApplicationManagementSession::~CApplicationManagementSession iCertInfo offs 0x%X", + reinterpret_cast(&this->iCertInfo) - reinterpret_cast(this) ); + + Server().DropSession(); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::ServiceL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::ServiceL(const RMessage2& aMessage) + { + if (aMessage.Function() == EPerformRfs) + { + TRAPD( err, Server().PerformRFSL() ) + ; + aMessage.Complete(err); + } + else + { + TBool handled(EFalse); + TInt err(KErrNone); + TRAP( err, handled = PreDispatchMessageL( aMessage ) ); + if ( !handled) + { + TRAP(err,DispatchMessageL(aMessage)); + } + + // Some of the functions contains operations that already complete message + // doing Complete() twice will cause panic + if (aMessage.Handle() ) + { + aMessage.Complete(err); + } + } + } + +// CApplicationManagementSession::PreDispatchMessageL() +// ------------------------------------------------------------------------------------------------------------------- + +TBool CApplicationManagementSession::PreDispatchMessageL( + const RMessage2 &aMessage) + { + TBool ret(EFalse); + // These succeed regardless of certificate.... + switch (aMessage.Function() ) + { + case EGetStateChangingIdsCountOperation: + { + // gets count of items list of ids that are potentially changing state + StateChangeComponentIdsCountL(aMessage); + ret = ETrue; + break; + } + case EGetStateChangingIdsOperation: + { + // gets list of ids that are potentially changing state + StateChangeComponentIdsL(aMessage); + ret = ETrue; + break; + } + case ECompleteStateChangeOperation: // completes change of state + { + StateChangeCompleteL(aMessage); + ret = ETrue; + break; + } + default: + { + break; + } + } + return ret; + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::DispatchMessageL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::DispatchMessageL(const RMessage2& aMessage) + { + RDEBUG_2( "CApplicationManagementSession::DispatchMessageL; %d" , + aMessage.Function() ); + + TBool go(EFalse); + if (iTrustAdded) + { + go = Server().CheckCertL(iCertInfo); + } + else + { + go = ETrue; + } + + if (go) + { + switch (aMessage.Function() ) + { + case EAddTrust: + { + RDEBUG_2( "CApplicationManagementSession::DispatchMessageL; EAddTrust this=0x%x", this ); + AddTrustL(aMessage); + break; + } + case EDeplCompCountOperation: + { + ComponentCountL(aMessage); + return; + } + case EDeplCompIdsOperation: + { + ComponentIdsL(aMessage); + return; + } + case EDeplCompDeliverCompleteOperation: + { + DeliverCompleteL(aMessage); + break; + } + case EDeplCompGetOperation: + { + GetComponentL(aMessage) ; + break; + } + case EInstallOperation: + { + InstallL(aMessage) ; + break; + } + case EDeplCompAttrUpdateOperation: + { + UpdateL(aMessage) ; + break; + } + case EDeplCompGetDataOperation: + { + GetDataL(aMessage) ; + break; + } + case EDeplCompGetDataLengthOperation: + { + GetDataLengthL(aMessage) ; + break; + } + case EDeplCompRemoveOperation: + { + RemoveL(aMessage) ; + break; + } + case EDeplCompDeliverStartOperation2: + { + Deliver2L(aMessage) ; + break; + } + case EDeplCompUpdateDataOperation: + { + UpdateDataL(aMessage) ; + break; + } + case EDeplCompUpdateStreamedDataOperation: + { + UpdateStreamedDataL(aMessage) ; + break; + } + case EDeplCompDownloadOperation: + { + DownloadL(aMessage) ; + break; + } + case EDeplCompUpdateOperation: + { + FullUpdateL(aMessage) ; + break; + } + case EDeplCompGetUserIdOperation: + { + GetUserIdL(aMessage); + break; + } + case EDeplCompStartDownloadOperation: + { + StartDownloadL(aMessage); + break; + } + case EDeplCompDeactivateOperation: + { + DeactivateL(aMessage); + break; + } + case EDeplCompActivateOperation: + { + ActivateL(aMessage); + break; + } + case EDeplCompGetTemporaryInstFile: + { + GetTemporaryInstFileL(aMessage); + break; + } + + case EDeplCompGetFinalResultForGA: + { + GetFinalResultForGAL(aMessage); + break; + + } + case EDeplCompGenericAlertSent: + { + GenericAlertSentForIdL(aMessage); + break; + } + case ECheckStatusNodes: + { + CheckStatusNodesValuesL(); + break; + } + + default: + { + User::Leave(KErrNotSupported); + break; + } + } + } + else + { + RDEBUG_2( "CApplicationManagementSession::DispatchMessageL; Policy prevented action this=0x%x", this ); + User::Leave(KErrAccessDenied); + } + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::GenericAlertSentForIdL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::GenericAlertSentForIdL( + const RMessage2& aMessage) const + { + TUint32 luid; + TPckg pk(luid); + TInt read(aMessage.Read(0, pk)); + + Server().DeleteGenericAlertForIDL(luid); + + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::GetFinalResultForGAL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::GetFinalResultForGAL( + const RMessage2& aMessage) + { + + RDEBUG( "CApplicationManagementSession: GetFinalResultForGAL Step 1" ); + TUint32 luid; + TPckg pk(luid); + + TInt finalresult = KErrNone; + + RDEBUG( "CApplicationManagementSession: GetFinalResultForGAL Step 2" ); + + HBufC8 *targetURI = HBufC8::NewL(512); + TPtr8 ptr = targetURI->Des(); + + RDEBUG( "CApplicationManagementSession: GetFinalResultForGAL Step 3" ); + + TInt read(aMessage.Read(0, pk)); + + RDEBUG( "CApplicationManagementSession: GetFinalResultForGAL Step 4" ); + + Server().GetAMServerDownloadDBL(luid, finalresult, ptr); + + RDEBUG( "CApplicationManagementSession: GetFinalResultForGAL Step 5" ); + + RDEBUG_2( "ApplicationManagementServer: GetFinalResultForGAL Count is %d", finalresult ); + TPckg p1(finalresult); + aMessage.WriteL(1, p1); + + RDEBUG( "CApplicationManagementSession: GetFinalResultForGAL Step 6" ); + aMessage.WriteL(2, ptr); + + RDEBUG( "CApplicationManagementSession: GetFinalResultForGAL Step 7" ); + if (targetURI) + delete targetURI; + + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::ComponentCountL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::ComponentCountL(const RMessage2& aMessage) + { + RDEBUG( "CApplicationManagementSession: ComponentCountL" ); + TDeploymentComponentState st; + TPckg pk(st); + + TInt read(aMessage.Read( 1, pk) ); + RDEBUG_3( "CApplicationManagementSession: ComponentCountL State is %d, read %d", st, read); + + const RComponentIdArray &arrt = Server().Storage()->GetComponentIds(); + RComponentIdArray arr; + CleanupClosePushL(arr); + if ((st == EDCSActive)||(st == EDCSInactive)) + { + ActiveComponentsL(arrt, arr,st); + } + else + { + TInt count(arrt.Count() ); + for (TInt i( 0); i < count; i++) + { + CDeploymentComponent &compo = Server().Storage()->ComponentL(arrt[i]); + if (st == EDCSNone || compo.State() == st) + { + arr.Append(arrt[i]); + } + } + } + TInt n(arr.Count() ); + CleanupStack::PopAndDestroy( &arr); + + RDEBUG_2( "ApplicationManagementServer: ComponentCountL Count is %d", n ); + TPckg p(n); + + aMessage.WriteL(0, p); + + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::ActiveComponentsL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::ActiveComponentsL( + const RComponentIdArray &aArrt, RComponentIdArray &aArr,TDeploymentComponentState &aState) const + { + Swi::RSisRegistrySession sisses; + TInt r(sisses.Connect() ); + User::LeaveIfError(r) ; + CleanupClosePushL(sisses); + + RArray uids; + sisses.InstalledUidsL(uids); + CleanupClosePushL(uids); + TInt cont(aArrt.Count() ); + TInt uidc(uids.Count() ); + RArray juids; + Server().JavaUidsL(juids); + CleanupClosePushL(juids); + TInt juidc(juids.Count() ); + RComponentIdArray rem; + CleanupClosePushL(rem); + for (TInt i( 0); i < cont; i++) + { + CDeploymentComponent &compo = Server().Storage()->ComponentL(aArrt[i]); + TDeploymentComponentState state = compo.State(); + if (state == aState) + { + TBool add(EFalse); + const TUid &uid(compo.Uid() ); + for (TInt j( 0); add == EFalse && j < uidc; j++) + { + + if (uids[j] == uid) + { + + RDEBUG( "CApplicationManagementSession::ActiveComponentsL Entered" ); + + // Check if this registry entry is present + Swi::RSisRegistrySession sisSession; + User::LeaveIfError(sisSession.Connect()); + CleanupClosePushL(sisSession); + + Swi::RSisRegistryEntry sisEntry; + + //Opens the base package entry by specifying a UID. + User::LeaveIfError(sisEntry.Open(sisSession, compo.Uid())); + CleanupClosePushL(sisEntry); + + add = sisEntry.IsPresentL(); + + if(add) + RDEBUG( "CApplicationManagementSession::ActiveComponentsL ETrue" ); + else + RDEBUG( "CApplicationManagementSession::ActiveComponentsL EFalse" ); + + + CleanupStack::PopAndDestroy(2, &sisSession); + + } + } + if ( !add) // go throug java suites + { + for (TInt k( 0); add == EFalse && k < juidc; k++) + { + if (juids[k] == uid) + { + add = ETrue; + } + } + } + if (add) + { + aArr.Append(aArrt[i]); + } + else + { + RDEBUG8_3( "ApplicationManagementServer: ActiveComponentCountL skipping 0x%x, %S", + compo.Uid() ,&compo.ComponentId() ); + rem.Append(aArrt[i]); + } + } + } + TInt rc(rem.Count() ); + for (TInt t( 0); t < rc; t++) + { + RDEBUG_2( "ApplicationManagementServer: ActiveComponentCountL removing non existing %d", rem[t] ); + CDeploymentComponent &compo = Server().Storage()->ComponentL(rem[t]); + if(!compo.AppRemovable()) + Server().RemoveInternalL(compo, EFalse); + } + CleanupStack::PopAndDestroy( &rem); + CleanupStack::PopAndDestroy( &juids); + CleanupStack::PopAndDestroy( &uids); + CleanupStack::PopAndDestroy( &sisses); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::ComponentIdsL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::ComponentIdsL(const RMessage2& aMessage) const + { + RDEBUG( "CApplicationManagementSession: ComponentIdsL" ); + TDeploymentComponentState st; + TPckg pk(st); + + TInt read(aMessage.Read( 1, pk) ); + RDEBUG_3( "CApplicationManagementSession: ComponentIdsL State is %d, read %d", st, read); + + const RComponentIdArray &arrt = Server().Storage()->GetComponentIds(); + TInt buflen( 0); + TUint32* buf= NULL; + if (st == EDCSNone) + { + buflen = arrt.Count() ; + buf = new ( ELeave ) TUint32[buflen]; + CleanupArrayDeletePushL(buf); + for (TInt i( 0); i < buflen; i++) + { + RDEBUG_2("ApplicationManagementSession: ComponentIdsL Adding %d!!", arrt[i]); + buf[i] = arrt[i]; + } + } + else + { + RComponentIdArray arr; + if (st == EDCSActive) + { + ActiveComponentsL(arrt, arr,st); + } + else + { + TInt artc(arrt.Count() ); + for (TInt i( 0); i < artc; i++) + { + CDeploymentComponent &compo = Server().Storage()->ComponentL(arrt[i]); + if (compo.State() == st) + { + arr.Append(arrt[i]); + } + } + } + buflen = arr.Count() ; + buf = new ( ELeave ) TUint32[buflen]; + CleanupArrayDeletePushL(buf); + + TUint32 len(aMessage.GetDesMaxLength( 0) / 4); + if (buflen == len) + { + RDEBUG( "CApplicationManagementSession: ComponentIdsL Right count!!" ); + } + else + { + RDEBUG_3( "CApplicationManagementSession: ComponentIdsL Wrong count (is %d, should be %d)!!", len, buflen); + if (len < buflen) + { + buflen = len; + } + } + for (TInt i( 0); i < buflen; i++) + { + RDEBUG_2( "CApplicationManagementSession: ComponentIdsL Adding %d!!", + arr[i] ); + buf[i] = arr[i]; + } + arr.Close(); + } + + TPtrC8 p( ( TUint8* ) buf, buflen * sizeof(TUint32)); + aMessage.WriteL( 0, p); + + CleanupStack::PopAndDestroy(buf); + } + +#ifdef _DEBUG +HBufC* Des8to16LC(const TDesC8 &aDes) + { + HBufC *b = HBufC::NewLC(aDes.Length() ); + TPtr p(b->Des() ); + p.Copy(aDes); + return b; + } + +HBufC* ToStringLC(TDeploymentComponent &aComp) + { + HBufC *b = HBufC::NewLC(aComp.iId.Length() + aComp.iName.Length() + + aComp.iVersion.Length() + 10 + 50); + TPtr p(b->Des() ); + _LIT( KFormat, "Id: '%S', Name: '%S', Version: '%S', State: %d, OldState: %d"); + p.Format(KFormat, &*Des8to16LC(aComp.iId), &*Des8to16LC(aComp.iName), + &*Des8to16LC(aComp.iVersion), aComp.iState, aComp.iOldState) ; + CleanupStack::PopAndDestroy( 3); + return b; + } +#endif + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::Deliver2L() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::Deliver2L(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: Deliver2L" ); + + TDeploymentComponentIPC comp; + TPckg< TDeploymentComponentIPC> pcomp(comp); + TInt read2(aMessage.Read( 0, pcomp) ); + + HBufC8 *data = HBufC8::NewLC(aMessage.GetDesLength( 1) ); + TPtr8 pbuf(data->Des()); + TInt read(aMessage.Read( 1, pbuf) ); + + CDeploymentComponent *compo= NULL; + if (iTrustAdded) + { + compo = Server().Storage()->NewComponentL(EDCSDelivered, comp.iUserId, &iCertInfo); + } + else + { + compo = Server().Storage()->NewComponentL(EDCSDelivered, comp.iUserId); + } + + compo->Set(comp.iComponent); + compo->Data().SetDataL(pbuf, comp.iMimeType); + Server().Storage()->UpdateL( *compo); + compo->CopyStateTo(comp.iComponent); + +#ifdef _DEBUG + RDEBUG_2( "Deliver2L: TDeploymentComponent is '%S'", + ToStringLC( comp.iComponent ) ); + CleanupStack::PopAndDestroy(); +#endif + + TPckg< TDeploymentComponent> pcomp2(comp.iComponent); + aMessage.Write( 0, pcomp2); + CleanupStack::PopAndDestroy(data) ; + TInt n(compo->InternalId() ); + TPckg p(n); + aMessage.WriteL( 2, p); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::DeliverCompleteL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::DeliverCompleteL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: DeliverCompleteL" ); + TUint32 id; + TPckg pid(id); + + TInt read(aMessage.Read( 0, pid) ); + RDEBUG_2( "ApplicationManagementSession: DeliverCompleteL id is %d", id ); + + CDeploymentComponent &compo = Server().Storage()->ComponentL(id); + + HBufC8 *opts = HBufC8::NewLC(aMessage.GetDesLength( 1) ); + TPtr8 popts(opts->Des() ); + TInt read1(aMessage.Read( 1, popts) ); + compo.SetInstallOptsL( *opts); + + HBufC8 *meta = HBufC8::NewLC(aMessage.GetDesLength( 2) ); + TPtr8 pmeta(meta->Des() ); + TInt read2(aMessage.Read( 2, pmeta) ); + compo.SetMetaDataL( *meta, KNullDesC8); + + CleanupStack::PopAndDestroy(meta) ; + CleanupStack::PopAndDestroy(opts) ; + Server().Storage()->UpdateL(compo); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::GetComponentL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::GetComponentL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: GetComponentL" ); + TUint32 id; + TPckg pid(id); + TInt read(aMessage.Read( 0, pid) ); + + RDEBUG_2( "ApplicationManagementSession: GetComponentL id is %d", id ); + CDeploymentComponent &compo = Server().Storage()->ComponentL(id); + + TDeploymentComponent comp; + compo.CopyStateTo(comp); + + TPckg< TDeploymentComponent> pcomp(comp); + aMessage.Write( 1, pcomp); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::StartDownloadL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::StartDownloadL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: StartDownloadL" ); + TUint32 id = 0; + TPckg pid(id); + TInt read(aMessage.Read( 0, pid) ); + + TPckgBuf target; + read = aMessage.Read( 1, target) ; + RDEBUG_2( "ApplicationManagementSession: StartDownloadL id is %d", id ); + + CDeploymentComponent &compo = Server().Storage()->ComponentL(id); + compo.SetDownloadTarget(target() ); + Server().AddDownloadL( &compo); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::DeactivateL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::DeactivateL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: DeactivateL" ); + TUint32 id = 0; + TPckg pid(id); + TInt read(aMessage.Read( 0, pid) ); + + RDEBUG_2( "ApplicationManagementSession: DeactivateL id is %d", id ); + CDeploymentComponent &compo = Server().Storage()->ComponentL(id); + Server().Storage()->DeactivateL(compo); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::ActivateL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::ActivateL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: ActivateL" ); + TUint32 id; + TPckg pid(id); + TInt read(aMessage.Read( 0, pid) ); + + RDEBUG_2( "ApplicationManagementSession: ActivateL id is %d", id ); + CDeploymentComponent &compo = Server().Storage()->ComponentL(id); + Server().Storage()->ActivateL(compo); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::GetUserIdL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::GetUserIdL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: GetUserIdL" ); + TUint32 id = 0; + TPckg pid(id); + TInt read(aMessage.Read( 0, pid) ); + + RDEBUG_2( "ApplicationManagementSession: GetUserIdL id is %d", id ); + CDeploymentComponent &compo = Server().Storage()->ComponentL(id); + + aMessage.Write( 1, compo.UserId() ); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::GetTemporaryInstFileL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::GetTemporaryInstFileL( + const RMessage2& aMessage) const + { + // TIpcArgs( &id, &itemid, &filehandle ) + RDEBUG( "ApplicationManagementSession: GetTemporaryInstFileL" ); + TUint32 id; + TPckg pid(id); + TInt read(aMessage.Read( 0, pid) ); + + TDeplCompAttrType item; + TPckg itemid(item); + read = aMessage.Read( 1, itemid); + + RDEBUG_2( "ApplicationManagementSession: GetTemporaryInstFileL id is %d", id ); + CDeploymentComponent &compo = Server().Storage()->ComponentL(id); + + TFileName fileName; + + if (item == EDCData) + { + fileName.Copy(compo.Data().DataFileName() ); + } + else + if (item == EDCMetaData) + { + fileName.Copy(compo.MetaData().DataFileName() ); + } + else + { + RDEBUG_2( "ApplicationManagementSession: GetTemporaryInstFileL: Not supported type: (%d)", item); + User::Leave(KErrNotSupported); + } + + RDEBUG_2( "ApplicationManagementSession: GetTemporaryInstFileL: (%S)", &fileName); + + RFs fs; + User::LeaveIfError(fs.Connect() ); + User::LeaveIfError(fs.ShareProtected() ); + CleanupClosePushL(fs); + RFile file; + User::LeaveIfError(file.Open(fs, fileName, EFileWrite) ); + CleanupClosePushL(file); + + // Takes care of completing with session (RFs), + // SendReceieve returns session handle at client side + User::LeaveIfError(file.TransferToClient(aMessage, 2) ); + CleanupStack::PopAndDestroy(2, &fs); // fs , file + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::PackageSizeL() +// ------------------------------------------------------------------------------------------------------------------- + +TInt CApplicationManagementSession::PackageSizeL( + Swi::RSisRegistrySession& aSession, Swi::RSisRegistryEntry& aEntry) + { + RPointerArray listPackages; + TInt size(0); + TInt err(0); + CleanupClosePushL(listPackages); + + aEntry.AugmentationsL(listPackages); + + for (TInt index(0); index < listPackages.Count(); index++) + { + TRAP(err, AugmentationSizeL( aSession, *listPackages[index])) + if (err != KErrNone) + { + break; + } + } + + if (err != KErrNone) + { + size = 0; + } + else + { + TRAP(err, size += aEntry.SizeL() ); + } + + listPackages.ResetAndDestroy(); + CleanupStack::PopAndDestroy( &listPackages); + + if (err != KErrNone) + { + //We leave if there was an error, + // but we have to clean up the listPackages before the leave. + User::Leave(err); + } + + return size; + } + +// ------------------------------------------------------------------------------------------------ +// CAppMngrSisxInfo::AugmentationSizeL() +// Returns the Size of the package +// (other items were commented in a header). +// ------------------------------------------------------------------------------------------------ +// +TInt CApplicationManagementSession::AugmentationSizeL( + Swi::RSisRegistrySession& aSession, + const Swi::CSisRegistryPackage& aPackage) + { + TInt size(0); + Swi::RSisRegistryEntry regEntry; + CleanupClosePushL(regEntry); + + regEntry.OpenL(aSession, aPackage); + size += PackageSizeL(aSession, regEntry); + + CleanupStack::PopAndDestroy( ®Entry); + + return size; + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::LookupSisRegistryL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::LookupSisRegistryL() + { + Swi::RSisRegistrySession sisses; + TInt r(sisses.Connect() ); + RPointerArray pkgs(12); + sisses.InstalledPackagesL(pkgs); + + TInt count(pkgs.Count() ); + for (TInt i( 0); i < count; i++) + { + Swi::CSisRegistryPackage* p = pkgs[i]; + + RDEBUG_5(" Found package: %d, '%S', uid: 0x%X, size: %d" , + i, &p->Name(), p->Uid().iUid, AugmentationSizeL( sisses, *p ) ); + } + + sisses.Close(); + pkgs.ResetAndDestroy(); + + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::InstallL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::InstallL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: InstallL" ); + TUint32 id; + TPckg pid(id); + TInt read(aMessage.Read( 0, pid) ); + + TDeploymentComponentState targetst; + TPckg pk(targetst); + + read = aMessage.Read( 1, pk) ; + + RDEBUG_3( "ApplicationManagementSession: InstallL id is %d, targetstate %d", + id, targetst ); + + CDeploymentComponent &compo = Server().Storage()->ComponentL(id); + if (compo.State() == EDCSDelivered) + { + Server().DoTheInstallL(compo) ; + } + else + { + User::Leave(KErrArgument); + } + RDEBUG_2( "ApplicationManagementSession: InstallL success. New compo state (%d)", compo.State()); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::UpdateDataL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::UpdateDataL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: UpdateDataL" ); + + TDeplCompDataIPC ipc; + TPckg pipc(ipc); + TInt read(aMessage.Read( 0, pipc) ); + RDEBUG_2( "ApplicationManagementSession: UpdateDataL id is %d", ipc.iInternalId ); + + HBufC8 *buf = HBufC8::NewLC(aMessage.GetDesLength( 1) ); + TPtr8 pbuf(buf->Des() ); + TInt read2(aMessage.Read( 1, pbuf) ); + + CDeploymentComponent &compo = Server().Storage()->ComponentL(ipc.iInternalId); + + if (Server().CheckB64Encode(pbuf) ) + { + RDEBUG( "ApplicationManagementSession: UpdateDataL data is base64 encoded"); + // b64 encoded data, decode it + HBufC8* tmp; + tmp = Server().DecodeB64DataLC(pbuf); + pbuf.Copy( *tmp); + pbuf = buf->Des(); + CleanupStack::PopAndDestroy(tmp); + } + + if (compo.State() == EDCSDelivered) + { + if (ipc.iAttrType == EDCData) + { + compo.SetDataL(pbuf, ipc.iDataMime); + } + else + if (ipc.iAttrType == EDCMetaData) + { + compo.SetMetaDataL(pbuf, ipc.iDataMime); + } + else + { + RDEBUG_2( "ApplicationManagementSession::UpdateDataL - ERROR UpdateDataL called for illegal item: %d!", ipc.iAttrType ); + User::Leave(KErrArgument); + } + + Server().Storage()->UpdateL(compo); + } + else + { + RDEBUG( "ApplicationManagementSession::UpdateDataL - ERROR UpdateDataL called for illegal state message!" ); + User::Leave(KErrArgument); + } + CleanupStack::PopAndDestroy(buf); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::UpdateStreamedDataL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::UpdateStreamedDataL( + const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: UpdateStreamedDataL() Start"); + TDeplCompDataIPC ipc; + TPckg pipc(ipc); + TInt read(aMessage.Read( 0, pipc) ); + RDEBUG_2( "ApplicationManagementSession: UpdateStreamedDataL id is %d", ipc.iInternalId ); + + CDeploymentComponent &compo = Server().Storage()->ComponentL(ipc.iInternalId); + + if (compo.State() == EDCSDelivered) + { + RFs fs; + User::LeaveIfError(fs.Connect() ); + CleanupClosePushL(fs); + RFile file; + TFileName dataFileName; + TInt length(0); + + if (ipc.iAttrType == EDCData) + { + dataFileName.Copy(compo.Data().DataFileName() ) ; + } + else + if (ipc.iAttrType == EDCMetaData) + { + dataFileName.Copy(compo.MetaData().DataFileName() ) ; + } + else + { + RDEBUG_2( "ApplicationManagementSession::UpdateStreamedDataL - ERROR called for illegal item: %d!", ipc.iAttrType ); + User::Leave(KErrArgument); + } + + RDEBUG_2( "ApplicationManagementSession::UpdateStreamedDataL(): using dataFile: (%S)", &dataFileName ); + + // EFileWrite So we can delete the original decoded data file + User::LeaveIfError(file.Open(fs, dataFileName, EFileWrite) ); + CleanupClosePushL(file) ; + if (Server().IsDataFileB64EncodedL(file, length) ) + { + RDEBUG( "CApplicationManagementServer::UpdateStreamedDataL(): data is decoded" ); + + TFileName tempFileName; + TBuf<30> privatePath; + fs.PrivatePath(privatePath); + RFile tempFile; + TInt err(KErrNone); + err = tempFile.Temp(fs, privatePath, tempFileName, EFileWrite); + if (err == KErrNone) + { + RDEBUG_2( "ApplicationManagementSession::UpdateStreamedDataL(): created tempFile: (%S)", &tempFileName ); + } + else + { + User::Leave(err); + } + CleanupClosePushL(tempFile); + + TRAP( err, Server().DecodeB64DataFileL( file, tempFile ) ); + if (err != KErrNone) + { + RDEBUG_2( "ApplicationManagementSession::UpdateStreamedDataL - failed to decode datafile: %d", err ); + CleanupStack::PopAndDestroy( 2, &file); + compo.ResetDataL(fs); // Remove both files if exists + User::Leave(err); + } + else + { + // close both files, delete decode file and rename temp file to correct one + CleanupStack::PopAndDestroy( 2, &file); + fs.Delete(dataFileName); + err = fs.Rename(tempFileName, dataFileName); + RDEBUG_2( "ApplicationManagementSession::UpdateStreamedDataL - successfully decoded datafile: %d", err ); + } + CleanupStack::PopAndDestroy( &fs); + } + else + { + RDEBUG( "ApplicationManagementSession::UpdateStreamedDataL(): data is NOT decoded" ); + CleanupStack::PopAndDestroy( 2, &fs); + } + + if (ipc.iAttrType == EDCData) + { + compo.SetDataL(ipc.iDataMime); + } + else + { + compo.SetMetaDataL(ipc.iDataMime); + } + + Server().Storage()->UpdateL(compo); + } + else + { + RDEBUG( "ApplicationManagementSession::UpdateStreamedDataL - ERROR called for illegal state message!" ); + User::Leave(KErrArgument); + } + RDEBUG( "ApplicationManagementSession: UpdateStreamedDataL() End"); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::UpdateL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::UpdateL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: UpdateL" ); + + TUint32 id; + TPckg pid(id); + TInt read(aMessage.Read( 0, pid) ); + RDEBUG_2("ApplicationManagementSession: UpdateL id is %d", id ); + + TDeplCompAttrType item; + TPckg itemid(item); + TInt read1(aMessage.Read( 1, itemid) ); + HBufC8 *buf = HBufC8::NewLC(aMessage.GetDesLength( 2) ); + TPtr8 pbuf(buf->Des() ); + TInt read2(aMessage.Read( 2, pbuf) ); + + CDeploymentComponent &c = Server().Storage()->ComponentL(id); + TDeploymentComponentState st(c.State() ); + if (st == EDCSDelivered || st == EDCSDownload) + { + switch (item) + { + case EDCId: + { + c.SetIdL(pbuf); + break; + } + case EDCName: + { + c.SetNameL(pbuf); + break; + } + case EDCVersion: + { + c.SetVersionL(pbuf); + break; + } + case EDCDescriptionRef: + { + c.SetDescriptionL(pbuf); + break; + } + case EDCInstallOptions: + { + c.SetInstallOptsL(pbuf); + break; + } + case EDCMetaData: + { + c.SetMetaDataL(pbuf, KNullDesC8); + break; + } + case EDCPkgID: + { + c.SetPkgIDL(pbuf); + break; + } + case EDCPkgType: + { + c.SetPkgTypeL(pbuf); + break; + } + + default: + { + if (st == EDCSDelivered) + { + switch (item) + { + case EDCData: + { + c.SetDataL(pbuf, KNullDesC8); + if (c.State() == EDCSDownload) + { + // Server().StartDownload( *compo ); + } + break; + } + default: + { + RDEBUG_2("ApplicationManagementSession: ERROR UpdateL called for illegal item type!!!! %d", item ); + User::Leave(KErrArgument); + } + } + } + else + if (st == EDCSDownload) + { + switch (item) + { + case EDCId: + { + c.SetIdL(pbuf); + break; + } + case EDCName: + { + c.SetNameL(pbuf); + break; + } + case EDCVersion: + { + c.SetVersionL(pbuf); + break; + } + case EDCDownloadURI: + { + c.SetDownloadURIL(pbuf); + break; + } + case EDCConRef: + { + TPckgBuf aInt; + aInt.Copy(pbuf); + c.SetIAPL(aInt() ); + break; + } + default: + { + RDEBUG_2( "ApplicationManagementSession: ERROR UpdateL called for illegal item type!!!! %d", item ); + User::Leave(KErrArgument); + break; + } + } + } + break; + } + } + Server().Storage()->UpdateL(c); + } + else + if (st == EDCSActive ||st == EDCSInactive) + { + switch (item) + { + case EDCName: + { + c.SetNameL(pbuf); + break; + } + case EDCVersion: + { + c.SetVersionL(pbuf); + break; + } + case EDCDescriptionRef: + { + c.SetDescriptionL(pbuf); + break; + } + default: + { + RDEBUG_2( "ApplicationManagementSession: ERROR UpdateL called for illegal item type!!!! %d", item ); + User::Leave(KErrArgument); + break; + } + } + Server().Storage()->UpdateL(c); + } + else + { + RDEBUG( "ApplicationManagementSession: ERROR UpdateL called for illegal state message!" ); + User::Leave(KErrArgument); + } + CleanupStack::PopAndDestroy(buf); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::GetDataLengthL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::GetDataLengthL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: GetDataLengthL" ); + TUint32 id; + TPckg pid(id); + + TInt read(aMessage.Read( 0, pid) ); + + TInt length( 0); + + TDeplCompAttrType dt; + TPckg< TDeplCompAttrType> pdt(dt); + read = aMessage.Read( 1, pdt) ; + CDeploymentComponent &compo = Server().Storage()->ComponentL(id); + if (compo.State() == EDCSDelivered) + { + if (dt == EDCInstallOptions) + { + if (compo.InstallOptsSet() ) + { + length = sizeof(TAMInstallOptions); + } + } + else + if (dt == EDCData) + { + length = compo.Data().DataLengthL(); + } + else + if (dt == EDCDataMime) + { + length = compo.Data().MimeType().Length(); + } + else + if (dt == EDCMetaData) + { + length = compo.MetaData().DataLengthL(); + } + else + if (dt == EDCMetaDataMime) + { + length = compo.MetaData().MimeType().Length(); + } + else + { + RDEBUG_2( "ApplicationManagementSession: GetDataLengthL ERROR called with illegal type %d", dt ); + User::Leave(KErrArgument); + } + } + else + if (compo.State() == EDCSDownload) + { + if (dt == EDCDownloadURI) + { + length = compo.DownloadURI().Length(); + } + else + if (dt == EDCInstallOptions) + { + if (compo.InstallOptsSet() ) + { + length = sizeof(TAMInstallOptions); + } + } + else + { + RDEBUG_2( "ApplicationManagementSession: GetDataLengthL ERROR Download / called with illegal state component id %d", + compo.State() ); + User::Leave(KErrArgument); + } + } + else + { + RDEBUG_2( "ApplicationManagementSession: GetDataLengthL ERROR called with illegal state component id %d", + compo.State() ); + User::Leave(KErrArgument); + } + + TPckg< TInt> pcomp(length); + aMessage.Write( 2, pcomp); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::GetDataL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::GetDataL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: GetDataL" ); + TUint32 id; + TPckg pid(id); + + TInt read(aMessage.Read( 0, pid) ); + + TDeplCompAttrType dt; + TPckg< TDeplCompAttrType> pdt(dt); + read = aMessage.Read( 1, pdt) ; + + RDEBUG_3( "ApplicationManagementSession: GetDataL id is %d, and attribute %d", id, dt ); + CDeploymentComponent &compo = Server().Storage()->ComponentL(id); + if (dt == EDCStatus) + { + TPckg p(compo.Status() ); + aMessage.Write( 2, p); + } + else + if (compo.State() == EDCSDelivered) + { + if (dt == EDCInstallOptions) + { + if (compo.InstallOptsSet() ) + { + TAMInstallOptionsPckgBuf pckg(compo.InstallOpts() ); + aMessage.Write( 2, pckg); + } + else + { + aMessage.Write( 2, KNullDesC8); + } + } + else + if (dt == EDCData) + { + aMessage.Write( 2, compo.Data().Data() ); + } + else + if (dt == EDCDataMime) + { + aMessage.Write( 2, compo.Data().MimeType() ); + } + else + if (dt == EDCMetaData) + { + aMessage.Write( 2, compo.MetaData().Data() ); + } + else + if (dt == EDCMetaDataMime) + { + aMessage.Write( 2, compo.MetaData().MimeType() ); + } + else + { + RDEBUG_2( "ApplicationManagementSession: GetDataL ERROR called with illegal type %d", dt ); + User::Leave(KErrArgument); + } + } + else + if (compo.State() == EDCSDownload) + { + + if (dt == EDCDownloadURI) + { + aMessage.Write( 2, compo.DownloadURI() ); + } + + else + if (dt == EDCInstallOptions) + { + if (compo.InstallOptsSet() ) + { + TAMInstallOptionsPckgBuf + pckg(compo.InstallOpts() ); + aMessage.Write( 2, pckg); + } + else + { + aMessage.Write( 2, KNullDesC8); + } + } + else + if (dt == EDCConRef) + { + TPckg p(compo.GetIAP() ); + aMessage.Write( 2, p); + } + else + { + RDEBUG_2( "ApplicationManagementSession:GetDataL ERROR called with illegal type %d", dt ); + User::Leave(KErrArgument); + } + } + else + { + RDEBUG_2("ApplicationManagementSession: GetDataL ERROR called with illegal state component id %d", compo.State() ); + User::Leave(KErrArgument); + } + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::RemoveL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::RemoveL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: RemoveL" ); + TUint32 id; + TPckg pid(id); + TInt read(aMessage.Read( 0, pid) ); + RDEBUG_2( "ApplicationManagementSession: RemoveL id is %d", id ); + RemoveInternalL(id); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::RemoveInternalL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::RemoveInternalL(const TUint32 &aId) const + { + CDeploymentComponent &compo = Server().Storage()->ComponentL(aId); + + Server().RemoveInternalL(compo); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::DownloadL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::DownloadL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: DownloadL" ); + + TDCUserId userId; + aMessage.ReadL( 1, userId); + CDeploymentComponent *compo= NULL; + + if (iTrustAdded) + { + compo = Server().Storage()->NewComponentL(EDCSDownload, userId, &iCertInfo); + } + else + { + compo = Server().Storage()->NewComponentL(EDCSDownload, userId); + } + TUint32 i(compo->InternalId() ); + TPckg p(i); + aMessage.WriteL(0, p); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::FullUpdateL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::FullUpdateL(const RMessage2& aMessage) const + { + RDEBUG( "ApplicationManagementSession: FullUpdateL" ); + + TUint32 sid; + + TPckg psid(sid); + TInt read(aMessage.Read( 0, psid) ); + TUint32 tid; + TPckg ptid(tid); + TInt read2(aMessage.Read( 1, ptid) ); + + RDEBUG_3( "ApplicationManagementSession: FullUpdateL sid is %d, tid is %d", sid, tid ); + CApplicationManagementServer &server = Server(); + server.FullUpdateL(sid, tid); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::ServiceError() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::ServiceError(const RMessage2& aMessage, + TInt aError) + { + RDEBUG_2( "ApplicationManagementSession: CApplicationManagementSession::ServiceError %d", aError); + CSession2::ServiceError(aMessage, aError); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::AddTrustL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::AddTrustL(const RMessage2 &aMessage) + { + TPckg pkg(iCertInfo); + aMessage.ReadL( 0, pkg); + iTrustAdded = ETrue; + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::StateChangeComponentIdsL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::StateChangeComponentIdsL( + const RMessage2& aMessage) const + { + RDEBUG( "CApplicationManagementSession: StateChangeComponentIdsL" ); + RComponentIdArray arr; + Server().Storage()->GetStateChangeComponentIdsL(arr); + TInt buflen(arr.Count() ); + TUint32* buf = new ( ELeave ) TUint32[buflen]; + CleanupArrayDeletePushL(buf); + for (TInt i( 0); i < buflen; i++) + { + RDEBUG_2( "ApplicationManagementSession:ComponentIdsL Adding %d!!", arr[i]); + buf[i] = arr[i]; + } + TPtrC8 p( ( TUint8* ) buf, buflen * sizeof(TUint32)); + aMessage.WriteL( 0, p); + arr.Close(); + CleanupStack::PopAndDestroy(buf); + RDEBUG( "CApplicationManagementSession: StateChangeComponentIdsL end" ); + + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::StateChangeComponentIdsCountL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::StateChangeComponentIdsCountL( + const RMessage2& aMessage) const + { + RDEBUG( "CApplicationManagementSession: StateChangeComponentIdsCountL" ); + RPointerArray preInstalledAppParams; + CAMPreInstallApp* preInstallApp = CAMPreInstallApp::NewL(); + preInstallApp->GetPreInstalledAppsL(preInstalledAppParams); + TInt count = 0; + for (count = 0; count< preInstalledAppParams.Count(); count++) + { + RDEBUG8_2("CApplicationManagementSession::DownloadL: Installed App Name is: %S",&(preInstalledAppParams[count]->iPreInstalledAppame)); + RDEBUG8_2("CApplicationManagementSession::DownloadL: Installed App Vendor is: %S",&(preInstalledAppParams[count]->iPreInstalledAppVendorName)); + RDEBUG_2("CApplicationManagementSession::DownloadL: Installed App UID is : '0x%X'",preInstalledAppParams[count]->iPreInstalledAppUid); + + TBool found = EFalse; + const RComponentIdArray &arrt = Server().Storage()->GetComponentIds(); + TInt countval(arrt.Count() ); + for (TInt i( 0); i < countval; i++) + { + CDeploymentComponent &compo = Server().Storage()->ComponentL(arrt[i]); + if (compo.Uid()== preInstalledAppParams[count]->iPreInstalledAppUid) + { + RDEBUG( "CApplicationManagementSession: ActiveComponentsL found= TRUE" ); + found = ETrue; + } + } + if (!found) + { + RDEBUG( "CApplicationManagementSession: Adding Pre-installed app" ); + TDCUserId preInstalledAppName; + preInstalledAppName.Copy(preInstalledAppParams[count]->iPreInstalledAppame); + CDeploymentComponent *preInstallCompo= NULL; + RDEBUG8_2("CApplicationManagementSession: Installed App Name is: %S",&preInstalledAppName); + preInstallCompo = Server().Storage()->NewComponentL(EDCSActive, preInstalledAppName); + preInstallCompo->SetUid(preInstalledAppParams[count]->iPreInstalledAppUid); + preInstallCompo->SetNameL(preInstalledAppName); + preInstallCompo->SetVersionL(preInstalledAppParams[count]->iVersion); + preInstallCompo->SetMimeTypeL(preInstalledAppParams[count]->iMimeType); + Server().Storage()->UpdateL( *preInstallCompo ); + Server().Storage()->CheckForDuplicateNodesInDeployedL(*preInstallCompo); + } + } + delete preInstallApp; + RComponentIdArray arr; + Server().Storage()->GetStateChangeComponentIdsL(arr); + TPckgBuf buflen(arr.Count() ); + aMessage.WriteL( 0, buflen); + arr.Close(); + RDEBUG( "CApplicationManagementSession: StateChangeComponentIdsCountL end" ); + } + +// ------------------------------------------------------------------------------------------------------------------- +// CApplicationManagementSession::StateChangeCompleteL() +// ------------------------------------------------------------------------------------------------------------------- + +void CApplicationManagementSession::StateChangeCompleteL( + const RMessage2& aMessage) const + { + RDEBUG( "CApplicationManagementSession: StateChangeCompleteL" ); + TUint32 tid; + TPckg ptid(tid); + TInt read2(aMessage.Read( 0, ptid) ); + Server().Storage()->StateChangedL(tid); + } +void CApplicationManagementSession::CheckStatusNodesValuesL() + { + const RComponentIdArray &arrt = Server().Storage()->GetComponentIds(); + TInt cont(arrt.Count() ); + TBool isUpdateRequired = ETrue; + for (TInt i( 0); i < cont; i++) + { + CDeploymentComponent &compo = Server().Storage()->ComponentL(arrt[i]); + isUpdateRequired = EFalse; + if (compo.Status() == EDownload_DownloadProgress) + { + compo.SetStatusNode(EDownload_DownloadFailed); + isUpdateRequired = ETrue; + } + else + if (compo.Status() == EDelivered_InstallProgress) + { + compo.SetStatusNode(EDelivered_InstalledFailedWithData); + isUpdateRequired = ETrue; + } + else + if (compo.Status() == EDelivered_RemoveProgress) + { + compo.SetStatusNode(EDelivered_RemoveFailed); + isUpdateRequired = ETrue; + } + else + if (compo.Status() == EDeployed_RemoveProgress) + { + compo.SetStatusNode(EDeployed_RemoveFailed); + isUpdateRequired = ETrue; + } + else + if (compo.Status() == EDeployed_ActivateProgress) + { + compo.SetStatusNode(EDeployed_ActivateFailed); + isUpdateRequired = ETrue; + } + else + if (compo.Status() + == EDeployed_DeactivateProgress) + { + compo.SetStatusNode(EDeployed_DeactivateFailed); + isUpdateRequired = ETrue; + } + if (isUpdateRequired) + Server().Storage()->UpdateL(compo); + } + + } + +void CApplicationManagementServer::SetSisAppVersionAndDriveL( + CDeploymentComponent &aCompo) + { + RDEBUG( "CApplicationManagementSession: SetSisAppVersionAndDriveL: Begin" ); + + Swi::RSisRegistrySession sisSession; + User::LeaveIfError(sisSession.Connect()); + CleanupClosePushL(sisSession); + + Swi::RSisRegistryEntry sisEntry; + + //Opens the base package entry by specifying a UID. + User::LeaveIfError(sisEntry.Open(sisSession, aCompo.Uid())); + CleanupClosePushL(sisEntry); + + TUint drivesMask = sisEntry.InstalledDrivesL(); + + TInt drive= EDriveA; + TDriveNumber installedDrive = EDriveC; + + if( drivesMask ) + { + // Select the highest drive as location drive. That's the case when + // all installation is not in same drive + + while( drivesMask >>= 1 ) + { + drive++; + } + + RDEBUG_2( "drive -> SetSisAppVersionAndDriveL %d", drive); + + installedDrive = (TDriveNumber)drive; + } + + + TBool status = EFalse; + + //Since "C" drive is not removable + + if (installedDrive!=EDriveC) + { + status = IsInstalledAppRemovableL(installedDrive); + } + if (status) + { + RDEBUG( "IsInstalledAppRemovableL(SetSisAppVersionAndDriveL); True"); + } + else + { + RDEBUG( "IsInstalledAppRemovableL(SetSisAppVersionAndDriveL); False"); + } + + //check for status drive + aCompo.SetAppRemovableStatus(status); + + TVersion version = sisEntry.VersionL(); + + if (aCompo.ComponentVersion() == KNullDesC8) + { + TBuf8 pkgDes; + pkgDes.AppendNum(version.iMajor); + pkgDes.Append(KLiteralPeriod); + pkgDes.AppendNum(version.iMinor); + aCompo.SetVersionL(pkgDes); + + } + CleanupStack::PopAndDestroy(2, &sisSession); + + RDEBUG( "CApplicationManagementSession: SetSisAppVersionAndDriveL: End" ); + } + +TBool CApplicationManagementServer::IsInstalledAppRemovableL( + TDriveNumber &iDrive) + { + + RDEBUG( "IsInstalledAppRemovableL: Step1" ); + TBool removable=EFalse; + RFs rfs; + User::LeaveIfError(rfs.Connect() ); + CleanupClosePushL(rfs); + TDriveList driveList; + TInt driveCount; + + //Get all removeable drive, both physically and logically + User::LeaveIfError(DriveInfo::GetUserVisibleDrives(rfs, driveList, + driveCount, KDriveAttRemovable)); + + TInt max(driveList.Length()); + + RDEBUG_2( "driveList.Length() %d", max); + + RDEBUG_2( "driveCount %d", driveCount); + + TBuf<26> buf; + buf.Copy(driveList); + RDEBUG_2( "Drive Info (%S)", &buf); + + for (TInt i=0; i