/*

* Copyright (c) 2008 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:  OMJ Symbian preinstaller process

*

*/

#include <e32base.h>

#include <pathinfo.h>

#include <driveinfo.h>

#include <javastorageentry.h>

#include <javastorage.h>

#include <javastoragenames.h>

#include <utf.h>

#include "silentmidletinstall.h"

#include "javacommonutils.h"

#include "javauid.h"

#include "javauids.h"

#include "logger.h"

#include "javaprocessconstants.h"

#include "javasymbianoslayer.h"

using namespace java::storage;

using namespace java::util;

// MIDlet name and vendor max size is 255,

// +1 added for terminating zero needed for logging

const TInt KMaxBufferSize = 256;

// character constants needed when parsing java attributes

const TUint32 HT = 9;  // horizontal tab

const TUint32 LF = 10; // line feed

const TUint32 CR = 13; // carriage return

const TUint32 SP = 32; // space

const TUint32 COLON = 58; // ':'

const int INSTALLED = 0;

const int NO_PREINSTALL = 2;

_LIT(KMidletName, "MIDlet-Name");

_LIT(KMidletVendor, "MIDlet-Vendor");

_LIT(KMidletVersion, "MIDlet-Version");

_LIT(KMidletUid, "Nokia-MIDlet-UID-1");

_LIT(KJadExtension, "*.jad");

// Java Installer Integrity Service journal file name

_LIT(KISJournalFile, "\\private\\102033E6\\installer\\is\\isjournal.dat");

// The directory where the java applications to be preinstalled are searched

// from

_LIT(KPreinstallDir, ":\\resource\\java\\preinstall\\");

/**

 * To create new instance of this class.

 *

 * @param aFs - A reference to the file server.

 * @return Reference to the object of this class.

 * @exception If construction fails.

 */

CSilentMIDletInstall* CSilentMIDletInstall::NewLC(RFs& aFs)

{

    CSilentMIDletInstall* self = new(ELeave) CSilentMIDletInstall(aFs);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

}

/**

 * To do 1st phase construction for this object.

 * Adds this active object to the scheduler.

 *

 * @param aFs - A reference to the file server.

 */

CSilentMIDletInstall::CSilentMIDletInstall(RFs& aFs) :

        CActive(EPriorityStandard), iFs(aFs)

{

    CActiveScheduler::Add(this);

}

/**

 * To do 2nd phase construction for this object.

 *

 * @exception If the method is not able to allocate necessary buffers.

 */

void CSilentMIDletInstall::ConstructL()

{

    iMIDletName = HBufC::NewL(KMaxBufferSize);

    iMIDletVendor = HBufC::NewL(KMaxBufferSize);

    iMIDletUid = HBufC::NewL(KMaxBufferSize);

    iPreinstallServer = new(ELeave) PreinstallCommsServer();

    iNumberOfAppsToInstall = 0;

    iISRollbackNeeded = EFalse;

}

/**

 * Deletes this object.

 * All allocated resources are released.

 */

CSilentMIDletInstall::~CSilentMIDletInstall()

{

    iJadFiles.ResetAndDestroy();

    iJadFiles.Close();

    iDirs.ResetAndDestroy();

    iDirs.Close();

    delete iMIDletName;

    iMIDletName = NULL;

    delete iMIDletVendor;

    iMIDletVendor = NULL;

    delete iMIDletUid;

    iMIDletUid = NULL;

    delete iPreinstallServer;

    iPreinstallServer = NULL;

}

/**

 * To start silent preinstallations.

 */

void CSilentMIDletInstall::Start()

