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

**

** Copyright (C) 2009 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

#if defined QPROCESS_DEBUG

#include <qdebug.h>

#include <qstring.h>

#include <ctype.h>

#if !defined(Q_OS_WINCE)

#include <errno.h>

#endif

QT_BEGIN_NAMESPACE

/*

    Returns a human readable representation of the first \a len

    characters in \a data.

*/

static QByteArray qt_prettyDebug(const char *data, int len, int maxSize)

{

    if (!data) return "(null)";

    QByteArray out;

    for (int i = 0; i < len && i < maxSize; ++i) {

        char c = data[i];

        if (isprint(c)) {

            out += c;

        } else switch (c) {

        case '\n': out += "\\n"; break;

        case '\r': out += "\\r"; break;

        case '\t': out += "\\t"; break;

        default:

            char buf[5];

            qsnprintf(buf, sizeof(buf), "\\%3o", c);

            buf[4] = '\0';

            out += QByteArray(buf);

        }

    }

    if (len < maxSize)

        out += "...";

    return out;

}

QT_END_NAMESPACE

#endif

#include "qprocess.h"

#include "qprocess_p.h"

#include <qbytearray.h>

#include <qdatetime.h>

#include <qcoreapplication.h>

#include <qsocketnotifier.h>

#include <qtimer.h>

#ifdef Q_WS_WIN

#include <private/qwineventnotifier_p.h>

#endif

#ifdef Q_OS_SYMBIAN

#include <e32std.h>

#endif

#ifndef QT_NO_PROCESS

QT_BEGIN_NAMESPACE

/*!

    \class QProcessEnvironment

    \brief The QProcessEnvironment class holds the environment variables that

    can be passed to a program.

    \ingroup io

    \ingroup misc

    \mainclass

    \reentrant

    \since 4.6

    A process's environment is composed of a set of key=value pairs known as

    environment variables. The QProcessEnvironment class wraps that concept

    and allows easy manipulation of those variables. It's meant to be used

    along with QProcess, to set the environment for child processes. It

    cannot be used to change the current process's environment.

    The environment of the calling process can be obtained using

    QProcessEnvironment::systemEnvironment().

    On Unix systems, the variable names are case-sensitive. For that reason,

    this class will not touch the names of the variables. Note as well that

    Unix environment allows both variable names and contents to contain arbitrary

    binary data (except for the NUL character), but this is not supported by

    QProcessEnvironment. This class only supports names and values that are

    encodable by the current locale settings (see QTextCodec::codecForLocale).

    On Windows, the variable names are case-insensitive. Therefore,

    QProcessEnvironment will always uppercase the names and do case-insensitive

    comparisons.

    On Windows CE, the concept of environment does not exist. This class will

    keep the values set for compatibility with other platforms, but the values

    set will have no effect on the processes being created.

    \sa QProcess, QProcess::systemEnvironment(), QProcess::setProcessEnvironment()

*/

#ifdef Q_OS_WIN

static inline QProcessEnvironmentPrivate::Unit prepareName(const QString &name)

{ return name.toUpper(); }

static inline QProcessEnvironmentPrivate::Unit prepareName(const QByteArray &name)

{ return QString::fromLocal8Bit(name).toUpper(); }

static inline QString nameToString(const QProcessEnvironmentPrivate::Unit &name)

{ return name; }

static inline QProcessEnvironmentPrivate::Unit prepareValue(const QString &value)

{ return value; }

static inline QProcessEnvironmentPrivate::Unit prepareValue(const QByteArray &value)

{ return QString::fromLocal8Bit(value); }

static inline QString valueToString(const QProcessEnvironmentPrivate::Unit &value)

{ return value; }

static inline QByteArray valueToByteArray(const QProcessEnvironmentPrivate::Unit &value)

{ return value.toLocal8Bit(); }

#else

static inline QProcessEnvironmentPrivate::Unit prepareName(const QByteArray &name)

{ return name; }

static inline QProcessEnvironmentPrivate::Unit prepareName(const QString &name)

{ return name.toLocal8Bit(); }

static inline QString nameToString(const QProcessEnvironmentPrivate::Unit &name)

{ return QString::fromLocal8Bit(name); }

static inline QProcessEnvironmentPrivate::Unit prepareValue(const QByteArray &value)

{ return value; }

static inline QProcessEnvironmentPrivate::Unit prepareValue(const QString &value)

{ return value.toLocal8Bit(); }

static inline QString valueToString(const QProcessEnvironmentPrivate::Unit &value)

{ return QString::fromLocal8Bit(value); }

static inline QByteArray valueToByteArray(const QProcessEnvironmentPrivate::Unit &value)

{ return value; }

#endif

template<> void QSharedDataPointer<QProcessEnvironmentPrivate>::detach()

{

    if (d && d->ref == 1)

        return;

    QProcessEnvironmentPrivate *x = (d ? new QProcessEnvironmentPrivate(*d)

                                     : new QProcessEnvironmentPrivate);

    x->ref.ref();

    if (d && !d->ref.deref())

        delete d;

    d = x;

}

