/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtCore module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

//#define QPROCESS_DEBUG

#ifdef QPROCESS_DEBUG

#include "qdebug.h"

#define QPROCESS_DEBUG_PRINT(args...) qDebug(args);

#else

#define QPROCESS_DEBUG_PRINT(args...)

#endif

#ifndef QT_NO_PROCESS

#define QPROCESS_ASSERT(check, panicReason, args...) \

    if (!(check)) { \

        qWarning(args); \

        User::Panic(KQProcessPanic, panicReason); \

    }

#include <exception>

#include <e32base.h>

#include <e32std.h>

#include <stdio.h>

#include "qplatformdefs.h"

#include "qdir.h"

#include "qstring.h"

#include "qprocess.h"

#include "qprocess_p.h"

#include "qeventdispatcher_symbian_p.h"

#include <private/qthread_p.h>

#include <qmutex.h>

#include <qmap.h>

#include <qsocketnotifier.h>

#include <errno.h>

QT_BEGIN_NAMESPACE

_LIT(KQProcessManagerThreadName, "QProcManThread");

_LIT(KQProcessPanic, "QPROCESS");

enum TQProcessPanic {

    EProcessManagerMediatorRunError         = 1,

    EProcessManagerMediatorInactive         = 2,

    EProcessManagerMediatorNotPending       = 3,

    EProcessManagerMediatorInvalidCmd       = 4,

    EProcessManagerMediatorCreationFailed   = 5,

    EProcessManagerMediatorThreadOpenFailed = 6,

    EProcessManagerMediatorNullObserver     = 7,

    EProcessActiveRunError                  = 10,

    EProcessActiveNullParameter             = 11,

    EProcessManagerMutexCreationFail        = 20,

    EProcessManagerThreadCreationFail       = 21,

    EProcessManagerSchedulerCreationFail    = 22,

    EProcessManagerNullParam                = 23

};

// Forward declarations

class QProcessManager;

// Active object to listen for child process death

class QProcessActive : public CActive

{

public:

    static QProcessActive *construct(QProcess *process,

                                     RProcess **proc,

                                     int serial,

                                     int deathPipe);

    virtual ~QProcessActive();

    void start();

    void stop();

    bool error();

protected:

    // Inherited from CActive

    void RunL();

    TInt RunError(TInt aError);

    void DoCancel();

    QProcessActive();

private:

    QProcess *process;

    RProcess **pproc;

    int serial;

    int deathPipe;

    bool errorValue;

};

// Active object to communicate synchronously with process manager thread

class QProcessManagerMediator : public CActive

{

public:

    static QProcessManagerMediator *construct();

    virtual ~QProcessManagerMediator();

    bool add(QProcessActive *processObserver);

    void remove(QProcessActive *processObserver);

    void terminate();

protected:

    enum Commands {

        ENoCommand,

        EAdd,

        ERemove,

        ETerminate

    };

    // Inherited from CActive

    void RunL();

    TInt RunError(TInt aError);

    void DoCancel();

    QProcessManagerMediator();

    bool notify(QProcessActive *processObserver, Commands command);

private:

    QProcessActive *currentObserver;

    Commands currentCommand;

    RThread processManagerThread;

};

// Process manager manages child process death listeners.

//

// Note: Because QProcess can be used outside event loop, we cannot be guaranteed

// an active scheduler exists for us to add our process death listener objects.

// We can't just install active scheduler on the calling thread, as that would block it

// if we want to actually use it, so a separate manager thread is required.

class QProcessManager

{

public:

    QProcessManager();

    ~QProcessManager();

    void startThread();

    TInt run(void *param);

    bool add(QProcess *process);

    void remove(QProcess *process);

    inline void setMediator(QProcessManagerMediator *newMediator) {

        mediator = newMediator;

    };

private:

    inline void lock() {

        managerMutex.Wait();

    };

    inline void unlock() {

        managerMutex.Signal();

    };

    QMap<int, QProcessActive *> children;

    QProcessManagerMediator *mediator;

    RMutex managerMutex;

    bool threadStarted;

    RThread managerThread;

};

static bool qt_rprocess_running(RProcess *proc)

{

    if (proc && proc->Handle()) {

        TExitType et = proc->ExitType();

        if (et == EExitPending)

            return true;

    }

    return false;

}

static void qt_create_symbian_commandline(const QStringList &arguments, QString &commandLine)