{

    iState = EFindOutDeviceDrives;

    // Check if an explicit roll-back of a previous installation is needed

    // in the case there is nothing to pre-install (if there is something

    // to pre-install, the potential roll-back is done automatically)

    TUint attrs;

    TInt err = iFs.Att(KISJournalFile, attrs);

    LOG1(EJavaPreinstaller, EInfo,

         "Checking IS journal file \\private\\102033E6\\installer\\is\\isjournal.dat, status %d", err);

    if ((KErrNotFound == err) || (KErrPathNotFound == err))

    {

        iISRollbackNeeded = EFalse;

    }

    else

    {

        iISRollbackNeeded = ETrue;

        // If JavaInstaller is running, then existence of the Java Installer

        // integrity service directory is ok and rollback is not needed

        TFullName processName;

        _LIT(KJavaInstallerProcess, "*Installer*");

        TFindProcess finder(KJavaInstallerProcess);

        err = finder.Next(processName);

        if (err == KErrNone)

        {

            iISRollbackNeeded = EFalse;

            WLOG(EJavaPreinstaller,

                 "Java Installer is running while checking need to rollback");

        }

    }

    CompleteRequest();

}

/**

 * To stop whole preinstaller.

 * Stops the active scheduler.

 */

void CSilentMIDletInstall::Exit()

{

    CActiveScheduler::Stop();

}

/**

 * Completes the current request for this object and

 * sets this active object to active state.

 *

 * @Postconditions The following conditions are true immediately after

 * returning from this method.

 * - iStatus == KErrNone

 * - IsActive() == ETrue

 */

void CSilentMIDletInstall::CompleteRequest()

{

    TRequestStatus *status = &iStatus;

    User::RequestComplete(status, KErrNone);

    if (!IsActive())

    {

        SetActive();

    }

}

/**

 * To run this active object.

 *

 * This object goes through the following states in the order the states

 * are listed below:

 *

 * EFindOutDeviceDrives: find out all non-remote drives in the device

 *    - mark externally mountable drives (removable drives)

 *    - mark read only drives (ROM)

 *

 * EFindOutDrivesToBeScannedNow: make list of drives to be scanned

 *    - start with all mounted drives

 *

 * EAppsInPreinstallDirectories: go through all drives in the list and

 *  find all java applications in the preinstall directory

 *    - only the .jad file is checked but remember that downloading .jar is not

 *      allowed when preinstalling so the .jar file referred to in the .jad

 *      file must be in the device

 *

 * ECheckWhichAppsShouldBeInstalled: for each java application check from

 *  Java Storage whether it should be installed

 *    - if same or newer version already installed, do not install

 *    - if the user has uninstalled same or newer version, do not install

 *    - unsigned java applications can be installed only in debug builds

 *

 * EExecutePreinstallServer:

 *  - store list of .jad files to preinstall server object,

 *  - start Java Installer in poll mode,

 *  - start preinstall server in another thread and wait until Java Installer exits

 *      - preinstall server will give the names of the .jad files to

 *        Java Installer when it polls them,

 *      - preinstall server will log whether each installation  succeeded.

 *      - After all .jad files have been polled, preinstall server will ask

 *        Java Installer to exit.

 *  - when Java Installer exits, this active object moves to next state.

 *

 * EExit:

 *  - stop preinstall server thread

 *  - notify possibly waiting processes that preinstallation has been done

 *  - exit

 *

 */

void CSilentMIDletInstall::RunL()

{

    switch (iState)

    {

    case EFindOutDeviceDrives:

    {

        LOG(EJavaPreinstaller, EInfo,

            "CSilentMIDletInstall:RunL EFindOutDeviceDrives");

        GetAllDeviceDrivesL();

        iState = EFindOutDirectoriesToBeScannedNow;

        CompleteRequest();

    }

    break;

    case EFindOutDirectoriesToBeScannedNow:

    {

        LOG(EJavaPreinstaller, EInfo,

            "CSilentMIDletInstall:RunL EFindOutDirectoriesToBeScannedNow");

        GetDirsToBeScannedL();

        iState = EAppsInPreinstallDirectories;

        CompleteRequest();

    }

    break;

    case EAppsInPreinstallDirectories:

    {

        LOG(EJavaPreinstaller, EInfo,

            "CSilentMIDletInstall:RunL EAppsInPreinstallDirectories");

        GetMIDletFilesL(iDirs);

        iState = ECheckWhichAppsShouldBeInstalled;

        CompleteRequest();

    }

    break;

    case ECheckWhichAppsShouldBeInstalled:

    {

        LOG(EJavaPreinstaller, EInfo,

            "CSilentMIDletInstall:RunL ECheckWhichAppsShouldBeInstalled");

        CheckWhichAppsShouldBeInstalledL();

        iState = EExecutePreinstallServer;

        CompleteRequest();

    }

    break;

    case EExecutePreinstallServer:

    {

        LOG(EJavaPreinstaller, EInfo,

            "CSilentMIDletInstall:RunL EExecutePreinstallServer");

        // This method advances the state machine to EExit state

        ExecutePreinstallServerL();

    }

    break;

    case EExit:

    {

        LOG(EJavaPreinstaller, EInfo,

            "CSilentMIDletInstall:RunL EExit");

        // Stop the server if it is running

        iPreinstallServer->stop();

        // Java Captain starts preinstaller each time a mountable drive

        // is added to the device. There is no need to wait for mount

        // events in this process.

        // Stop the whole preinstaller process.

        Exit();

    }

    break;

    } // switch

}