QStringList QProcessEnvironmentPrivate::toList() const

{

    QStringList result;

    QHash<Unit, Unit>::ConstIterator it = hash.constBegin(),

                                    end = hash.constEnd();

    for ( ; it != end; ++it) {

        QString data = nameToString(it.key());

        QString value = valueToString(it.value());

        data.reserve(data.length() + value.length() + 1);

        data.append(QLatin1Char('='));

        data.append(value);

        result << data;

    }

    return result;

}

QProcessEnvironment QProcessEnvironmentPrivate::fromList(const QStringList &list)

{

    QProcessEnvironment env;

    QStringList::ConstIterator it = list.constBegin(),

                              end = list.constEnd();

    for ( ; it != end; ++it) {

        int pos = it->indexOf(QLatin1Char('='));

        if (pos < 1)

            continue;

        QString value = it->mid(pos + 1);

        QString name = *it;

        name.truncate(pos);

        env.insert(name, value);

    }

    return env;

}

/*!

    Creates a new QProcessEnvironment object. This constructor creates an

    empty environment. If set on a QProcess, this will cause the current

    environment variables to be removed.

*/

QProcessEnvironment::QProcessEnvironment()

    : d(0)

{

}

/*!

    Frees the resources associated with this QProcessEnvironment object.

*/

QProcessEnvironment::~QProcessEnvironment()

{

}

/*!

    Creates a QProcessEnvironment object that is a copy of \a other.

*/

QProcessEnvironment::QProcessEnvironment(const QProcessEnvironment &other)

    : d(other.d)

{

}

/*!

    Copies the contents of the \a other QProcessEnvironment object into this

    one.

*/

QProcessEnvironment &QProcessEnvironment::operator=(const QProcessEnvironment &other)

{

    d = other.d;

    return *this;

}

/*!

    \fn bool QProcessEnvironment::operator !=(const QProcessEnvironment &other) const

    Returns true if this and the \a other QProcessEnvironment objects are different.

    \sa operator==()

*/

/*!

    Returns true if this and the \a other QProcessEnvironment objects are equal.

    Two QProcessEnvironment objects are considered equal if they have the same

    set of key=value pairs. The comparison of keys is done case-sensitive on

    platforms where the environment is case-sensitive.

    \sa operator!=(), contains()

*/

bool QProcessEnvironment::operator==(const QProcessEnvironment &other) const

{

}

/*!

    Returns true if this QProcessEnvironment object is empty: that is

    there are no key=value pairs set.

    \sa clear(), systemEnvironment(), insert()

*/

bool QProcessEnvironment::isEmpty() const

{

    return d ? d->hash.isEmpty() : true;

}

/*!

    Removes all key=value pairs from this QProcessEnvironment object, making

    it empty.

    \sa isEmpty(), systemEnvironment()

*/

void QProcessEnvironment::clear()

{

    if (d)

        d->hash.clear();

}

/*!

    Returns true if the environment variable of name \a name is found in

    this QProcessEnvironment object.

    On Windows, variable names are case-insensitive, so the key is converted

    to uppercase before searching. On other systems, names are case-sensitive

    so no trasformation is applied.

    \sa insert(), value()

*/

bool QProcessEnvironment::contains(const QString &name) const

{

    return d ? d->hash.contains(prepareName(name)) : false;

}

/*!

    Inserts the environment variable of name \a name and contents \a value

    into this QProcessEnvironment object. If that variable already existed,

    it is replaced by the new value.

    On Windows, variable names are case-insensitive, so this function always

    uppercases the variable name before inserting. On other systems, names

    are case-sensitive, so no transformation is applied.

    On most systems, inserting a variable with no contents will have the

    same effect for applications as if the variable had not been set at all.

    However, to guarantee that there are no incompatibilities, to remove a

    variable, please use the remove() function.

    \sa contains(), remove(), value()

*/

void QProcessEnvironment::insert(const QString &name, const QString &value)

{

    d->hash.insert(prepareName(name), prepareValue(value));

}

/*!

    Removes the environment variable identified by \a name from this

    QProcessEnvironment object. If that variable did not exist before,

    nothing happens.

    On Windows, variable names are case-insensitive, so the key is converted

    to uppercase before searching. On other systems, names are case-sensitive

    so no trasformation is applied.

    \sa contains(), insert(), value()

*/

void QProcessEnvironment::remove(const QString &name)

{

    if (d)

        d->hash.remove(prepareName(name));

}

/*!

    Searches this QProcessEnvironment object for a variable identified by

    \a name and returns its value. If the variable is not found in this object,

    then \a defaultValue is returned instead.

    On Windows, variable names are case-insensitive, so the key is converted

    to uppercase before searching. On other systems, names are case-sensitive

    so no trasformation is applied.

    \sa contains(), insert(), remove()

*/

QString QProcessEnvironment::value(const QString &name, const QString &defaultValue) const