{

    for (int i = 0; i < arguments.size(); ++i) {

        QString tmp = arguments.at(i);

        // in the case of \" already being in the string the \ must also be escaped

        tmp.replace(QLatin1String("\\\""), QLatin1String("\\\\\""));

        // escape a single " because the arguments will be parsed

        tmp.replace(QLatin1String("\""), QLatin1String("\\\""));

        if (tmp.isEmpty() || tmp.contains(QLatin1Char(' ')) || tmp.contains(QLatin1Char('\t'))) {

            // The argument must not end with a \ since this would be interpreted

            // as escaping the quote -- rather put the \ behind the quote: e.g.

            // rather use "foo"\ than "foo\"

            QString endQuote(QLatin1String("\""));

            int i = tmp.length();

            while (i > 0 && tmp.at(i - 1) == QLatin1Char('\\')) {

                --i;

                endQuote += QLatin1String("\\");

            }

        } else {

        }

    }

}

static TInt qt_create_symbian_process(RProcess **proc, const QString &programName, const QStringList &arguments)

{

    RProcess *newProc = NULL;

    newProc = new RProcess();

    if (!newProc)

        return KErrNoMemory;

    QString commandLine;

    qt_create_symbian_commandline(arguments, commandLine);

    TPtrC program_ptr(reinterpret_cast<const TText*>(programName.constData()));

    TPtrC cmdline_ptr(reinterpret_cast<const TText*>(commandLine.constData()));

    TInt err = newProc->Create(program_ptr, cmdline_ptr);

    if (err == KErrNotFound) {

        // Strip path from program name and try again (i.e. try from default location "\sys\bin")

        int index = programName.lastIndexOf(QDir::separator());

        int index2 = programName.lastIndexOf(QChar(QLatin1Char('/')));

        index = qMax(index, index2);

        if (index != -1 && programName.length() >= index) {

            QString strippedName;

            strippedName = programName.mid(index + 1);

            QPROCESS_DEBUG_PRINT("qt_create_symbian_process() Executable '%s' not found, trying stripped version '%s'",

                                 qPrintable(programName), qPrintable(strippedName));

            TPtrC stripped_ptr(reinterpret_cast<const TText*>(strippedName.constData()));

            err = newProc->Create(stripped_ptr, cmdline_ptr);

            if (err != KErrNone) {

                QPROCESS_DEBUG_PRINT("qt_create_symbian_process() Unable to create process '%s': %d",

                                     qPrintable(strippedName), err);

            }

        }

    }

    if (err == KErrNone)

        *proc = newProc;

    else

        delete newProc;

    return err;

}

static qint64 qt_native_read(int fd, char *data, qint64 maxlen)

{

    qint64 ret = 0;

    do {

        ret = ::read(fd, data, maxlen);

    } while (ret == -1 && errno == EINTR);

    QPROCESS_DEBUG_PRINT("qt_native_read(): fd: %d, result: %d, errno = %d", fd, (int)ret, errno);

    return ret;

}

static qint64 qt_native_write(int fd, const char *data, qint64 len)

{

    qint64 ret = 0;

    do {

        ret = ::write(fd, data, len);

    } while (ret == -1 && errno == EINTR);

    QPROCESS_DEBUG_PRINT("qt_native_write(): fd: %d, result: %d, errno = %d", fd, (int)ret, errno);

    return ret;

}

static void qt_native_close(int fd)

{

    int ret;

    do {

        ret = ::close(fd);

    } while (ret == -1 && errno == EINTR);

}

static void qt_create_pipe(int *pipe)

{

    if (pipe[0] != -1)

        qt_native_close(pipe[0]);

    if (pipe[1] != -1)

        qt_native_close(pipe[1]);

    if (::pipe(pipe) != 0) {

        qWarning("QProcessPrivate::createPipe: Cannot create pipe %p: %s",

                 pipe, qPrintable(qt_error_string(errno)));

    } else {

        QPROCESS_DEBUG_PRINT("qt_create_pipe(): Created pipe %d - %d", pipe[0], pipe[1]);

    }

}

// Called from ProcessManagerThread

QProcessActive *QProcessActive::construct(QProcess *process,

                                          RProcess **proc,

                                          int serial,

                                          int deathPipe)

{

    QPROCESS_ASSERT((process || proc || *proc),

                    EProcessActiveNullParameter,

                    "QProcessActive::construct(): process (0x%x), proc (0x%x) or *proc == NULL, not creating an instance", process, proc)

    QProcessActive *newInstance = new QProcessActive();

    if (!newInstance) {

        QPROCESS_DEBUG_PRINT("QProcessActive::construct(): Failed to create new instance");

    } else {

        newInstance->process = process;

        newInstance->pproc = proc;

        newInstance->serial = serial;

        newInstance->deathPipe = deathPipe;

        newInstance->errorValue = false;

    }

    return newInstance;

}

// Called from ProcessManagerThread

QProcessActive::QProcessActive()

        : CActive(CActive::EPriorityStandard)

{

    // Nothing to do

}

// Called from ProcessManagerThread

QProcessActive::~QProcessActive()

{

    process = NULL;

    pproc = NULL;

}

// Called from ProcessManagerThread

void QProcessActive::start()