/**

 * To handle leave from RunL.

 * This method re-activates this active object.

 * After calling this method this active object is in stable state and

 * ready to continue its execution

 *

 * @param aError - A reason of error.

 * @return KErrNone.

 */

TInt CSilentMIDletInstall::RunError(TInt aError)

{

    ELOG2(EJavaPreinstaller,

          "CSilentMIDletInstall::RunError(%d) from state %d", aError, iState);

    Cancel();

    // Make preinstaller to exit nicely.

    iState = EExit;

    CompleteRequest();

    return KErrNone;

}

/**

 * Cancel this object. Stops preinstall server if needed.

 */

void CSilentMIDletInstall::DoCancel()

{

    ELOG1(EJavaPreinstaller,

          "CSilentMIDletInstall::DoCancel from state %d", iState);

    // Check whether preinstall server must be stopped

    if (iState == EExecutePreinstallServer)

    {

        // Stops the server if it is running

        iPreinstallServer->stop();

    }

}

/**

 * Add .jad files in the directories specified in aDirs to iJadFiles.

 *

 * Goes  all directories in iDirs one by one and adds the

 * valid .jad files in alphabetical order to iJadFiles.

 *

 * @param aDirs - An array of directories to be scanned.

 * @exception Unable to alloc memory for the internal buffers.

 * @exception Unable to get directory's contents.

 */

void CSilentMIDletInstall::GetMIDletFilesL(RPointerArray<HBufC>& aDirs)

{

    JELOG2(EJavaPreinstaller);

    const TInt num = aDirs.Count();

    // Read JAD files.

    for (TInt i = 0; i < num; i++)

    {

        const TPtrC& dir = ((HBufC *)(aDirs[i]))->Des();

        HBufC* mask= NULL;

        TPtr maskPtr(NULL,0,0);

        // Create JAD mask, e.g., "z:\resource\java\preinstall\*.jad".

        // Reserve space also for terminating zero for logging the info

        mask = HBufC::NewLC(dir.Length() + KJadExtension().Length() + 1);

        maskPtr.Set(mask->Des());

        maskPtr.Append(dir);

        maskPtr.Append(KJadExtension);

        LOG1WSTR(EJavaPreinstaller, EInfo,

                 "CSilentMIDletInstall::GetMIDletFilesL Looking for jad files from directory %s",

                 (wchar_t *)(maskPtr.PtrZ()));

        GetDirEntriesL(dir, *mask, iJadFiles);

        CleanupStack::PopAndDestroy(mask);

    }

    if (iJadFiles.Count() == 0)

    {

        ILOG(EJavaPreinstaller,

             "CSilentMIDletInstall:GetMIDletFilesL No MIDlets to preinstall");

    }

}

/**

 * Get the entries of the directory in alphabetical order.

 *

 * @param aDirectory - A directory to be scanned.

 * @param aMask - A filter to be used for scanning.

 * @param aVector - An output vector for contents.

 * @exception Unable to alloc memory for the internal buffers.

 */

void CSilentMIDletInstall::GetDirEntriesL(const TDesC& aDirectory,

        const TDesC& aMask, RPointerArray<HBufC>& aVector)

