/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: Java platform 2.0 javarestoreconverter process

*

*/

#include <apacmdln.h>

#include <apgcli.h>

#include <driveinfo.h>

#include <e32base.h>

#include <pathinfo.h>

#include <utf.h>

#include <zipfile.h>

#include "restoreconvertmidlet.h"

#include "javacommonutils.h"

#include "javaprocessconstants.h"

#include "javastorage.h"

#include "javastorageentry.h"

#include "javastoragenames.h"

#include "javasymbianoslayer.h"

#include "javauids.h"

#include "logger.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; // ':'

_LIT(KJarFileNameSuffix, ".jar");

_LIT(KJadFileNameSuffix, ".jad");

_LIT(KFLJarFileNameSuffix, ".dm");

_LIT(KSDJarFileNameSuffix, ".dcf");

_LIT(KSMCBackSplash, "\\");

_LIT(KDriveText, "drive");

_LIT(KMidletName, "MIDlet-Name");

_LIT(KMidletVendor, "MIDlet-Vendor");

_LIT(KManifestEntryName, "META-INF/MANIFEST.MF");

// The directory where the java applications to be converted are searched from

_LIT(KMidletSuiteInstallBasePath, ":\\Private\\102033E6\\MIDlets\\");

/**

 * 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.

 *

 */

CRestoreConvertMIDlet* CRestoreConvertMIDlet::NewLC(RFs& aFs)