{

    if (!d)

        return defaultValue;

    QProcessEnvironmentPrivate::Hash::ConstIterator it = d->hash.constFind(prepareName(name));

    if (it == d->hash.constEnd())

        return defaultValue;

    return valueToString(it.value());

}

/*!

    Converts this QProcessEnvironment object into a list of strings, one for

    each environment variable that is set. The environment variable's name

    and its value are separated by an equal character ('=').

    The QStringList contents returned by this function are suitable for use

    with the QProcess::setEnvironment function. However, it is recommended

    to use QProcess::setProcessEnvironment instead since that will avoid

    unnecessary copying of the data.

    \sa systemEnvironment(), QProcess::systemEnvironment(), QProcess::environment(),

        QProcess::setEnvironment()

*/

QStringList QProcessEnvironment::toStringList() const

{

    return d ? d->toList() : QStringList();

}

void QProcessPrivate::Channel::clear()

{

    switch (type) {

    case PipeSource:

        Q_ASSERT(process);

        process->stdinChannel.type = Normal;

        process->stdinChannel.process = 0;

        break;

    case PipeSink:

        Q_ASSERT(process);

        process->stdoutChannel.type = Normal;

        process->stdoutChannel.process = 0;

        break;

    }

    type = Normal;

    file.clear();

    process = 0;

}

/*! \fn bool QProcessPrivate::startDetached(const QString &program, const QStringList &arguments, const QString &workingDirectory, qint64 *pid)

\internal

 */

/*!

    \class QProcess

    \brief The QProcess class is used to start external programs and

    to communicate with them.

    \ingroup io

    \reentrant

    \section1 Running a Process

    To start a process, pass the name and command line arguments of

    the program you want to run as arguments to start(). Arguments

    are supplied as individual strings in a QStringList.

    For example, the following code snippet runs the analog clock

    example in the Motif style on X11 platforms by passing strings

    containing "-style" and "motif" as two items in the list of

    arguments:

    \snippet doc/src/snippets/qprocess/qprocess-simpleexecution.cpp 0

    \dots

    \snippet doc/src/snippets/qprocess/qprocess-simpleexecution.cpp 1

    \snippet doc/src/snippets/qprocess/qprocess-simpleexecution.cpp 2

    QProcess then enters the \l Starting state, and when the program

    has started, QProcess enters the \l Running state and emits

    started().

    QProcess allows you to treat a process as a sequential I/O

    device. You can write to and read from the process just as you

    would access a network connection using QTcpSocket. You can then

    write to the process's standard input by calling write(), and

    read the standard output by calling read(), readLine(), and

    getChar(). Because it inherits QIODevice, QProcess can also be

    used as an input source for QXmlReader, or for generating data to

    be uploaded using QFtp.

    \note On Windows CE and Symbian, reading and writing to a process

    is not supported.

    When the process exits, QProcess reenters the \l NotRunning state

    (the initial state), and emits finished().

    The finished() signal provides the exit code and exit status of

    the process as arguments, and you can also call exitCode() to

    obtain the exit code of the last process that finished, and

    exitStatus() to obtain its exit status. If an error occurs at

    any point in time, QProcess will emit the error() signal. You

    can also call error() to find the type of error that occurred

    last, and state() to find the current process state.

    \section1 Communicating via Channels

    Processes have two predefined output channels: The standard

    output channel (\c stdout) supplies regular console output, and

    the standard error channel (\c stderr) usually supplies the

    errors that are printed by the process. These channels represent

    two separate streams of data. You can toggle between them by

    calling setReadChannel(). QProcess emits readyRead() when data is

    available on the current read channel. It also emits

    readyReadStandardOutput() when new standard output data is

    available, and when new standard error data is available,

    readyReadStandardError() is emitted. Instead of calling read(),

    readLine(), or getChar(), you can explicitly read all data from

    either of the two channels by calling readAllStandardOutput() or

    readAllStandardError().

    The terminology for the channels can be misleading. Be aware that

    the process's output channels correspond to QProcess's

    \e read channels, whereas the process's input channels correspond

    to QProcess's \e write channels. This is because what we read

    using QProcess is the process's output, and what we write becomes

    the process's input.

    QProcess can merge the two output channels, so that standard

    output and standard error data from the running process both use

    the standard output channel. Call setProcessChannelMode() with

    MergedChannels before starting the process to activative

    this feature. You also have the option of forwarding the output of

    the running process to the calling, main process, by passing

    ForwardedChannels as the argument.

    Certain processes need special environment settings in order to

    operate. You can set environment variables for your process by

    calling setEnvironment(). To set a working directory, call

    setWorkingDirectory(). By default, processes are run in the

    current working directory of the calling process.

    \note On Symbian, setting environment or working directory

    is not supported. The working directory will always be the private

    directory of the running process.

    \section1 Synchronous Process API

    QProcess provides a set of functions which allow it to be used

    without an event loop, by suspending the calling thread until

    certain signals are emitted:

    \list

    \o waitForStarted() blocks until the process has started.

    \o waitForReadyRead() blocks until new data is

    available for reading on the current read channel.