{

    JELOG2(EJavaPreinstaller);

    // Get entries in alphabetical order.

    CDir* entries= NULL;

    TInt err = iFs.GetDir(aMask, KEntryAttMaskSupported, ESortByName, entries);

    if (err != KErrNone)

    {

        if (err != KErrPathNotFound)

        {

            ELOG1(EJavaPreinstaller,

                  "CSilentMIDletInstall::GetDirEntriesL Dir error (%d)", err);

        }

        delete entries;

        return;

    }

    CleanupStack::PushL(entries);

    // Add full file names to the vector.

    TInt num = entries->Count();

    for (TInt i = 0; i < num; i++)

    {

        const TDesC& name = (*entries)[i].iName;

        // Reserve one char for null terminator

        HBufC* path = HBufC::NewLC(aDirectory.Length() + name.Length() + 1);

        TPtr pathPtr(path->Des());

        pathPtr.Append(aDirectory);

        pathPtr.Append(name);

        LOG1WSTR(EJavaPreinstaller, EInfo,

                 "CSilentMIDletInstall::GetDirEntriesL Adding file %s",

                 (wchar_t *)(pathPtr.PtrZ()));

        CleanupStack::Pop(path);

    }

    CleanupStack::PopAndDestroy(entries);

}

/**

 * Start Java Installer in poll mode and then wait until it exits.

 */

void CSilentMIDletInstall::RunJavaInstallerL()

{

    JELOG2(EJavaPreinstaller);

    LOG(EJavaPreinstaller, EInfo, "CSilentMIDletInstall::RunJavaInstaller");

    RProcess rJavaInstaller;

    TFileName fileName;

    // Max one path name, user name and password and some options ->

    // 1536 is enough

    TBuf<1536> commandLine;

    // Build command line used to pass all necessary info to Java Installer

    TInt len = strlen(java::runtime::JAVA_INSTALLER_STARTER_DLL);

    TPtr8 ptr8InstallerDll((TUint8 *)java::runtime::JAVA_INSTALLER_STARTER_DLL, len, len);

    commandLine.Copy(ptr8InstallerDll);

    commandLine.Append(_L(" poll -address=preinstall"));

    // Upgrading MIDlets is allowed

    commandLine.Append(_L(" -upgrade=yes"));

    // No OCSP checks for preinstalled MIDlets

    commandLine.Append(_L(" -ocsp=no"));

#ifdef _DEBUG

    // Allow installing unsigned apps in debug builds

    commandLine.Append(_L(" -untrusted=yes"));

#else

    // Deny preinstalling untrusted midlets in release builds

    commandLine.Append(_L(" -untrusted=no"));

#endif

    // Do upgrade if version number has not increased

    commandLine.Append(_L(" -overwrite=no"));

    // Both the JAD and JAR file must be present when preinstalling MIDlets,

    // downloading is not allowed.

    commandLine.Append(_L(" -download=no"));

    // If upgrade install, retain the data (RMS and private files) of the previous version

    commandLine.Append(_L(" -upgrade_data=yes"));

    // start JavaInstaller

    TBuf<64> installerProcess;  // Actual len of the process name is 9

    len = strlen(java::runtime::JAVA_PROCESS);

    TPtr8 ptr8Process((TUint8 *)java::runtime::JAVA_PROCESS, len, len);

    installerProcess.Copy(ptr8Process);

    TInt err = rJavaInstaller.Create(installerProcess, commandLine);

    if (KErrNone == err)

    {

        LOG(EJavaPreinstaller, EInfo, "CSilentMIDletInstall::RunJavaInstaller calling Logon");

        // This call will wait until Java Installer exits (or panics)

        rJavaInstaller.Logon(iStatus);

        LOG(EJavaPreinstaller, EInfo, "CSilentMIDletInstall::RunJavaInstaller calling Resume");

        rJavaInstaller.Resume();

    }

    else

    {

        ELOG1(EJavaPreinstaller,

              "CSilentMIDletInstall::RunJavaInstaller Cannot start Installer, error %d", err);

        // CActive will trap the following leave, execution will go to RunError

        User::Leave(err);

    }