1 /*

     2  * Copyright (c) 2000 Nokia Corporation and/or its subsidiary(-ies). 

     3  * All rights reserved.

     4  * This component and the accompanying materials are made available

     5  * under the terms of "Eclipse Public License v1.0"

     6  * which accompanies this distribution, and is available

     7  * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8  *

     9  * Initial Contributors:

    10  * Nokia Corporation - initial contribution.

    11  *

    12  * Contributors:

    13  *

    14  * Description: Implementation of applicationmanagement components

    15  *

    16  */

    17 

    18 #define __INCLUDE_CAPABILITY_NAMES__

    19 

    20 #include <e32svr.h>

    21 #include <badesca.h>

    22 #include <e32cmn.h>

    23 #include <bautils.h> 

    24 #include <featmgr.h>

    25 #include <imcvcodc.h>

    26 #include <uikon.hrh>

    27 #include <e32property.h>

    28 #include "ApplicationManagementConst.h"

    29 #include "ampskeys.h"

    30 #include <SWInstDefs.h>

    31 #include "amprivateCRKeys.h"

    32 #include <PolicyEngineClient.h>

    33 #include <PolicyEngineXACML.h>

    34 #include <pathinfo.h>

    35 #include <driveinfo.h>

    36 

    37 #include "ApplicationManagementCommon.h"

    38 #include "ApplicationManagementClientServer.h"

    39 #include "ApplicationManagementServer.h"

    40 #include "AMDeploymentComponent.h"

    41 #include "amsmlhelper.h"

    42 #include "ApplicationManagementUtility.h"

    43 #include "ApplicationManagementUtilityFactory.h"

    44 

    45 #include "debug.h"

    46 

    47 #include "coemain.h"

    48 #include <aknnotewrappers.h>

    49 #include "SyncService.h"

    50 #include "AMPreInstallApp.h"

    51 #include <DevManInternalCRKeys.h>

    52 

    53 using namespace NApplicationManagement;

    54 

    55 #ifdef __AM_CONNECT_INSTALLER_ONSTARTUP_	

    56 

    57 #pragma message("AM Connecting installer at startup")

    58 #else

    59 #pragma message("AM Connecting installer when needed")

    60 #endif

    61 

    62 // Needed only for jad+jar installation  

    63 _LIT( KInstallDir, "c:\\temp\\" );

    64 _LIT8(KMIDletJarURL, "MIDlet-Jar-URL");

    65 

    66 //OMA SCOMO Specific

    67 _LIT8(KDownloadState, "./SCOMO/Download/");

    68 _LIT8(KDeliveredState, "./SCOMO/Inventory/Delivered/");

    69 _LIT8(KDeployedState, "./SCOMO/Inventory/Deployed/");

    70 

    71 // ------------------------------------------------------------------------------------------------

    72 // CShutDown::CShutdown()

    73 // ------------------------------------------------------------------------------------------------

    74 

    75 inline CShutdown::CShutdown() :

    76     CTimer(-1)

    77     {

    78     CActiveScheduler::Add(this);

    79     }

    80 

    81 // ------------------------------------------------------------------------------------------------

    82 // CShutDown::ConstructL()

    83 // ------------------------------------------------------------------------------------------------

    84 

    85 inline void CShutdown::ConstructL()

    86     {

    87     CTimer::ConstructL();

    88     }

    89 

    90 // ------------------------------------------------------------------------------------------------

    91 // CShutDown::Start()

    92 // ------------------------------------------------------------------------------------------------

    93 

    94 inline void CShutdown::Start()

    95     {

    96     RDEBUG( "ApplicationManagementServer: starting shutdown timeout" );

    97     After(KApplicationManagementShutdownDelay);

    98     }

    99 

   100 // ------------------------------------------------------------------------------------------------

   101 // CShutDown::RunL()

   102 // ------------------------------------------------------------------------------------------------

   103 

   104 void CShutdown::RunL()

   105     {

   106     RDEBUG( "ApplicationManagementServer timeout ... closing" );

   107     CActiveScheduler::Stop();

   108     }

   109 

   110 // ------------------------------------------------------------------------------------------------

   111 // CShutDown::Start()

   112 // ------------------------------------------------------------------------------------------------

   113 

   114 inline void CShutdown::Stop()

   115     {

   116     RDEBUG( "ApplicationManagementServer: Stop" );

   117     CActiveScheduler::Stop();

   118     }

   119 

   120 

   121 // ------------------------------------------------------------------------------------------------

   122 // CApplicationManagementServer::CreateServiceL()

   123 // ------------------------------------------------------------------------------------------------

   124 CApaAppServiceBase* CApplicationManagementServer::CreateServiceL(

   125         TUid aServiceType) const

   126     {

   127     RDEBUG( "ApplicationManagementServer CreateServiceL" );

   128     if (aServiceType.iUid == KAMServiceUid)

   129         {

   130         return ((CApaAppServiceBase*) (new (ELeave) CApplicationManagementSession));

   131         }

   132     else

   133         {

   134         return CAknAppServer::CreateServiceL(aServiceType);

   135         }

   136     }

   137 

   138 // ------------------------------------------------------------------------------------------------

   139 // CApplicationManagementServer::SendServerToBackground()

   140 // ------------------------------------------------------------------------------------------------

   141 

   142 void CApplicationManagementServer::SendServerToBackground()

   143     {

   144 

   145     RDEBUG( "ApplicationManagementServer SendServerToBackground - Start " );

   146     TApaTaskList taskList(CEikonEnv::Static()->WsSession() );

   147     TApaTask task = taskList.FindApp(TUid::Uid(KAppMgmtServerUid));

   148     

   149      TInt id = CEikonEnv::Static()->RootWin().Identifier();

   150 

   151     RDEBUG_2( "CApplicationManagementServer:::SendServerToBackground %d", id );

   152 	

   153     task.SetWgId(id);

   154 

   155     if (task.Exists())

   156         {

   157 	RDEBUG( "ApplicationManagementServer SendServerToBackground - Start 1" );

   158         task.SendToBackground();

   159         }

   160     RDEBUG( "ApplicationManagementServer SendServerToBackground - End " );

   161     TInt amServerEnabled = 0;

   162     RProperty::Set(KUidPSApplicationManagementKeys, KAMServerUIEnabled,

   163             amServerEnabled);

   164     RDEBUG( "ApplicationManagementServer SendServerToBackground - End 2 " );

   165 

   166     }

   167 

   168 // ------------------------------------------------------------------------------------------------

   169 // CApplicationManagementServer::BringServertoForeground()

   170 // ------------------------------------------------------------------------------------------------

   171 

   172 void CApplicationManagementServer::BringServertoForeground()

   173     {

   174 

   175     RDEBUG( "CApplicationManagementServer:::BringServertoForeground " );

   176     TApaTaskList taskList(CEikonEnv::Static()->WsSession() );

   177     TApaTask task = taskList.FindApp(TUid::Uid(KAppMgmtServerUid));

   178 

   179     TInt id = CEikonEnv::Static()->RootWin().Identifier();

   180 

   181     RDEBUG_2( "CApplicationManagementServer:::BringServertoForeground %d", id );

   182 	

   183     task.SetWgId(id);

   184     if (task.Exists())

   185         {

   186 	RDEBUG( "ApplicationManagementServer SendServerToBackground - BringServertoForeground " );

   187         task.BringToForeground();

   188         }

   189     }

   190 

   191 // ------------------------------------------------------------------------------------------------

   192 // CApplicationManagementServer::BringServertoForeground()

   193 // ------------------------------------------------------------------------------------------------

   194 

   195 void CApplicationManagementServer::BringDMUItoForeground()

   196     {

   197     RDEBUG( "ApplicationManagementServer DownloadComplete - DM UI Broughtto foreground Start " );

   198 

   199     TApaTaskList taskList(CEikonEnv::Static()->WsSession() );

   200     TApaTask task = taskList.FindApp(KPSUidNSmlDMSyncApp);

   201 

   202     const TInt id = task.WgId();

   203     task.SetWgId(id);

   204     RDEBUG_2( "CApplicationManagementServer:::BringDMUItoForeground %d", id );

   205     

   206     if (task.Exists())

   207         {

   208         RDEBUG( "ApplicationManagementServer DownloadComplete - DM UI Broughtto foreground " );

   209         task.BringToForeground();

   210         }

   211     }

   212 

   213 // ------------------------------------------------------------------------------------------------

   214 // CApplicationManagementServer::ComponentDownloadComplete()

   215 // ------------------------------------------------------------------------------------------------

   216 

   217 void CApplicationManagementServer::ComponentDownloadComplete(

   218         CDeploymentComponent *aComponent, TInt iapid, HBufC8 *aServerId)

   219     {

   220     TInt err = KErrNone;

   221     TRAP( err, DownloadCompleteL( aComponent, iapid, aServerId ));

   222     }

   223 

   224 // ------------------------------------------------------------------------------------------------

   225 // CApplicationManagementServer::DownloadCompleteL()

   226 // ------------------------------------------------------------------------------------------------

   227 

   228 void CApplicationManagementServer::DownloadCompleteL(

   229         CDeploymentComponent *aComponent, TInt iapid, HBufC8 *aServerId)

   230     {

   231     RDEBUG( "ApplicationManagementServer DownloadComplete - start" );

   232     __ASSERT_DEBUG( aComponent, User::Invariant() );

   233     iStorage->UpdateL( *aComponent);

   234     TInt errdownload = KErrNone;

   235     TInt errInstall = KErrNone;

   236     TInt status = KStatusSuccess;

   237     if ( !aComponent->DownloadFailed() )

   238         {

   239         CDeploymentComponent *old = DoDataUpdateCheckL( *aComponent);

   240         TDownloadTarget trgt = aComponent->DownloadTarget();

   241         switch (trgt)

   242             {

   243             case EDeliver:

   244                 {

   245                 break;

   246                 }

   247             case EInstall:

   248             case EInstallAndActivate:

   249                 {

   250                 TRAP(errInstall,DoTheInstallL( *aComponent));

   251                 if (trgt == EInstall && errInstall == KErrNone)

   252                     {

   253                     iStorage->DeactivateL( *aComponent);

   254                     }

   255                 /* to avoid duplicates in deployed tree if user delivered upgrade package

   256                  * by using "Install/InstallActivate" operation. if upgrade package is delivered 

   257                  * by Update/UpdateandActivate" , this been handled in next switch case

   258                  */

   259 

   260                 break;

   261                 }

   262 

   263             case EUpdate:

   264             case EUpdateAndActivate:

   265                 {

   266                 if (old)

   267                     {

   268                     FullUpdateL( *aComponent, *old);

   269                     if (trgt == EUpdate)

   270                         {

   271                         iStorage->DeactivateL( *aComponent);

   272                         }

   273                     }

   274                 break;

   275                 }

   276             default:

   277                 {

   278                 break;

   279                 }

   280             }

   281 

   282         }

   283     else

   284         {

   285         errdownload = aComponent->DownloadStatus();

   286         }

   287 

   288     RDEBUG( "ApplicationManagementServer DownloadComplete - Start Send to background" );

   289     //Download Completed/ Failed or installation success/ failure Send server to Background.

   290 

   291     SendServerToBackground();

   292 

   293     // Bring DM UI to foreground provided operation is in non silent mode.

   294     TInt operNonSilent = KErrNotFound;

   295 

   296     RProperty::Get(KUidPSApplicationManagementKeys, KAMOperationNonSilent,

   297             operNonSilent);

   298 

   299     if (operNonSilent==1 || operNonSilent==KErrNotFound)

   300         {

   301         RDEBUG( "ApplicationManagementServer DownloadComplete - DM UI Bring " );

   302         BringDMUItoForeground();

   303         }

   304 

   305     iOMASCOMOEnabled = IsOMASCOMOEnabledL();

   306 		

   307 

   308     if (iOMASCOMOEnabled)

   309         {

   310 

   311 

   312 				status = GetErrorStatus(errdownload,errInstall); 

   313 		      

   314         TInt ASyncSupported = -1;

   315 

   316         CRepository *repository = CRepository::NewLC( KUidPSApplicationManagementKeys );

   317         repository->Get(KAsyncEnabled, ASyncSupported);

   318         CleanupStack::PopAndDestroy();

   319         

   320         // For Sync Reporting

   321         if (!ASyncSupported)

   322             {

   323             

   324             // Update Central Repository with proper error code for Sync

   325             

   326            

   327             CRepository *repository= CRepository::NewLC ( KUidPSApplicationManagementKeys ) ;

   328             repository->Set(KAMSyncStatus, status);

   329             CleanupStack::PopAndDestroy();

   330                         

   331             RProperty counter;

   332             

   333             TInt r=counter.Attach(KUidPSApplicationManagementKeys,

   334                     KSyncNotifier, EOwnerThread);

   335             User::LeaveIfError(r);

   336 

   337             TInt err = counter.Set(KErrCancel);

   338             User::LeaveIfError(err);

   339             counter.Close();

   340 

   341             }

   342         else// Do AsyncReporting

   343             {

   344 

   345             // Get deployement component entries

   346             TInt internalid = aComponent->InternalId();

   347 

   348             TBuf8<256> targetURI;

   349 

   350             TDeploymentComponentState state = aComponent->State();

   351 

   352             if (state == EDCSDownload)

   353                 {

   354                 targetURI.Append(KDownloadState);

   355                 targetURI.Append(aComponent->UserId());

   356                 }

   357             else

   358                 if (state == EDCSDelivered)

   359                     {

   360                     targetURI.Append(KDeliveredState);

   361                     targetURI.Append(aComponent->UserId());

   362 

   363                     }

   364                 else

   365                     if (state == EDCSActive|| state == EDCSInactive)

   366                         {

   367                         targetURI.Append(KDeployedState);

   368                         targetURI.Append(aComponent->UserId());

   369                         }

   370 

   371             //Save Entry to database with status and target URI of deployment component

   372 

   373             TInt index;

   374             iAMServerDB->SaveToDatabaseL(index, internalid, status,

   375                     targetURI, iapid);

   376 

   377             EnableDMNetworkMonL(iapid, aServerId);

   378             }

   379 

   380         }

   381     if (iDownloadMngr->DownloadCount() == 0)

   382         {

   383         

   384         RDEBUG_2( "CApplicationManagementServer::ConstructL - ERROR leaving cannot connect installer: %d", iSessionCount );

   385         

   386         // Is session count is not modified whenever there is error then at the end of download complete decrement

   387         //  the session count.

   388         

   389         if(status != KStatusSuccess && iSessionCount != 0 )

   390             {

   391             iSessionCount--; 

   392             }

   393        

   394         if (iSessionCount == 0)

   395             {  

   396 		       iShutdown.Stop();

   397             }

   398         }

   399 

   400     RDEBUG( "ApplicationManagementServer DownloadComplete - end" );

   401     }

   402 

   403 // ------------------------------------------------------------------------------------------------

   404 // CApplicationManagementServer::IsOMASCOMOEnabledL()

   405 // ------------------------------------------------------------------------------------------------

   406 

   407 TBool CApplicationManagementServer::IsOMASCOMOEnabledL()

   408     {

   409     TInt adapterValue;

   410     

   411     CRepository *repository = CRepository::NewLC ( KCRUidPrivateApplicationManagementKeys ) ;

   412     repository->Get(KAMAdapterValue, adapterValue);

   413     CleanupStack::PopAndDestroy();

   414     

   415     if(adapterValue ==0 || adapterValue == 1)

   416      return EFalse;

   417     else

   418      return ETrue;

   419     

   420     }

   421 

   422 // ------------------------------------------------------------------------------------------------

   423 // CApplicationManagementServer::GetErrorStatus()

   424 // ------------------------------------------------------------------------------------------------

   425 TInt CApplicationManagementServer::GetErrorStatus(TInt aErrorDownload, TInt aErrorInstall)

   426 {

   427 	       TInt status = KStatusSuccess;

   428 	       

   429 	       if (aErrorDownload!=KErrNone)

   430                 {

   431                 if (aErrorDownload == KStatusUserCancelled || aErrorDownload

   432                         == KStatusDowloadFailedOOM || aErrorDownload

   433                          == KStatusUnSupportedEnvironment || aErrorDownload 

   434                         ==KStatusAlternateDownldAuthFail || aErrorDownload == KStatusAltDowldUnavailable)

   435                     {

   436                     status = aErrorDownload;

   437                     }

   438                 else

   439                     status = KStatusDownloadFailed;

   440                 }

   441 

   442             else

   443                 if (aErrorInstall!=KErrNone)

   444                     {

   445                     if (aErrorInstall == SwiUI::KSWInstErrSecurityFailure)

   446                         status = KStatusPkgValidationFailed;

   447                     if (aErrorInstall == SwiUI::KSWInstErrInsufficientMemory)

   448                         status = KStatusInstallFailedOOM;

   449                     else

   450                         status = KStatusInstallFailed;

   451 

   452                     }

   453                     

   454            return status;

   455 

   456 }

   457 

   458    

   459 // ------------------------------------------------------------------------------------------------

   460 // CApplicationManagementServer::EnableDMNetworkMonL()

   461 // ------------------------------------------------------------------------------------------------

   462 void CApplicationManagementServer::EnableDMNetworkMonL(TInt iapid, HBufC8 *aServerId)

   463 {

   464 						TInt retryenabled = 1;

   465 						_LIT( KNetMon,"\\dmnetworkmon.exe" );

   466             

   467             // Enable DM Network Monitoring for retry of Generic alert in case of N/W loss

   468 

   469             CRepository *repository= CRepository::NewLC ( KCRUidDeviceManagementInternalKeys );

   470             repository->Set(KDevManEnableDMNetworkMon, retryenabled);

   471             repository->Set(KDevManServerIdKey, *aServerId);

   472             repository->Set(KDevManIapIdKey, iapid);

   473             CleanupStack::PopAndDestroy();

   474                

   475 						// create NetMon EXE

   476             RProcess rp;

   477             TInt err = rp.Create(KNetMon,KNullDesC);

   478             User::LeaveIfError(err);

   479             TRequestStatus stat;

   480             rp.Rendezvous(stat);

   481                             

   482             if (stat!=KRequestPending)

   483               rp.Kill(0);     // abort startup

   484             else

   485               rp.Resume();    // logon OK - start the server

   486             TInt r=(rp.ExitType()==EExitPanic) ? KErrGeneral : stat.Int();

   487                         rp.Close();

   488 

   489 	

   490 }

   491 

   492 // ------------------------------------------------------------------------------------------------

   493 // CApplicationManagementServer::CApplicationManagementServer

   494 // ------------------------------------------------------------------------------------------------

   495 

   496 inline CApplicationManagementServer::CApplicationManagementServer()

   497     {

   498     }

   499 

   500 // ------------------------------------------------------------------------------------------------

   501 // CApplicationManagementServer::AddSession()

   502 // ------------------------------------------------------------------------------------------------

   503 

   504 void CApplicationManagementServer::AddSession()

   505     {

   506     // A new session is being created

   507     RDEBUG( "ApplicationManagementServer: CApplicationManagementServer::AddSession" );

   508     ++iSessionCount;

   509 

   510     // Cancel the shutdown timer if it was running

   511     iShutdown.Cancel();

   512     }

   513 

   514 // ------------------------------------------------------------------------------------------------

   515 // CApplicationManagementServer::DropSession()

   516 // ------------------------------------------------------------------------------------------------

   517 

   518 void CApplicationManagementServer::DropSession()

   519     {

   520     // A session is being destroyed

   521     RDEBUG( "ApplicationManagementServer: CApplicationManagementServer::DropSession" );

   522 

   523     // Start the shutdown timer if it is the last session

   524     if ( --iSessionCount == 0)

   525         {

   526         if (iDownloadMngr->DownloadCount() > 0)

   527             {

   528             RDEBUG( "ApplicationManagementServer: CApplicationManagementServer::DropSession download in progress" );

   529             }

   530         else

   531             {

   532             iShutdown.Start();

   533             }

   534         }

   535     }

   536 

   537 // -----------------------------------------------------------------------------------------------------------

   538 // CApplicationManagementServer::AddDownloadL( CDeploymentComponent *aComponent )

   539 // -----------------------------------------------------------------------------------------------------------

   540 

   541 void CApplicationManagementServer::AddDownloadL(

   542         CDeploymentComponent *aComponent)

   543     {

   544     __ASSERT_DEBUG( aComponent, User::Invariant() );

   545     iDownloadMngr->AddDownloadL(aComponent);

   546     }

   547 

   548 // ------------------------------------------------------------------------------------------------

   549 // CApplicationManagementServer::NewLC

   550 // ------------------------------------------------------------------------------------------------

   551 

   552 CApplicationManagementServer* CApplicationManagementServer::NewL()

   553     {

   554 

   555     CApplicationManagementServer* self=new(ELeave) CApplicationManagementServer;

   556 

   557     return self;

   558     }

   559 

   560 // ------------------------------------------------------------------------------------------------

   561 // CApplicationManagementServer::CreateServiceSecurityCheckL

   562 // ------------------------------------------------------------------------------------------------

   563 

   564 CPolicyServer::TCustomResult CApplicationManagementServer::CreateServiceSecurityCheckL(

   565         TUid aServiceType, const RMessage2& aMsg, TInt& aAction,

   566         TSecurityInfo& aMissing)

   567     {

   568     TInt32 trustRange = EAddTrust;

   569     TInt32 performRFS = EPerformRfs;

   570     TInt32 last = ELast;

   571 

   572     if ( (aServiceType.iUid >= trustRange)

   573             && (aServiceType.iUid < performRFS ))

   574         {

   575         if (aMsg.HasCapability(TCapability(ECapabilityTrustedUI) ) )

   576             {

   577             return CPolicyServer::EPass;

   578             }

   579         else

   580             {

   581             return CPolicyServer::EFail;

   582             }

   583         }

   584 

   585     else

   586         if ( (aServiceType.iUid >= performRFS) && (aServiceType.iUid < last))

   587 

   588             {

   589             if (aMsg.HasCapability(TCapability(ECapabilityDiskAdmin))

   590                     && (aMsg.SecureId().iId == 0x101f9a02 ))

   591                 {

   592                 return CPolicyServer::EPass;

   593                 }

   594             else

   595                 {

   596                 return CPolicyServer::EFail;

   597                 }

   598             }

   599 

   600         else

   601             if (aServiceType.iUid == last)

   602                 {

   603                 return CPolicyServer::EFail;

   604                 }

   605 

   606             else

   607                 {

   608                 return CAknAppServer::CreateServiceSecurityCheckL(

   609                         aServiceType, aMsg, aAction, aMissing);

   610                 }

   611 

   612     }

   613 

   614 // ------------------------------------------------------------------------------------------------

   615 // CApplicationManagementServer::~CApplicationManagementServer

   616 // ------------------------------------------------------------------------------------------------

   617 

   618 CApplicationManagementServer::~CApplicationManagementServer()

   619     {

   620     RDEBUG_3("CApplicationManagementServer::~CApplicationManagementServer 0x%X - 0x%X", reinterpret_cast<TUint>(this ),

   621             reinterpret_cast<TUint>(this)+sizeof( CApplicationManagementServer ) );

   622     FeatureManager::UnInitializeLib();

   623     iInstaller.Close();

   624     delete iStorage;

   625 

   626     delete iUtility;

   627     delete iAMServerDB;

   628 

   629     RProperty::Delete(KUidPSApplicationManagementKeys, KAMServerUIEnabled);

   630 

   631     RProperty::Delete(KUidPSApplicationManagementKeys, KAMOperationNonSilent);

   632 

   633     RProperty::Delete(KUidPSApplicationManagementKeys, KSyncNotifier);

   634 

   635     RProperty::Delete(KUidPSApplicationManagementKeys, KDMUINotClosed);

   636 

   637     

   638     iInstallFile.Close();

   639     iInstallRFs.Close();

   640 

   641     delete iDownloadMngr;

   642     }

   643 

   644 // ------------------------------------------------------------------------------------------------

   645 // CApplicationManagementServer::HandleAllClientsClosed

   646 // ------------------------------------------------------------------------------------------------

   647 void CApplicationManagementServer::HandleAllClientsClosed()

   648     {

   649     // Do Nothing

   650     RDEBUG( "CApplicationManagementServer::HandleAllClientsClosed" );

   651     }

   652 

   653 // ------------------------------------------------------------------------------------------------

   654 // CApplicationManagementServer::ConstructL

   655 // ------------------------------------------------------------------------------------------------

   656 

   657 void CApplicationManagementServer::ConstructL(const TDesC &aServerName)

   658     {

   659 

   660     // 2nd phase construction - ensure the timer and server objects are running

   661     RDEBUG( "CApplicationManagementServer::ConstructL - Start" );

   662 

   663     iOMASCOMOEnabled = ETrue;

   664 

   665     CAknAppServer::ConstructL(aServerName);

   666     TRAPD( errf, FeatureManager::InitializeLibL() )

   667     ;

   668     if (errf != KErrNone)

   669         {

   670         User::Leave(errf);

   671         }

   672 

   673     RDEBUG( "CApplicationManagementServer::ConstructL - start" );

   674 

   675     iStorage = CDeliveryComponentStorage::NewL();

   676 

   677     iUtility

   678             = ApplicationManagementUtilityFactory::CreateManagementUtilityL();

   679     iDownloadMngr = CAMDownloadManager::NewL( *this);

   680     iAMServerDB = CAMDownloaddb::NewL();

   681 

   682     // Define P&S Keys

   683     RProperty::Define(KUidPSApplicationManagementKeys, KAMServerUIEnabled,

   684             RProperty::EInt);

   685 

   686     RProperty::Define(KUidPSApplicationManagementKeys, KAMOperationNonSilent,

   687             RProperty::EInt);

   688 

   689     RProperty::Define(KUidPSApplicationManagementKeys, KSyncNotifier,

   690             RProperty::EInt);

   691 

   692     RProperty::Define(KUidPSApplicationManagementKeys, KDMUINotClosed,

   693             RProperty::EInt);

   694 

   695     RProperty syncproperty;

   696 

   697     //Ignore error status

   698     syncproperty.Attach(KUidPSApplicationManagementKeys, KSyncNotifier,

   699             EOwnerThread);

   700     syncproperty.Set(KErrNone);

   701     syncproperty.Close();

   702     

   703     SendServerToBackground();

   704 

   705 #ifdef __AM_CONNECT_INSTALLER_ONSTARTUP_	

   706     TInt err( iInstaller.Connect() );

   707     if ( err != KErrNone )

   708         {

   709         RDEBUG_2( "CApplicationManagementServer::ConstructL - ERROR leaving cannot connect installer: %d", err );

   710         User::LeaveIfError( err );

   711         }

   712 #endif	

   713     RDEBUG( "CApplicationManagementServer::ConstructL - end" );

   714     }

   715 

   716 // ------------------------------------------------------------------------------------------------

   717 // CApplicationManagementServer::StartShutDownTimer()

   718 // ------------------------------------------------------------------------------------------------

   719 

   720 void CApplicationManagementServer::StartShutDownTimerL()

   721     {

   722 

   723     RDEBUG( "CApplicationManagementServer::ConstructL - end" );

   724 

   725     iShutdown.ConstructL();

   726     // ensure that the server still exits even if the 1st client fails to connect

   727     iShutdown.Start();

   728 

   729     RDEBUG( "CApplicationManagementServer::ConstructL - end" );

   730     }

   731 

   732 // ------------------------------------------------------------------------------------------------

   733 // CApplicationManagementServer::CustomSecurityCheckL()

   734 // ------------------------------------------------------------------------------------------------

   735 

   736 CPolicyServer::TCustomResult CApplicationManagementServer::CustomSecurityCheckL(

   737         const RMessage2& /*aMsg*/, TInt& /*aAction*/, TSecurityInfo& /*aMissing*/)

   738     {

   739     return EPass;

   740     }

   741 

   742 // ------------------------------------------------------------------------------------------------

   743 // CApplicationManagementServer::InstallCompleteL()

   744 // ------------------------------------------------------------------------------------------------

   745 

   746 void CApplicationManagementServer::InstallCompleteL(

   747         const CDeploymentComponent& aCompo, const TBool &aInstallSuccess)

   748     {

   749     RDEBUG_2("CApplicationManagementServer::InstallCompleteL start (%d)", aInstallSuccess);

   750     iInstallFile.Close();

   751 

   752     // if java jad + jar install, remove files from c:\temp directory

   753     if (CDeploymentComponent::IsJavaMimeL(aCompo.MetaData().MimeType() ) && CDeploymentComponent::IsJavaMimeL(aCompo.Data().MimeType() ) )

   754         {

   755         TFileName fn, fn2;

   756         GenerateTempFileNameL(iInstallRFs, aCompo, fn, fn2);

   757         RDEBUG_3("CApplicationManagementServer::InstallCompleteL delete files: (%S) (%S)", &fn, &fn2);

   758         User::LeaveIfError(iInstallRFs.Delete(fn) );

   759         User::LeaveIfError(iInstallRFs.Delete(fn2) );

   760         }

   761 

   762     if (aInstallSuccess)

   763         {

   764         // Remove temporary files from private directory 

   765         const_cast<CDeploymentComponent&>(aCompo).ResetDataL(iInstallRFs);

   766         }

   767 

   768     iInstallRFs.Close();

   769 

   770     iInstallInProgress = EFalse;

   771 #ifndef __AM_CONNECT_INSTALLER_ONSTARTUP_	

   772     iInstaller.Close() ;

   773 #endif

   774     RDEBUG("CApplicationManagementServer::InstallCompleteL end");

   775     }

   776 

   777 // ------------------------------------------------------------------------------------------------

   778 // CApplicationManagementServer::GenerateTempJarFileNameL()

   779 // ------------------------------------------------------------------------------------------------

   780 

   781 void CApplicationManagementServer::GenerateTempJarFileNameL(RFs &aFs,

   782         const TDesC& aMetaSource, TFileName &aFileName) const

   783     {

   784     if (aMetaSource != KNullDesC)

   785         {

   786         RFile file;

   787         User::LeaveIfError(file.Open(aFs, aMetaSource, EFileRead) );

   788         CleanupClosePushL(file);

   789         TFileName temp;

   790         temp = ReadJarFileNameL(file);

   791         GenerateTempFileNameL(aFs, temp, aFileName);

   792         CleanupStack::PopAndDestroy( &file);

   793         }

   794     }

   795 

   796 // ------------------------------------------------------------------------------------------------

   797 // CApplicationManagementServer::GenerateTempFileNameL()

   798 // ------------------------------------------------------------------------------------------------

   799 

   800 void CApplicationManagementServer::GenerateTempFileNameL(const RFs &aFs,

   801         const TDesC& aSource, TFileName &aFileName) const

   802     {

   803     if (aSource != KNullDesC)

   804         {

   805         aFileName.Copy(KInstallDir);

   806         TParse p;

   807         User::LeaveIfError(aFs.Parse(aSource, p) );

   808         aFileName.Append(p.NameAndExt() );

   809         }

   810     }

   811 

   812 // ------------------------------------------------------------------------------------------------

   813 // CApplicationManagementServer::GenerateTempFileNameL()

   814 // ------------------------------------------------------------------------------------------------

   815 

   816 void CApplicationManagementServer::GenerateTempFileNameL(RFs &aFs,

   817         const CDeploymentComponent& aCompo, TFileName& aSource,

   818         TFileName &aMetaSource, TFileName &aFileName,

   819         TFileName &aMetaFileName) const

   820     {

   821     if ( !BaflUtils::FolderExists(aFs, KInstallDir) )

   822         {

   823         aFs.MkDirAll(KInstallDir);

   824         }

   825 

   826     aMetaSource.Copy(aCompo.MetaData().DataFileName() );

   827     GenerateTempFileNameL(aFs, aMetaSource, aMetaFileName);

   828     aSource.Copy(aCompo.Data().DataFileName() );

   829     GenerateTempJarFileNameL(aFs, aMetaSource, aFileName);

   830     }

   831 

   832 // ------------------------------------------------------------------------------------------------

   833 // CApplicationManagementServer::GenerateTempFileNameL()

   834 // ------------------------------------------------------------------------------------------------	

   835 

   836 void CApplicationManagementServer::GenerateTempFileNameL(RFs &aFs,

   837         const CDeploymentComponent& aCompo, TFileName &aFileName,

   838         TFileName &aMetaFileName) const

   839     {

   840     TFileName ftemp, msource;

   841     GenerateTempFileNameL(aFs, aCompo, ftemp, msource, aFileName,

   842             aMetaFileName);

   843     }

   844 

   845 // ------------------------------------------------------------------------------------------------

   846 // CApplicationManagementServer::ReadJarFileNameL()

   847 // ------------------------------------------------------------------------------------------------

   848 

   849 TFileName CApplicationManagementServer::ReadJarFileNameL(RFile& aFile) const

   850     {

   851     TFileName jarFileName;

   852     HBufC8* lineBuffer = HBufC8::NewLC(KMaxFileName+72); // lets hope all lines fit to this

   853     TPtr8 linePtr(lineBuffer->Des() );

   854     TInt length(0);

   855     aFile.Size(length);

   856     HBufC8* data = HBufC8::NewLC(length);

   857     TPtr8 ptr(data->Des() );

   858     aFile.Read(ptr);

   859     RDesReadStream stream(*data);

   860     CleanupClosePushL(stream);

   861     TInt colonIndex = -1;

   862     TInt err(KErrNone);

   863     TInt found(KErrNotFound);

   864     const TInt KJadNameValueSeparator = 0x3A; //':' 

   865 

   866     for (;;)

   867         {

   868         TRAP( err, ReadLineL(stream, linePtr) );

   869         if (err == KErrNone)

   870             {

   871             RDEBUG8_2("Read line: (%S)", &linePtr);

   872             found = linePtr.Find(KMIDletJarURL);

   873             if (found != KErrNotFound && found == 0) // found

   874                 {

   875                 TPtrC8 filename(linePtr);

   876                 colonIndex = linePtr.Locate(KJadNameValueSeparator);

   877                 if (colonIndex != KErrNotFound)

   878                     {

   879                     filename.Set(linePtr.Mid(colonIndex+1)); // get jar filename, format is: MIDlet-Jar-URL: bomber.jar

   880                     jarFileName.Copy(filename);

   881                     jarFileName.Trim();

   882                     break;

   883                     }

   884                 }

   885             }

   886         else

   887             {

   888             User::Leave(err);

   889             }

   890         }

   891     CleanupStack::PopAndDestroy(3, lineBuffer); // stream, data

   892     return jarFileName;

   893     }

   894 

   895 // ------------------------------------------------------------------------------------------------

   896 // CApplicationManagementServer::ReadLineL()

   897 // ------------------------------------------------------------------------------------------------

   898 

   899 void CApplicationManagementServer::ReadLineL(RReadStream& aStream,

   900         TDes8& aLineBuffer) const

   901     {

   902     TBuf8<1> input;

   903     const TUint32 LF = 10;

   904     const TUint32 CR = 13;

   905     TBool endOfLine(EFalse);

   906     TInt errRead(KErrNone);

   907 

   908     // reset

   909     aLineBuffer.Zero();

   910 

   911     while ( !endOfLine)

   912         {

   913         TRAP(errRead, aStream.ReadL(input, 1));

   914 

   915         if (errRead == KErrEof)

   916             {

   917             // EOF

   918             User::Leave(KErrEof);

   919             }

   920         // check special characters	

   921         if (input[0] == LF)

   922             {

   923             // End of line

   924             endOfLine = ETrue;

   925             }

   926         else

   927             if (input[0] == CR)

   928                 {

   929                 // Only end of line if not followed by a LF

   930                 }

   931             else

   932                 {

   933                 // We put any other character in the buffer

   934                 if (aLineBuffer.Length() < aLineBuffer.MaxLength())

   935                     {

   936                     aLineBuffer.Append(input[0]);

   937                     }

   938                 }

   939         }

   940     }

   941 

   942 // ------------------------------------------------------------------------------------------------

   943 // CApplicationManagementServer::PrepareInstallL()

   944 // ------------------------------------------------------------------------------------------------	

   945 

   946 TBool CApplicationManagementServer::PrepareInstallL(

   947         const CDeploymentComponent &aComponent, TFileName &aFileName)

   948     {

   949     RDEBUG( "CApplicationManagementServer::PrepareInstallL" );

   950     TBool res(ETrue);

   951 

   952 #ifndef __AM_CONNECT_INSTALLER_ONSTARTUP_

   953     TInt err(iInstaller.Connect() );

   954     if (err != KErrNone)

   955         {

   956         RDEBUG_2( "CApplicationManagementServer::PrepareInstallL - ERROR leaving cannot connect installer: %d", err );

   957         User::LeaveIfError(err);

   958         }

   959     CleanupClosePushL(iInstaller);

   960 #endif

   961 

   962     RDEBUG( "CApplicationManagementServer::PrepareInstallL - connected to installer" );

   963     // Copy data file name (install file)

   964     if (aComponent.Data().DataFileName().Length() > 0)

   965         {

   966         aFileName.Copy(aComponent.Data().DataFileName() );

   967         }

   968     else

   969         {

   970         // data file has not been created for component!	

   971         User::Leave(KErrNotFound);

   972         }

   973     // Open RFs session

   974     User::LeaveIfError(iInstallRFs.Connect() );

   975     User::LeaveIfError(iInstallRFs.ShareProtected() );

   976 

   977     // set installoptions and correct mime type

   978     using namespace SwiUI;

   979     iInstallOptions = aComponent.InstallOpts().iOptions;

   980     TInstallReq req;

   981 	if (aComponent.Data().MimeType() == SwiUI::KSisMimeType) 

   982 	{

   983 		//convert if MIME type is application/vnd.symbian.install to x-epoc/x-sisx-app

   984 		//as installer doesn't support application/vnd.symbian.install MIME type from S60 3rd edition onwards.

   985 		req.iMIME = SwiUI::KSisxMimeType;

   986 	}

   987 	else 

   988 	{

   989 		req.iMIME = aComponent.Data().MimeType();

   990 	}

   991 

   992 	if (CDeploymentComponent::IsJavaMimeL(aComponent.MetaData().MimeType() ) ) {

   993 		// Check if both jad and jar files already exist in the phone	

   994 		if (CDeploymentComponent::IsJavaMimeL(aComponent.Data().MimeType() ) && aComponent.MetaData().MimeType() == SwiUI::KJadMIMEType) {

   995 			// Move both files to temporary location and use jad to install java application

   996 			CFileMan *fm = CFileMan::NewL(iInstallRFs);

   997 			CleanupStack::PushL(fm);

   998 			TFileName source, metasource, metatarget;

   999 			aFileName.Copy(KNullDesC8() ); // reset

  1000 			GenerateTempFileNameL(iInstallRFs, aComponent, source, metasource,

  1001 					aFileName, metatarget);

  1002 

  1003             RDEBUG_2( "CApplicationManagementServer::PrepareInstallL - temp jar file '%S'", &aFileName );

  1004             RDEBUG_2( "CApplicationManagementServer::PrepareInstallL - temp jad file '%S'", &metatarget );

  1005 

  1006             // Copy datafile (jar)

  1007             TInt copyer(fm->Copy(source, aFileName) );

  1008 

  1009             // Copy metadatafile (jad)

  1010             TInt copyer2(fm->Copy(metasource, metatarget) );

  1011 

  1012             CleanupStack::PopAndDestroy(fm);

  1013 

  1014             RDEBUG_3( "CApplicationManagementServer::PrepareInstallL - (%d)-(%d)", copyer, copyer2 );

  1015 

  1016             if (copyer == KErrNone && copyer2 == KErrNone)

  1017                 {

  1018                 res = ETrue;

  1019                 aFileName = metatarget;

  1020                 req.iMIME = aComponent.MetaData().MimeType();

  1021                 }

  1022             else

  1023                 {

  1024                 User::Leave(KErrWrite);

  1025                 }

  1026             }

  1027         else

  1028             if (aComponent.MetaData().MimeType() == SwiUI::KJadMIMEType)

  1029                 {

  1030                 aFileName.Copy(aComponent.MetaData().DataFileName() );

  1031                 req.iMIME = aComponent.MetaData().MimeType();

  1032                 RDEBUG_2( "CApplicationManagementServer::PrepareInstallL - Using Jad file to install java application: %S", &aFileName );

  1033                 }

  1034         }

  1035 

  1036     if (aComponent.GetIAP() > -1)

  1037         {

  1038         req.iIAP = aComponent.GetIAP();

  1039         RDEBUG_2( "CApplicationManagementServer::PrepareInstallL: setting iap to %d", req.iIAP );

  1040         }

  1041     else

  1042         {

  1043         TInt iap = KErrNotFound;

  1044         TRAPD( err, SmlHelper::GetDefaultIAPFromDMProfileL( iap ) )

  1045         ;

  1046         if (err == KErrNone)

  1047             {

  1048             req.iIAP = iap;

  1049             RDEBUG_2("	-> using DM profile default IAP: %d", iap);

  1050             }

  1051         else

  1052             {

  1053             RDEBUG_2("**** ERROR while fetching DM profile default iap: %d", err );

  1054             }

  1055         }

  1056 

  1057     iInstallReq = SwiUI::TInstallReqPckg(req);

  1058     RDEBUG8_2( "CApplicationManagementServer::PrepareInstallL: mime type is (%S)", &req.iMIME);

  1059     RDEBUG_2( "CApplicationManagementServer::PrepareInstallL - Using temp file '%S'", &aFileName );

  1060 

  1061     User::LeaveIfError(iInstallFile.Open(iInstallRFs, aFileName, EFileRead) );

  1062     TInt sz;

  1063     User::LeaveIfError(iInstallFile.Size(sz) );

  1064     if ( !(sz > 0))

  1065         {

  1066         res = EFalse;

  1067         RDEBUG( "CApplicationManagementServer::PrepareInstallL - ERROR size of source file is 0!" );

  1068         }

  1069 

  1070 #ifndef __AM_CONNECT_INSTALLER_ONSTARTUP_

  1071     CleanupStack::Pop( &iInstaller);

  1072 #endif

  1073 

  1074     RDEBUG( "CApplicationManagementServer::PrepareInstallL end" );

  1075     return res;

  1076     }

  1077 

  1078 // ------------------------------------------------------------------------------------------------

  1079 // CApplicationManagementServer::InstallL()

  1080 // ------------------------------------------------------------------------------------------------	

  1081 

  1082 void CApplicationManagementServer::InstallL(

  1083         const CDeploymentComponent &aComponent, TRequestStatus &aStatus)

  1084     {

  1085     RDEBUG( "CApplicationManagementServer::InstallL (async): begin" );

  1086 

  1087     if (iInstallInProgress == EFalse)

  1088         {

  1089         TFileName fn;

  1090         if (PrepareInstallL(aComponent, fn) )

  1091             {

  1092             RDEBUG_3( "CApplicationManagementServer::InstallL: Install '%S' sizeof opts: %d", &fn, sizeof (aComponent.InstallOpts()));

  1093 

  1094             // Silent or Non Silent Installation is choosen based on DM session started in silent or non silent

  1095 

  1096             TInt err = KErrNone;

  1097             TInt nonSilentOperation = KErrNotFound;

  1098             RProperty::Get(KUidPSApplicationManagementKeys,

  1099                     KAMOperationNonSilent, nonSilentOperation);

  1100 

  1101             if (!nonSilentOperation)

  1102                 {

  1103                 TRAP( err ,iInstaller.SilentInstall( aStatus, iInstallFile, iInstallReq, iInstallOptions ) );

  1104                 }

  1105             else

  1106                 {

  1107                 TRAP( err ,iInstaller.Install( aStatus, iInstallFile, iInstallReq ) );

  1108                 }

  1109 

  1110             RDEBUG_2( "CApplicationManagementServer::InstallL: status: %d", err);

  1111             User::LeaveIfError(err);

  1112             iInstallInProgress = ETrue;

  1113             }

  1114         else

  1115             {

  1116             RDEBUG( "CApplicationManagementServer::InstallL - PrepareInstallL failed, leaving" );

  1117             User::Leave(KErrArgument);

  1118             }

  1119         }

  1120     else

  1121         {

  1122         RDEBUG( "CApplicationManagementServer::InstallL (async): previous install still in progress...bailing out" );

  1123         TRequestStatus * status = &aStatus;

  1124         User::RequestComplete(status, KErrInUse);

  1125         }

  1126     RDEBUG( "CApplicationManagementServer::InstallL (async): end" );

  1127     }

  1128 

  1129 // ------------------------------------------------------------------------------------------------

  1130 // CApplicationManagementServer::PrepareInstallL()

  1131 // ------------------------------------------------------------------------------------------------	

  1132 

  1133 void CApplicationManagementServer::InstallL(

  1134         const CDeploymentComponent &aComponent)