{

    CRestoreConvertMIDlet* self = new(ELeave) CRestoreConvertMIDlet(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.

 */

CRestoreConvertMIDlet::CRestoreConvertMIDlet(RFs& aFs) :

        CActive(EPriorityStandard), iFs(aFs), iNumberOfAppsToInstall(0)

{

    CActiveScheduler::Add(this);

}

/**

 * To do 2nd phase construction for this object.

 *

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

 */

void CRestoreConvertMIDlet::ConstructL()

{

    iConvertServer = new(ELeave) RestoreServer();

    iMIDletName    = HBufC::NewL(KMaxBufferSize);

    iMIDletVendor  = HBufC::NewL(KMaxBufferSize);

}

/**

 * Deletes this object.

 * All allocated resources are released.

 */

CRestoreConvertMIDlet::~CRestoreConvertMIDlet()

{

    Cancel();

    iInstallFiles.ResetAndDestroy();

    iInstallFiles.Close();

    iUninstallUids.clear();

    iDirs.ResetAndDestroy();

    iDirs.Close();

    iIsJad.Reset();

    delete iMIDletName;

    iMIDletName = NULL;

    delete iMIDletVendor;

    iMIDletVendor = NULL;

    delete iConvertServer;

    iConvertServer = NULL;

}

/**

 * To start silent installation.

 */

void CRestoreConvertMIDlet::Start()

{

    iState = EFindOutDeviceDrives;

    CompleteRequest();

}

/**

 * To stop whole preinstaller.

 * Stops the active scheduler.

 */

void CRestoreConvertMIDlet::Exit()

{

    Deque();

    CActiveScheduler::Stop();

}

/**

 * To complete the request for this object.

 *

 * @Postconditions The following conditions are true immediately after

 * returning from this method.

 * - iStatus == KErrNone

 * - IsActive() == ETrue

 */

void CRestoreConvertMIDlet::CompleteRequest()

{

    TRequestStatus *status = &iStatus;

    User::RequestComplete(status, KErrNone);

    if (!IsActive())

    {

        SetActive();

    }

}

/**

 * To run this active object.

 *

 * The state logic is:

 *

 * EFindOutDeviceDrives:

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

 *    - mark externally mountable drives (removable drives)

 *    - mark read only drives (ROM)

 *

 * EGetDriveToBeScanned:

 *    - the drive to be scanned has been given as command line argument,

 *      store it to iDrive

 *

 * EAppsInInstalledDirectories:

 *    - go through all directories in iDirs one by one

 *      and find all java applications in the subdirectories of the directory

 *    - if only .jar/.dcf/.dm file is found it is added to iInstallFiles

 *    - if .jad file is found, it is added to iInstallFiles

 *

 * EUninstallFromOMJ:

 *   - uninstall all OMJ java applications in drive iDrive using Java Installer

 *     command line options 'uninstallall -drive=<iDrive>'

 *   - then for each java application in iInstallFiles try to find it from

 *     Java Storage based on MIDlet suite name and vendor name. If the MIDlet

 *     is still installed to OMJ (to some other drive than iDrive), it must

 *     be uninstalled from OMJ to reset the state of MIDlet (RMS data etc)

 *     to original state. The actual uninstallation is not done in this

 *     state, the uids of the applications to be uninstalled are just added to

 *     iUninstallUids in string format

 *

 * EExecuteRestoreServer:

 *  - give list of uninstall uids and list of install files to restore server

 *  - start restore server in another thread (it will listen to Comms messages)

 *  - start Java Installer in poll mode

 *  - when Java Installer polls for operations to be executed, the restore server

 *    will first ask it to uninstall each Java application in the list of uninstall uids,

 *    then restore server will ask Java Installer to install each .jad or .jar/.dcf/.dm file

 *    in the list of install files.

 *    Restore server will log whether each uninstallation / installation succeeds.

 *  - after all uninstallations and installations have been done, restore server will ask

 *    Java Installer to exit.

 *  - after that this active object moves to next state.

 *

 * EExit: free resources and exit

 *

 */

void CRestoreConvertMIDlet::RunL()

{

    switch (iState)

    {

    case EFindOutDeviceDrives:

    {

        LOG(EJavaConverters, EInfo,

            "CRestoreConvertMIDlet::RunL EFindOutDeviceDrives");

        GetAllDeviceDrivesL();

        iState = EGetDriveToBeScanned;

        CompleteRequest();

    }

    break;

    case EGetDriveToBeScanned:

    {

        LOG(EJavaConverters, EInfo,

            "CRestoreConvertMIDlet::RunL EGetDriveToBeScanned");

        HBufC *pBufCmdLine = HBufC::NewLC(User::CommandLineLength() + 10);

        TPtr args = pBufCmdLine->Des();

        User::CommandLine(args);

        LOG1WSTR(EJavaConverters, EInfo,

                 "Command line arguments of javarestoreconverter.exe are : %s",

                 (wchar_t *)(args.PtrZ()));

        // Check which drive is to be restored now from command line.

        TDriveNumber drive = EDriveC;

        TInt idx = args.Find(KDriveText());

        if (KErrNotFound == idx)

        {

            LOG1WSTR(EJavaConverters, EError,

                     "no -drive<X> argument in javarestoreconveter.exe command line (%s)",

                     (wchar_t *)(args.PtrZ()));

            User::Leave(KErrNotFound);

        }

        TChar driveChar = args[idx + KDriveText().Length()];

        char argLetter = args[idx + KDriveText().Length()];

        if (argLetter >= 'A' && argLetter <= 'J')

        {

            drive = (TDriveNumber)(argLetter - 'A');

        }

        else if (argLetter >= 'a' && argLetter <= 'j')

        {

            drive = (TDriveNumber)(argLetter - 'a');

        }

        else

        {

            User::Leave(KErrArgument);

        }

        CleanupStack::PopAndDestroy(pBufCmdLine);

        iDrive = drive;

        LOG1(EJavaConverters, EInfo, "Drive is %d", drive);

        // forget old search directories

        iDirs.ResetAndDestroy();

        // The specified drive will be scanned for

        // java applications to be converted

        if (iDriveStatuses[drive] & DriveInfo::EDrivePresent)

        {

            (void)iFs.DriveToChar(drive, driveChar);

            // The base Java application install directory in this

            // drive must be scanned.

            // Reserve memory also for drive letter and terminating zero

            // for logging.

            HBufC *baseInstallDir = HBufC::NewLC(KMidletSuiteInstallBasePath().Length() + 2);

            TPtr dirPtr(baseInstallDir->Des());

            dirPtr.Append(driveChar);

            dirPtr.Append(KMidletSuiteInstallBasePath());

            // Add new search directory

            iDirs.AppendL(baseInstallDir);

            CleanupStack::Pop(baseInstallDir);

        }

        else

        {

            // Restoring MIDlets to drive X but drive X is not present

            ELOG1(EJavaConverters,

                  "javarestoreconverter.exe: Drive number %d is not present", drive);

            User::Leave(KErrDisMounted);

        }

        iState = EAppsInInstalledDirectories;

        CompleteRequest();

    }

    break;

    case EAppsInInstalledDirectories:

    {

        LOG(EJavaConverters, EInfo,

            "CRestoreConvertMIDlet::RunL EAppsInInstalledDirectories");

        GetInstallFilesL(iDirs);

        iState = EUninstallFromOMJ;

        CompleteRequest();

    }

    break;

    case EUninstallFromOMJ:

    {

        LOG(EJavaConverters, EInfo,

            "CRestoreConvertMIDlet::RunL EUninstallFromOMJ");

        // Uninstall all Java applications in current drive

        UninstallAllFromDriveL(iDrive);

        // Check all Jad / Jar files in iInstallFiles and

        // add the Uids of those MIDlets still installed into OMJ

        // to iUninstallUids

        FindRemainingMIDletsToBeUninstalledL();

        iState = EExecuteRestoreServer;

        CompleteRequest();

    }

    break;

    case EExecuteRestoreServer:

    {

        LOG(EJavaConverters, EInfo,

            "CRestoreConvertMIDlet::RunL EExecuteRestoreServer");

        if (iNumberOfAppsToInstall > 0)

        {

            // Uninstall all MIDlet suites in iUninstallUids and then

            // install all MIDlet suites in iInstallFiles.

            // Tell RestoreServer what should be uninstalled and what

            // should be converted

            iConvertServer->setOperations(iInstallFiles, iUninstallUids);

            // Start the server

            int err = iConvertServer->start();

            if (0 != err)

            {

                // server cannot be started

                ELOG1(EJavaConverters,

                      "Cannot start convert server, err %d", err);

            }

            // Starts Java Installer, waits until Java Installer exits

            RunJavaInstallerL();

            iState = EExit;

        }

        else

        {

            iState = EExit;

            CompleteRequest();

        }

    }

    break;

    case EExit:

    {

        LOG(EJavaConverters, EInfo, "CRestoreConvertMIDlet::RunL EExit");

        // Stops the server if it is running

        iConvertServer->stop();

        FullCleanup();

        // The whole javaappconverter process is stopped.

        Exit();

    }

    break;

    }

}

/**

 * To handle leave from RunL.

 * This method exits this active object using normal state machine

 * After calling this method this active object will exit.

 *

 * @param aError - A reason of error.

 * @return KErrNone.

 */

TInt CRestoreConvertMIDlet::RunError(TInt aError)

{

    ELOG2(EJavaConverters,

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

    Cancel();

    iState = EExit;

    CompleteRequest();

    return KErrNone;

}

/**

 * To do cancelling for this object.

 *

 */

void CRestoreConvertMIDlet::DoCancel()

{

    ELOG1(EJavaConverters,

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

    // Check whether restore server must be stopped

    if (iState == EExecuteRestoreServer)

    {

        // Stops the server if it is running

        iConvertServer->stop();

    }

}

/**

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

 * If a directory does not contain a .jad file but it contains a .jar/.dcf/.dm file,

 * add that file to iInstallFiles

 *

 * @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 CRestoreConvertMIDlet::GetInstallFilesL(RPointerArray<HBufC>& aDirs)

{

    // Number of MIDlet installation base directories to scan,

    // one directory per local drive

    const TInt nBaseDirs = aDirs.Count();

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

    {

        TFileName suitePath;

        // Form base directory path, MIDlets have been installed

        // to subdirectories of this directory

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

        TFileName baseSuitePath = dir;

        CDir *entryList;

        CDir *dirList;

        TInt err = iFs.GetDir(baseSuitePath, KEntryAttMatchMask, ESortNone, entryList, dirList);

        if (KErrNone != err)

        {

            WLOG1WSTR(EJavaConverters,

                      "CRestoreConvertMIDlet::GetInstallFilesL Cannot list directory %s",

                      (wchar_t *)(baseSuitePath.PtrZ()));

            // If no S60 Java application has been installed to the drive,

            // the directory does not exist but it is OK

            if (KErrPathNotFound != err)

            {

                User::Leave(err);

            }

            continue;

        }

        // Only midlet installation directory entries are meaningfull,

        // discard other possible entries

        delete entryList;

        TInt   nCount = dirList->Count();

        TEntry dirEntry;

        for (TInt nInd = 0; nInd < nCount; nInd++)

        {

            dirEntry = (*dirList)[nInd];

            // Just to make sure this really is subdirectory

            if (dirEntry.IsDir())

            {

                // Is this midlet suite subdir?

                // Midlet suite subdirs look like this "[102b567B]"

                // Must parse the value of the Uid as unsigned int to avoid

                // overflow

                TUint32 nUid;

                TLex   lexer(dirEntry.iName);

                lexer.Inc();

                err = lexer.Val(nUid, EHex);

                if (KErrNone != err)

                {

                    // Not midlet suite subdir, skip it

                    continue;

                }

                // Does the subdirectory contain any Jar files?

                suitePath = baseSuitePath;

                suitePath.Append(dirEntry.iName);

                suitePath.Append(KSMCBackSplash);

                CDir *suiteDirEntryList;

                err = iFs.GetDir(suitePath, KEntryAttMatchMask, ESortNone, suiteDirEntryList);

                if (KErrNone != err)

                {

                    LOG1WSTR(EJavaConverters, EError,

                             "CRestoreConvertMIDlet::GetInstallFilesL Cannot list content of suite dir %s",

                             (wchar_t *)(suitePath.PtrZ()));

                    User::Leave(err);

                    return;

                }

                // If there is .jad or Jar file in suiteDirEntryList, adds

                // it to iInstallFiles.

                // Recognizes also DRM protected Jar files (.dm, .dcf)

                AddJadJarToInstallFilesL(suitePath, suiteDirEntryList);

                delete suiteDirEntryList;

            }

        } // for - loop all directory entries in a base installation directories

        delete dirList;

    } // for - loop all base installation directories

    if (iInstallFiles.Count() == 0)