{

    if (qt_rprocess_running(*pproc)) {

        CActiveScheduler::Add(this);

        (*pproc)->Logon(iStatus);

        SetActive();

        QPROCESS_DEBUG_PRINT("QProcessActive::start(): Started monitoring for process exit.");

    } else {

        QPROCESS_DEBUG_PRINT("QProcessActive::start(): Process doesn't exist or is already dead");

        // Assume process has already died

        qt_native_write(deathPipe, "", 1);

        errorValue = true;

    }

}

// Called from ProcessManagerThread

void QProcessActive::stop()

{

    QPROCESS_DEBUG_PRINT("QProcessActive::stop()");

    // Remove this from scheduler (also cancels the request)

    Deque();

}

bool QProcessActive::error()

{

    return errorValue;

}

// Called from ProcessManagerThread

void QProcessActive::RunL()

{

    // If this method gets executed, the monitored process has died

    // Notify main thread

    qt_native_write(deathPipe, "", 1);

    QPROCESS_DEBUG_PRINT("QProcessActive::RunL() sending death notice to %d", deathPipe);

}

// Called from ProcessManagerThread

TInt QProcessActive::RunError(TInt aError)

{

    Q_UNUSED(aError);

    // Handle RunL leave (should never happen)

    QPROCESS_ASSERT(0, EProcessActiveRunError, "QProcessActive::RunError(): Should never get here!")

    return 0;

}

// Called from ProcessManagerThread

void QProcessActive::DoCancel()

{

    QPROCESS_DEBUG_PRINT("QProcessActive::DoCancel()");

    if (qt_rprocess_running(*pproc)) {

        (*pproc)->LogonCancel(iStatus);

        QPROCESS_DEBUG_PRINT("QProcessActive::DoCancel(): Stopped monitoring for process exit.");

    } else {

        QPROCESS_DEBUG_PRINT("QProcessActive::DoCancel(): Process doesn't exist");

    }

}

// Called from ProcessManagerThread

QProcessManagerMediator *QProcessManagerMediator::construct()

{

    QProcessManagerMediator *newInstance = new QProcessManagerMediator;

    TInt err(KErrNone);

    newInstance->currentCommand = ENoCommand;

    newInstance->currentObserver = NULL;

    if (newInstance) {

        err = newInstance->processManagerThread.Open(newInstance->processManagerThread.Id());

        QPROCESS_ASSERT((err == KErrNone),

                        EProcessManagerMediatorThreadOpenFailed,

                        "QProcessManagerMediator::construct(): Failed to open processManagerThread (err:%d)", err)

    } else {

        QPROCESS_ASSERT(0,

                        EProcessManagerMediatorCreationFailed,

                        "QProcessManagerMediator::construct(): Failed to open construct mediator")

    }

    // Activate mediator

    CActiveScheduler::Add(newInstance);

    newInstance->iStatus = KRequestPending;

    newInstance->SetActive();

    QPROCESS_DEBUG_PRINT("QProcessManagerMediator::construct(): new instance successfully created and activated");

    return newInstance;

}

// Called from ProcessManagerThread

QProcessManagerMediator::QProcessManagerMediator()

        : CActive(CActive::EPriorityStandard)

{

    // Nothing to do

}

// Called from ProcessManagerThread

QProcessManagerMediator::~QProcessManagerMediator()

{

    processManagerThread.Close();

    currentCommand = ENoCommand;

    currentObserver = NULL;

}

// Called from main thread

bool QProcessManagerMediator::add(QProcessActive *processObserver)

{

    QPROCESS_DEBUG_PRINT("QProcessManagerMediator::add()");

    return notify(processObserver, EAdd);

}

// Called from main thread

void QProcessManagerMediator::remove(QProcessActive *processObserver)

{

    QPROCESS_DEBUG_PRINT("QProcessManagerMediator::remove()");

    notify(processObserver, ERemove);

}

// Called from main thread

void QProcessManagerMediator::terminate()

{

    QPROCESS_DEBUG_PRINT("QProcessManagerMediator::terminate()");

    notify(NULL, ETerminate);

}

// Called from main thread

bool QProcessManagerMediator::notify(QProcessActive *processObserver, Commands command)

{

    bool success(true);

    QPROCESS_DEBUG_PRINT("QProcessManagerMediator::Notify(): Command: %d, processObserver: 0x%x", command, processObserver);

    QPROCESS_ASSERT((command == ETerminate || processObserver),

                    EProcessManagerMediatorNullObserver,

                    "QProcessManagerMediator::Notify(): NULL processObserver not allowed for command: %d", command)

    QPROCESS_ASSERT(IsActive(),

                    EProcessManagerMediatorInactive,

                    "QProcessManagerMediator::Notify(): Mediator is not active!")

    QPROCESS_ASSERT(iStatus == KRequestPending,