1 /****************************************************************************

     2 **

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

     4 ** All rights reserved.

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

     6 **

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

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

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

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

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

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

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

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

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

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

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

    23 **

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

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

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

    27 **

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

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

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 //#define QPROCESS_DEBUG

    43 

    44 #if defined QPROCESS_DEBUG

    45 #include <qdebug.h>

    46 #include <qstring.h>

    47 #include <ctype.h>

    48 #if !defined(Q_OS_WINCE)

    49 #include <errno.h>

    50 #endif

    51 

    52 QT_BEGIN_NAMESPACE

    53 /*

    54     Returns a human readable representation of the first \a len

    55     characters in \a data.

    56 */

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

    58 {

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

    60     QByteArray out;

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

    62         char c = data[i];

    63         if (isprint(c)) {

    64             out += c;

    65         } else switch (c) {

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

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

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

    69         default:

    70             char buf[5];

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

    72             buf[4] = '\0';

    73             out += QByteArray(buf);

    74         }

    75     }

    76 

    77     if (len < maxSize)

    78         out += "...";

    79 

    80     return out;

    81 }

    82 

    83 QT_END_NAMESPACE

    84 

    85 #endif

    86 

    87 #include "qprocess.h"

    88 #include "qprocess_p.h"

    89 

    90 #include <qbytearray.h>

    91 #include <qdatetime.h>

    92 #include <qcoreapplication.h>

    93 #include <qsocketnotifier.h>

    94 #include <qtimer.h>

    95 

    96 #ifdef Q_WS_WIN

    97 #include <private/qwineventnotifier_p.h>

    98 #endif

    99 

   100 #ifdef Q_OS_SYMBIAN

   101 #include <e32std.h>

   102 #endif

   103 

   104 #ifndef QT_NO_PROCESS

   105 

   106 QT_BEGIN_NAMESPACE

   107 

   108 /*!

   109     \class QProcessEnvironment

   110 

   111     \brief The QProcessEnvironment class holds the environment variables that

   112     can be passed to a program.

   113 

   114     \ingroup io

   115     \ingroup misc

   116     \mainclass

   117     \reentrant

   118     \since 4.6

   119 

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

   121     environment variables. The QProcessEnvironment class wraps that concept

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

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

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

   125 

   126     The environment of the calling process can be obtained using

   127     QProcessEnvironment::systemEnvironment().

   128 

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

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

   131     Unix environment allows both variable names and contents to contain arbitrary

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

   133     QProcessEnvironment. This class only supports names and values that are

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

   135 

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

   137     QProcessEnvironment will always uppercase the names and do case-insensitive

   138     comparisons.

   139 

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

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

   142     set will have no effect on the processes being created.

   143 

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

   145 */

   146 #ifdef Q_OS_WIN

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

   148 { return name.toUpper(); }

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

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

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

   152 { return name; }

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

   154 { return value; }

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

   156 { return QString::fromLocal8Bit(value); }

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

   158 { return value; }

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

   160 { return value.toLocal8Bit(); }

   161 #else

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

   163 { return name; }

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

   165 { return name.toLocal8Bit(); }

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

   167 { return QString::fromLocal8Bit(name); }

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

   169 { return value; }

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

   171 { return value.toLocal8Bit(); }

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

   173 { return QString::fromLocal8Bit(value); }

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

   175 { return value; }

   176 #endif

   177 

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

   179 {

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

   181         return;

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

   183                                      : new QProcessEnvironmentPrivate);

   184     x->ref.ref();

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

   186         delete d;

   187     d = x;

   188 }

   189 

   190 QStringList QProcessEnvironmentPrivate::toList() const

   191 {

   192     QStringList result;

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

   194                                     end = hash.constEnd();

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

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

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

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

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

   200         data.append(value);

   201         result << data;

   202     }

   203     return result;

   204 }

   205 

   206 QProcessEnvironment QProcessEnvironmentPrivate::fromList(const QStringList &list)

   207 {

   208     QProcessEnvironment env;

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

   210                               end = list.constEnd();

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

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

   213         if (pos < 1)

   214             continue;

   215 

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

   217         QString name = *it;

   218         name.truncate(pos);

   219         env.insert(name, value);

   220     }

   221     return env;

   222 }

   223 

   224 /*!

   225     Creates a new QProcessEnvironment object. This constructor creates an

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

   227     environment variables to be removed.

   228 */

   229 QProcessEnvironment::QProcessEnvironment()

   230     : d(0)

   231 {

   232 }

   233 

   234 /*!

   235     Frees the resources associated with this QProcessEnvironment object.

   236 */

   237 QProcessEnvironment::~QProcessEnvironment()

   238 {

   239 }

   240 

   241 /*!

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

   243 */

   244 QProcessEnvironment::QProcessEnvironment(const QProcessEnvironment &other)

   245     : d(other.d)

   246 {

   247 }

   248 

   249 /*!

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

   251     one.

   252 */

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

   254 {

   255     d = other.d;

   256     return *this;

   257 }

   258 

   259 /*!

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

   261 

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

   263 

   264     \sa operator==()

   265 */

   266 

   267 /*!

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

   269 

   270     Two QProcessEnvironment objects are considered equal if they have the same

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

   272     platforms where the environment is case-sensitive.

   273 

   274     \sa operator!=(), contains()

   275 */

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

   277 {

   278     return d->hash == other.d->hash;

   279 }

   280 

   281 /*!

   282     Returns true if this QProcessEnvironment object is empty: that is

   283     there are no key=value pairs set.

   284 

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

   286 */

   287 bool QProcessEnvironment::isEmpty() const

   288 {

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

   290 }

   291 

   292 /*!

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

   294     it empty.

   295 

   296     \sa isEmpty(), systemEnvironment()

   297 */

   298 void QProcessEnvironment::clear()

   299 {

   300     if (d)

   301         d->hash.clear();

   302 }

   303 

   304 /*!

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

   306     this QProcessEnvironment object.

   307 

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

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

   310     so no trasformation is applied.

   311 

   312     \sa insert(), value()

   313 */

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

   315 {

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

   317 }

   318 

   319 /*!

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

   321     into this QProcessEnvironment object. If that variable already existed,

   322     it is replaced by the new value.

   323 

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

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

   326     are case-sensitive, so no transformation is applied.

   327 

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

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

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

   331     variable, please use the remove() function.

   332 

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

   334 */

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

   336 {

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

   338 }

   339 

   340 /*!

   341     Removes the environment variable identified by \a name from this

   342     QProcessEnvironment object. If that variable did not exist before,

   343     nothing happens.

   344 

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

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

   347     so no trasformation is applied.

   348 

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

   350 */

   351 void QProcessEnvironment::remove(const QString &name)

   352 {

   353     if (d)

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

   355 }

   356 

   357 /*!

   358     Searches this QProcessEnvironment object for a variable identified by

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

   360     then \a defaultValue is returned instead.

   361 

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

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

   364     so no trasformation is applied.

   365 

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

   367 */

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

   369 {

   370     if (!d)

   371         return defaultValue;

   372 

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

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

   375         return defaultValue;

   376 

   377     return valueToString(it.value());

   378 }

   379 

   380 /*!

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

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

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

   384 

   385     The QStringList contents returned by this function are suitable for use

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

   387     to use QProcess::setProcessEnvironment instead since that will avoid

   388     unnecessary copying of the data.

   389 

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

   391         QProcess::setEnvironment()

   392 */

   393 QStringList QProcessEnvironment::toStringList() const

   394 {

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

   396 }

   397 

   398 void QProcessPrivate::Channel::clear()

   399 {

   400     switch (type) {

   401     case PipeSource:

   402         Q_ASSERT(process);

   403         process->stdinChannel.type = Normal;

   404         process->stdinChannel.process = 0;

   405         break;

   406     case PipeSink:

   407         Q_ASSERT(process);

   408         process->stdoutChannel.type = Normal;

   409         process->stdoutChannel.process = 0;

   410         break;

   411     }

   412 

   413     type = Normal;

   414     file.clear();

   415     process = 0;

   416 }

   417 

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

   419 

   420 \internal

   421  */

   422 

   423 /*!

   424     \class QProcess

   425 

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

   427     to communicate with them.

   428 

   429     \ingroup io

   430 

   431     \reentrant

   432 

   433     \section1 Running a Process

   434 

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

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

   437     are supplied as individual strings in a QStringList.

   438 

   439     For example, the following code snippet runs the analog clock

   440     example in the Motif style on X11 platforms by passing strings

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

   442     arguments:

   443 

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

   445     \dots

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

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

   448 

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

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

   451     started().

   452 

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

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

   455     would access a network connection using QTcpSocket. You can then

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

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

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

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

   460     be uploaded using QFtp.

   461 

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

   463     is not supported.

   464 

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

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

   467 

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

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

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

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

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

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

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

   475 

   476     \section1 Communicating via Channels

   477 

   478     Processes have two predefined output channels: The standard

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

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

   481     errors that are printed by the process. These channels represent

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

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

   484     available on the current read channel. It also emits

   485     readyReadStandardOutput() when new standard output data is

   486     available, and when new standard error data is available,

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

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

   489     either of the two channels by calling readAllStandardOutput() or

   490     readAllStandardError().

   491 

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

   493     the process's output channels correspond to QProcess's

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

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

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

   497     the process's input.

   498 

   499     QProcess can merge the two output channels, so that standard

   500     output and standard error data from the running process both use

   501     the standard output channel. Call setProcessChannelMode() with

   502     MergedChannels before starting the process to activative

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

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

   505     ForwardedChannels as the argument.

   506 

   507     Certain processes need special environment settings in order to

   508     operate. You can set environment variables for your process by

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

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

   511     current working directory of the calling process.

   512 

   513     \note On Symbian, setting environment or working directory

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

   515     directory of the running process.

   516 

   517     \section1 Synchronous Process API

   518 

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

   520     without an event loop, by suspending the calling thread until

   521     certain signals are emitted:

   522 

   523     \list

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

   525 

   526     \o waitForReadyRead() blocks until new data is

   527     available for reading on the current read channel.

   528 

   529     \o waitForBytesWritten() blocks until one payload of

   530     data has been written to the process.

   531 

   532     \o waitForFinished() blocks until the process has finished.

   533     \endlist

   534 

   535     Calling these functions from the main thread (the thread that

   536     calls QApplication::exec()) may cause your user interface to

   537     freeze.

   538 

   539     The following example runs \c gzip to compress the string "Qt

   540     rocks!", without an event loop:

   541 

   542     \snippet doc/src/snippets/process/process.cpp 0

   543 

   544     \section1 Notes for Windows Users

   545 

   546     Some Windows commands (for example, \c dir) are not provided by

   547     separate applications, but by the command interpreter itself.

   548     If you attempt to use QProcess to execute these commands directly,

   549     it won't work. One possible solution is to execute the command

   550     interpreter itself (\c{cmd.exe} on some Windows systems), and ask

   551     the interpreter to execute the desired command.

   552 

   553     \sa QBuffer, QFile, QTcpSocket

   554 */

   555 

   556 /*!

   557     \enum QProcess::ProcessChannel

   558 

   559     This enum describes the process channels used by the running process.

   560     Pass one of these values to setReadChannel() to set the

   561     current read channel of QProcess.

   562 

   563     \value StandardOutput The standard output (stdout) of the running

   564            process.

   565 

   566     \value StandardError The standard error (stderr) of the running

   567            process.

   568 

   569     \sa setReadChannel()

   570 */

   571 

   572 /*!

   573     \enum QProcess::ProcessChannelMode

   574 

   575     This enum describes the process channel modes of QProcess. Pass

   576     one of these values to setProcessChannelMode() to set the

   577     current read channel mode.

   578 

   579     \value SeparateChannels QProcess manages the output of the

   580     running process, keeping standard output and standard error data

   581     in separate internal buffers. You can select the QProcess's

   582     current read channel by calling setReadChannel(). This is the

   583     default channel mode of QProcess.

   584 

   585     \value MergedChannels QProcess merges the output of the running

   586     process into the standard output channel (\c stdout). The

   587     standard error channel (\c stderr) will not receive any data. The

   588     standard output and standard error data of the running process

   589     are interleaved.

   590 

   591     \value ForwardedChannels QProcess forwards the output of the

   592     running process onto the main process. Anything the child process

   593     writes to its standard output and standard error will be written

   594     to the standard output and standard error of the main process.

   595 

   596     \sa setProcessChannelMode()

   597 */

   598 

   599 /*!

   600     \enum QProcess::ProcessError

   601 

   602     This enum describes the different types of errors that are

   603     reported by QProcess.

   604 

   605     \value FailedToStart The process failed to start. Either the

   606     invoked program is missing, or you may have insufficient

   607     permissions to invoke the program.

   608 

   609     \value Crashed The process crashed some time after starting

   610     successfully.

   611 

   612     \value Timedout The last waitFor...() function timed out. The

   613     state of QProcess is unchanged, and you can try calling

   614     waitFor...() again.

   615 

   616     \value WriteError An error occurred when attempting to write to the

   617     process. For example, the process may not be running, or it may

   618     have closed its input channel.

   619 

   620     \value ReadError An error occurred when attempting to read from

   621     the process. For example, the process may not be running.

   622 

   623     \value UnknownError An unknown error occurred. This is the default

   624     return value of error().

   625 

   626     \sa error()

   627 */

   628 

   629 /*!

   630     \enum QProcess::ProcessState

   631 

   632     This enum describes the different states of QProcess.

   633 

   634     \value NotRunning The process is not running.

   635 

   636     \value Starting The process is starting, but the program has not

   637     yet been invoked.

   638 

   639     \value Running The process is running and is ready for reading and

   640     writing.

   641 

   642     \sa state()

   643 */

   644 

   645 /*!

   646     \enum QProcess::ExitStatus

   647 

   648     This enum describes the different exit statuses of QProcess.

   649 

   650     \value NormalExit The process exited normally.

   651 

   652     \value CrashExit The process crashed.

   653 

   654     \sa exitStatus()

   655 */

   656 

   657 /*!

   658     \fn void QProcess::error(QProcess::ProcessError error)

   659 

   660     This signal is emitted when an error occurs with the process. The

   661     specified \a error describes the type of error that occurred.

   662 */

   663 

   664 /*!

   665     \fn void QProcess::started()

   666 

   667     This signal is emitted by QProcess when the process has started,

   668     and state() returns \l Running.

   669 */

   670 

   671 /*!

   672     \fn void QProcess::stateChanged(QProcess::ProcessState newState)

   673 

   674     This signal is emitted whenever the state of QProcess changes. The

   675     \a newState argument is the state QProcess changed to.

   676 */

   677 

   678 /*!

   679     \fn void QProcess::finished(int exitCode)

   680     \obsolete

   681     \overload

   682 

   683     Use finished(int exitCode, QProcess::ExitStatus status) instead.

   684 */

   685 

   686 /*!

   687     \fn void QProcess::finished(int exitCode, QProcess::ExitStatus exitStatus)

   688 

   689     This signal is emitted when the process finishes. \a exitCode is the exit

   690     code of the process, and \a exitStatus is the exit status.  After the

   691     process has finished, the buffers in QProcess are still intact. You can

   692     still read any data that the process may have written before it finished.

   693 

   694     \sa exitStatus()

   695 */

   696 

   697 /*!

   698     \fn void QProcess::readyReadStandardOutput()

   699 

   700     This signal is emitted when the process has made new data

   701     available through its standard output channel (\c stdout). It is

   702     emitted regardless of the current \l{readChannel()}{read channel}.

   703 

   704     \sa readAllStandardOutput(), readChannel()

   705 */

   706 

   707 /*!

   708     \fn void QProcess::readyReadStandardError()

   709 

   710     This signal is emitted when the process has made new data

   711     available through its standard error channel (\c stderr). It is

   712     emitted regardless of the current \l{readChannel()}{read

   713     channel}.

   714 

   715     \sa readAllStandardError(), readChannel()

   716 */

   717 

   718 /*! \internal

   719 */

   720 QProcessPrivate::QProcessPrivate()

   721 {

   722     processChannel = QProcess::StandardOutput;

   723     processChannelMode = QProcess::SeparateChannels;

   724     processError = QProcess::UnknownError;

   725     processState = QProcess::NotRunning;

   726     pid = 0;

   727     sequenceNumber = 0;

   728     exitCode = 0;

   729     exitStatus = QProcess::NormalExit;

   730     startupSocketNotifier = 0;

   731     deathNotifier = 0;

   732     notifier = 0;

   733     pipeWriter = 0;

   734     childStartedPipe[0] = INVALID_Q_PIPE;

   735     childStartedPipe[1] = INVALID_Q_PIPE;

   736     deathPipe[0] = INVALID_Q_PIPE;

   737     deathPipe[1] = INVALID_Q_PIPE;

   738     exitCode = 0;

   739     crashed = false;

   740     dying = false;

   741     emittedReadyRead = false;

   742     emittedBytesWritten = false;

   743 #ifdef Q_WS_WIN

   744     pipeWriter = 0;

   745     processFinishedNotifier = 0;

   746 #endif // Q_WS_WIN

   747 #ifdef Q_OS_UNIX

   748     serial = 0;

   749 #endif

   750 #ifdef Q_OS_SYMBIAN

   751     symbianProcess = NULL;

   752     processLaunched = false;

   753 #endif

   754 }

   755 

   756 /*! \internal

   757 */

   758 QProcessPrivate::~QProcessPrivate()

   759 {

   760     if (stdinChannel.process)

   761         stdinChannel.process->stdoutChannel.clear();

   762     if (stdoutChannel.process)

   763         stdoutChannel.process->stdinChannel.clear();

   764 }

   765 

   766 /*! \internal

   767 */

   768 void QProcessPrivate::cleanup()

   769 {

   770     q_func()->setProcessState(QProcess::NotRunning);

   771 #ifdef Q_OS_WIN

   772     if (pid) {

   773         CloseHandle(pid->hThread);

   774         CloseHandle(pid->hProcess);

   775         delete pid;

   776         pid = 0;

   777     }

   778     if (processFinishedNotifier) {

   779         processFinishedNotifier->setEnabled(false);

   780         qDeleteInEventHandler(processFinishedNotifier);

   781         processFinishedNotifier = 0;

   782     }

   783 

   784 #endif

   785     pid = 0;

   786     sequenceNumber = 0;

   787     dying = false;

   788 

   789     if (stdoutChannel.notifier) {

   790         stdoutChannel.notifier->setEnabled(false);

   791         qDeleteInEventHandler(stdoutChannel.notifier);

   792         stdoutChannel.notifier = 0;

   793     }

   794     if (stderrChannel.notifier) {

   795         stderrChannel.notifier->setEnabled(false);

   796         qDeleteInEventHandler(stderrChannel.notifier);

   797         stderrChannel.notifier = 0;

   798     }

   799     if (stdinChannel.notifier) {

   800         stdinChannel.notifier->setEnabled(false);

   801         qDeleteInEventHandler(stdinChannel.notifier);

   802         stdinChannel.notifier = 0;

   803     }

   804     if (startupSocketNotifier) {

   805         startupSocketNotifier->setEnabled(false);

   806         qDeleteInEventHandler(startupSocketNotifier);

   807         startupSocketNotifier = 0;

   808     }

   809     if (deathNotifier) {

   810         deathNotifier->setEnabled(false);

   811         qDeleteInEventHandler(deathNotifier);

   812         deathNotifier = 0;

   813     }

   814     if (notifier) {

   815         qDeleteInEventHandler(notifier);

   816         notifier = 0;

   817     }

   818     destroyPipe(stdoutChannel.pipe);

   819     destroyPipe(stderrChannel.pipe);

   820     destroyPipe(stdinChannel.pipe);

   821     destroyPipe(childStartedPipe);

   822     destroyPipe(deathPipe);

   823 #ifdef Q_OS_UNIX

   824     serial = 0;

   825 #endif

   826 #ifdef Q_OS_SYMBIAN

   827     if (symbianProcess) {

   828         symbianProcess->Close();

   829         delete symbianProcess;

   830         symbianProcess = NULL;

   831     }

   832 #endif

   833 }

   834 

   835 /*! \internal

   836 */

   837 bool QProcessPrivate::_q_canReadStandardOutput()

   838 {

   839     Q_Q(QProcess);

   840     qint64 available = bytesAvailableFromStdout();

   841     if (available == 0) {

   842         if (stdoutChannel.notifier)

   843             stdoutChannel.notifier->setEnabled(false);

   844         destroyPipe(stdoutChannel.pipe);

   845 #if defined QPROCESS_DEBUG

   846         qDebug("QProcessPrivate::canReadStandardOutput(), 0 bytes available");

   847 #endif

   848         return false;

   849     }

   850 

   851     char *ptr = outputReadBuffer.reserve(available);

   852     qint64 readBytes = readFromStdout(ptr, available);

   853     if (readBytes == -1) {

   854         processError = QProcess::ReadError;

   855         q->setErrorString(QProcess::tr("Error reading from process"));

   856         emit q->error(processError);

   857 #if defined QPROCESS_DEBUG

   858         qDebug("QProcessPrivate::canReadStandardOutput(), failed to read from the process");

   859 #endif

   860         return false;

   861     }

   862 #if defined QPROCESS_DEBUG

   863     qDebug("QProcessPrivate::canReadStandardOutput(), read %d bytes from the process' output",

   864             int(readBytes));

   865 #endif

   866 

   867     if (stdoutChannel.closed) {

   868         outputReadBuffer.chop(readBytes);

   869         return false;

   870     }

   871 

   872     outputReadBuffer.chop(available - readBytes);

   873 

   874     bool didRead = false;

   875     if (readBytes == 0) {

   876         if (stdoutChannel.notifier)

   877             stdoutChannel.notifier->setEnabled(false);

   878     } else if (processChannel == QProcess::StandardOutput) {

   879         didRead = true;

   880         if (!emittedReadyRead) {

   881             emittedReadyRead = true;

   882             emit q->readyRead();

   883             emittedReadyRead = false;

   884         }

   885     }

   886     emit q->readyReadStandardOutput();

   887     return didRead;

   888 }

   889 

   890 /*! \internal

   891 */

   892 bool QProcessPrivate::_q_canReadStandardError()

   893 {

   894     Q_Q(QProcess);

   895     qint64 available = bytesAvailableFromStderr();

   896     if (available == 0) {

   897         if (stderrChannel.notifier)

   898             stderrChannel.notifier->setEnabled(false);

   899         destroyPipe(stderrChannel.pipe);

   900         return false;

   901     }

   902 

   903     char *ptr = errorReadBuffer.reserve(available);

   904     qint64 readBytes = readFromStderr(ptr, available);

   905     if (readBytes == -1) {

   906         processError = QProcess::ReadError;

   907         q->setErrorString(QProcess::tr("Error reading from process"));

   908         emit q->error(processError);

   909         return false;

   910     }

   911     if (stderrChannel.closed) {

   912         errorReadBuffer.chop(readBytes);

   913         return false;

   914     }

   915 

   916     errorReadBuffer.chop(available - readBytes);

   917 

   918     bool didRead = false;

   919     if (readBytes == 0) {

   920         if (stderrChannel.notifier)

   921             stderrChannel.notifier->setEnabled(false);

   922     } else if (processChannel == QProcess::StandardError) {

   923         didRead = true;

   924         if (!emittedReadyRead) {

   925             emittedReadyRead = true;

   926             emit q->readyRead();

   927             emittedReadyRead = false;

   928         }

   929     }

   930     emit q->readyReadStandardError();

   931     return didRead;

   932 }

   933 

   934 /*! \internal

   935 */

   936 bool QProcessPrivate::_q_canWrite()

   937 {

   938     Q_Q(QProcess);

   939     if (stdinChannel.notifier)

   940         stdinChannel.notifier->setEnabled(false);

   941 

   942     if (writeBuffer.isEmpty()) {

   943 #if defined QPROCESS_DEBUG

   944         qDebug("QProcessPrivate::canWrite(), not writing anything (empty write buffer).");

   945 #endif

   946         return false;

   947     }

   948 

   949     qint64 written = writeToStdin(writeBuffer.readPointer(),

   950                                       writeBuffer.nextDataBlockSize());

   951     if (written < 0) {

   952         destroyPipe(stdinChannel.pipe);

   953         processError = QProcess::WriteError;

   954         q->setErrorString(QProcess::tr("Error writing to process"));

   955 #if defined(QPROCESS_DEBUG) && !defined(Q_OS_WINCE)

   956         qDebug("QProcessPrivate::canWrite(), failed to write (%s)", strerror(errno));

   957 #endif

   958         emit q->error(processError);

   959         return false;

   960     }

   961 

   962 #if defined QPROCESS_DEBUG

   963     qDebug("QProcessPrivate::canWrite(), wrote %d bytes to the process input", int(written));

   964 #endif

   965 

   966     writeBuffer.free(written);

   967     if (!emittedBytesWritten) {

   968         emittedBytesWritten = true;

   969         emit q->bytesWritten(written);

   970         emittedBytesWritten = false;

   971     }

   972     if (stdinChannel.notifier && !writeBuffer.isEmpty())

   973         stdinChannel.notifier->setEnabled(true);

   974     if (writeBuffer.isEmpty() && stdinChannel.closed)

   975         closeWriteChannel();

   976     return true;

   977 }

   978 

   979 /*! \internal

   980 */

   981 bool QProcessPrivate::_q_processDied()

   982 {

   983     Q_Q(QProcess);

   984 #if defined QPROCESS_DEBUG

   985     qDebug("QProcessPrivate::_q_processDied()");

   986 #endif

   987 #ifdef Q_OS_UNIX

   988     if (!waitForDeadChild())

   989         return false;

   990 #endif

   991 #ifdef Q_OS_WIN

   992     if (processFinishedNotifier)

   993         processFinishedNotifier->setEnabled(false);

   994 #endif

   995 

   996     // the process may have died before it got a chance to report that it was

   997     // either running or stopped, so we will call _q_startupNotification() and

   998     // give it a chance to emit started() or error(FailedToStart).

   999     if (processState == QProcess::Starting) {

  1000         if (!_q_startupNotification())

  1001             return true;

  1002     }

  1003 

  1004     if (dying) {

  1005         // at this point we know the process is dead. prevent

  1006         // reentering this slot recursively by calling waitForFinished()

  1007         // or opening a dialog inside slots connected to the readyRead

  1008         // signals emitted below.

  1009         return true;

  1010     }

  1011     dying = true;

  1012 

  1013     // in case there is data in the pipe line and this slot by chance

  1014     // got called before the read notifications, call these two slots

  1015     // so the data is made available before the process dies.

  1016     _q_canReadStandardOutput();

  1017     _q_canReadStandardError();

  1018 

  1019     findExitCode();

  1020 

  1021     if (crashed) {

  1022         exitStatus = QProcess::CrashExit;

  1023         processError = QProcess::Crashed;

  1024         q->setErrorString(QProcess::tr("Process crashed"));

  1025         emit q->error(processError);

  1026     }

  1027 

  1028     bool wasRunning = (processState == QProcess::Running);

  1029 

  1030     cleanup();

  1031 

  1032     if (wasRunning) {

  1033         // we received EOF now:

  1034         emit q->readChannelFinished();

  1035         // in the future:

  1036         //emit q->standardOutputClosed();

  1037         //emit q->standardErrorClosed();

  1038 

  1039         emit q->finished(exitCode);

  1040         emit q->finished(exitCode, exitStatus);

  1041     }

  1042 #if defined QPROCESS_DEBUG

  1043     qDebug("QProcessPrivate::_q_processDied() process is dead");

  1044 #endif

  1045     return true;

  1046 }

  1047 

  1048 /*! \internal

  1049 */

  1050 bool QProcessPrivate::_q_startupNotification()

  1051 {

  1052     Q_Q(QProcess);

  1053 #if defined QPROCESS_DEBUG

  1054     qDebug("QProcessPrivate::startupNotification()");

  1055 #endif

  1056 

  1057     if (startupSocketNotifier)

  1058         startupSocketNotifier->setEnabled(false);

  1059     if (processStarted()) {

  1060         q->setProcessState(QProcess::Running);

  1061         emit q->started();

  1062         return true;

  1063     }

  1064 

  1065     q->setProcessState(QProcess::NotRunning);

  1066     processError = QProcess::FailedToStart;

  1067     emit q->error(processError);

  1068 #ifdef Q_OS_UNIX

  1069     // make sure the process manager removes this entry

  1070     waitForDeadChild();

  1071     findExitCode();

  1072 #endif

  1073     cleanup();

  1074     return false;

  1075 }

  1076 

  1077 /*! \internal

  1078 */

  1079 void QProcessPrivate::closeWriteChannel()

  1080 {

  1081 #if defined QPROCESS_DEBUG

  1082     qDebug("QProcessPrivate::closeWriteChannel()");

  1083 #endif

  1084     if (stdinChannel.notifier) {

  1085         extern void qDeleteInEventHandler(QObject *o);

  1086         stdinChannel.notifier->setEnabled(false);

  1087         if (stdinChannel.notifier) {

  1088             qDeleteInEventHandler(stdinChannel.notifier);

  1089             stdinChannel.notifier = 0;

  1090         }

  1091     }

  1092 #ifdef Q_OS_WIN

  1093     // ### Find a better fix, feeding the process little by little

  1094     // instead.

  1095     flushPipeWriter();

  1096 #endif

  1097     destroyPipe(stdinChannel.pipe);

  1098 }

  1099 

  1100 /*!

  1101     Constructs a QProcess object with the given \a parent.

  1102 */

  1103 QProcess::QProcess(QObject *parent)

  1104     : QIODevice(*new QProcessPrivate, parent)

  1105 {

  1106 #if defined QPROCESS_DEBUG

  1107     qDebug("QProcess::QProcess(%p)", parent);

  1108 #endif

  1109 }

  1110 

  1111 /*!

  1112     Destructs the QProcess object, i.e., killing the process.

  1113 

  1114     Note that this function will not return until the process is

  1115     terminated.

  1116 */

  1117 QProcess::~QProcess()

  1118 {

  1119     Q_D(QProcess);

  1120     if (d->processState != NotRunning) {

  1121         qWarning("QProcess: Destroyed while process is still running.");

  1122         kill();

  1123         waitForFinished();

  1124     }

  1125 #ifdef Q_OS_UNIX

  1126     // make sure the process manager removes this entry

  1127     d->findExitCode();

  1128 #endif

  1129     d->cleanup();

  1130 }

  1131 

  1132 /*!

  1133     \obsolete

  1134     Returns the read channel mode of the QProcess. This function is