| -rw-r--r-- | library/process_unix.cpp | 502 |
1 files changed, 502 insertions, 0 deletions
diff --git a/library/process_unix.cpp b/library/process_unix.cpp new file mode 100644 index 0000000..b599edb --- a/dev/null +++ b/library/process_unix.cpp @@ -0,0 +1,502 @@ +/********************************************************************** +** Copyright (C) 2000 Trolltech AS. All rights reserved. +** +** This file is part of Qtopia Environment. +** +** This file may be distributed and/or modified under the terms of the +** GNU General Public License version 2 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. +** +** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE +** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +** +** See http://www.trolltech.com/gpl/ for GPL licensing information. +** +** Contact info@trolltech.com if any conditions of this licensing are +** not clear to you. +** +**********************************************************************/ + +#ifndef QT_H +# include <qfeatures.h> +#endif // QT_H + +#ifndef QT_NO_PROCESS + +//#include "qplatformdefs.h" +#include <stdio.h> +#include <unistd.h> +#include <signal.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <fcntl.h> + +#include "process.h" +#include "qapplication.h" +//#include "qptrqueue.h" +//#include "qptrlist.h" +#include "qsocketnotifier.h" +#include "qtimer.h" +//#include "qcleanuphandler.h" +#include "qregexp.h" + +#include <stdlib.h> +#include <errno.h> + +#define QPtrList QList + +//#define QT_QPROCESS_DEBUG + + +class Proc; +class ProcessManager; +class ProcessPrivate +{ +public: + ProcessPrivate(); + ~ProcessPrivate(); + + void closeOpenSocketsForChild(); + void newProc( pid_t pid, Process *process ); + + QByteArray bufStdout; + QByteArray bufStderr; + + QSocketNotifier *notifierStdin; + QSocketNotifier *notifierStdout; + QSocketNotifier *notifierStderr; + + ssize_t stdinBufRead; + Proc *proc; + + bool exitValuesCalculated; + bool socketReadCalled; + + static ProcessManager *procManager; +}; + + +/*********************************************************************** + * + * Proc + * + **********************************************************************/ +/* + The class Process does not necessarily map exactly to the running + child processes: if the process is finished, the Process class may still be + there; furthermore a user can use Process to start more than one process. + + The helper-class Proc has the semantics that one instance of this class maps + directly to a running child process. +*/ +class Proc +{ +public: + Proc( pid_t p, Process *proc=0 ) : pid(p), process(proc) + { +#if defined(QT_QPROCESS_DEBUG) + qDebug( "Proc: Constructor for pid %d and Process %p", pid, process ); +#endif + socketStdin = 0; + socketStdout = 0; + socketStderr = 0; + } + ~Proc() + { +#if defined(QT_QPROCESS_DEBUG) + qDebug( "Proc: Destructor for pid %d and Process %p", pid, process ); +#endif + if ( process != 0 ) { + if ( process->d->notifierStdin ) + process->d->notifierStdin->setEnabled( FALSE ); + if ( process->d->notifierStdout ) + process->d->notifierStdout->setEnabled( FALSE ); + if ( process->d->notifierStderr ) + process->d->notifierStderr->setEnabled( FALSE ); + process->d->proc = 0; + } + if( socketStdin != 0 ) + ::close( socketStdin ); + // ### close these sockets even on parent exit or is it better only on + // sigchld (but what do I have to do with them on exit then)? + if( socketStdout != 0 ) + ::close( socketStdout ); + if( socketStderr != 0 ) + ::close( socketStderr ); + } + + pid_t pid; + int socketStdin; + int socketStdout; + int socketStderr; + Process *process; +}; + +/*********************************************************************** + * + * ProcessManager + * + **********************************************************************/ +class ProcessManager : public QObject +{ + Q_OBJECT + +public: + ProcessManager(); + ~ProcessManager(); + + void append( Proc *p ); + void remove( Proc *p ); + +public slots: + void removeMe(); + +public: + struct sigaction oldactChld; + struct sigaction oldactPipe; + QPtrList<Proc> *procList; + int sigchldFd[2]; +}; + + +ProcessManager::ProcessManager() +{ + procList = new QPtrList<Proc>; + procList->setAutoDelete( TRUE ); +} + +ProcessManager::~ProcessManager() +{ + delete procList; +} + +void ProcessManager::append( Proc *p ) +{ + procList->append( p ); +#if defined(QT_QPROCESS_DEBUG) + qDebug( "ProcessManager: append process (procList.count(): %d)", procList->count() ); +#endif +} + +void ProcessManager::remove( Proc *p ) +{ + procList->remove( p ); +#if defined(QT_QPROCESS_DEBUG) + qDebug( "ProcessManager: remove process (procList.count(): %d)", procList->count() ); +#endif + if ( procList->count() == 0 ) { + QTimer::singleShot( 0, this, SLOT(removeMe()) ); + } +} + +void ProcessManager::removeMe() +{ + ProcessPrivate::procManager = 0; + delete this; +} + +#include "process_unix.moc" + + +/*********************************************************************** + * + * ProcessPrivate + * + **********************************************************************/ +ProcessManager *ProcessPrivate::procManager = 0; + +ProcessPrivate::ProcessPrivate() +{ +#if defined(QT_QPROCESS_DEBUG) + qDebug( "ProcessPrivate: Constructor" ); +#endif + stdinBufRead = 0; + + notifierStdin = 0; + notifierStdout = 0; + notifierStderr = 0; + + exitValuesCalculated = FALSE; + socketReadCalled = FALSE; + + proc = 0; +} + +ProcessPrivate::~ProcessPrivate() +{ +#if defined(QT_QPROCESS_DEBUG) + qDebug( "ProcessPrivate: Destructor" ); +#endif + + if ( proc != 0 ) { + if ( proc->socketStdin != 0 ) { + ::close( proc->socketStdin ); + proc->socketStdin = 0; + } + proc->process = 0; + } + + delete notifierStdin; + delete notifierStdout; + delete notifierStderr; +} + +/* + Closes all open sockets in the child process that are not needed by the child + process. Otherwise one child may have an open socket on standard input, etc. + of another child. +*/ +void ProcessPrivate::closeOpenSocketsForChild() +{ + if ( procManager != 0 ) { + if ( procManager->sigchldFd[0] != 0 ) + ::close( procManager->sigchldFd[0] ); + if ( procManager->sigchldFd[1] != 0 ) + ::close( procManager->sigchldFd[1] ); + + // close also the sockets from other Process instances + Proc *proc; + for ( proc=procManager->procList->first(); proc!=0; proc=procManager->procList->next() ) { + ::close( proc->socketStdin ); + ::close( proc->socketStdout ); + ::close( proc->socketStderr ); + } + } +} + +void ProcessPrivate::newProc( pid_t pid, Process *process ) +{ + proc = new Proc( pid, process ); + if ( procManager == 0 ) { + procManager = new ProcessManager; + } + // the ProcessManager takes care of deleting the Proc instances + procManager->append( proc ); +} + + +/*********************************************************************** + * + * Process + * + **********************************************************************/ +/*! + This private class does basic initialization. +*/ +void Process::init() +{ + d = new ProcessPrivate(); + exitStat = 0; + exitNormal = FALSE; +} + +/*! + Destroys the class. + + If the process is running, it is NOT terminated! Standard input, standard + output and standard error of the process are closed. + + \sa hangUp() kill() +*/ +Process::~Process() +{ + delete d; +} + +bool Process::exec( const QByteArray& in, QByteArray& out, QStringList *env ) +{ +#if defined(QT_QPROCESS_DEBUG) + qDebug( "Process::exec()" ); +#endif + + int sStdin[2]; + int sStdout[2]; + int sStderr[2]; + + // open sockets for piping + if ( ::socketpair( AF_UNIX, SOCK_STREAM, 0, sStdin ) ) { + return FALSE; + } + if ( ::socketpair( AF_UNIX, SOCK_STREAM, 0, sStderr ) ) { + return FALSE; + } + if ( ::socketpair( AF_UNIX, SOCK_STREAM, 0, sStdout ) ) { + return FALSE; + } + + // the following pipe is only used to determine if the process could be + // started + int fd[2]; + if ( pipe( fd ) < 0 ) { + // non critical error, go on + fd[0] = 0; + fd[1] = 0; + } + + // construct the arguments for exec + QCString *arglistQ = new QCString[ _arguments.count() + 1 ]; + const char** arglist = new const char*[ _arguments.count() + 1 ]; + int i = 0; + for ( QStringList::Iterator it = _arguments.begin(); it != _arguments.end(); ++it ) { + arglistQ[i] = (*it).local8Bit(); + arglist[i] = arglistQ[i]; +#if defined(QT_QPROCESS_DEBUG) + qDebug( "Process::start(): arg %d = %s", i, arglist[i] ); +#endif + i++; + } + arglist[i] = 0; + + // fork and exec + QApplication::flushX(); + pid_t pid = fork(); + if ( pid == 0 ) { + // child + d->closeOpenSocketsForChild(); + ::close( sStdin[1] ); + ::close( sStdout[0] ); + ::close( sStderr[0] ); + ::dup2( sStdin[0], STDIN_FILENO ); + ::dup2( sStdout[1], STDOUT_FILENO ); + ::dup2( sStderr[1], STDERR_FILENO ); + if ( fd[0] ) + ::close( fd[0] ); + if ( fd[1] ) + ::fcntl( fd[1], F_SETFD, FD_CLOEXEC ); // close on exec shows sucess + + if ( env == 0 ) { // inherit environment and start process + ::execvp( arglist[0], (char*const*)arglist ); // ### cast not nice + } else { // start process with environment settins as specified in env + // construct the environment for exec + int numEntries = env->count(); + bool setLibraryPath = + env->grep( QRegExp( "^LD_LIBRARY_PATH=" ) ).isEmpty() && + getenv( "LD_LIBRARY_PATH" ) != 0; + if ( setLibraryPath ) + numEntries++; + QCString *envlistQ = new QCString[ numEntries + 1 ]; + const char** envlist = new const char*[ numEntries + 1 ]; + int i = 0; + if ( setLibraryPath ) { + envlistQ[i] = QString( "LD_LIBRARY_PATH=%1" ).arg( getenv( "LD_LIBRARY_PATH" ) ).local8Bit(); + envlist[i] = envlistQ[i]; + i++; + } + for ( QStringList::Iterator it = env->begin(); it != env->end(); ++it ) { + envlistQ[i] = (*it).local8Bit(); + envlist[i] = envlistQ[i]; + i++; + } + envlist[i] = 0; + + // look for the executable in the search path + if ( _arguments.count()>0 && getenv("PATH")!=0 ) { + QString command = _arguments[0]; + if ( !command.contains( '/' ) ) { + QStringList pathList = QStringList::split( ':', getenv( "PATH" ) ); + for (QStringList::Iterator it = pathList.begin(); it != pathList.end(); ++it ) { + QFileInfo fileInfo( *it, command ); + if ( fileInfo.isExecutable() ) { + arglistQ[0] = fileInfo.filePath().local8Bit(); + arglist[0] = arglistQ[0]; + break; + } + } + } + } + ::execve( arglist[0], (char*const*)arglist, (char*const*)envlist ); // ### casts not nice + } + if ( fd[1] ) { + char buf = 0; + ::write( fd[1], &buf, 1 ); + ::close( fd[1] ); + } + ::exit( -1 ); + } else if ( pid == -1 ) { + // error forking + goto error; + } + // test if exec was successful + if ( fd[1] ) + close( fd[1] ); + if ( fd[0] ) { + char buf; + for ( ;; ) { + int n = ::read( fd[0], &buf, 1 ); + if ( n==1 ) { + // socket was not closed => error + goto error; + } else if ( n==-1 ) { + if ( errno==EAGAIN || errno==EINTR ) + // try it again + continue; + } + break; + } + } + + + ::close( sStdin[0] ); + ::close( sStdout[1] ); + ::close( sStderr[1] ); + + // DIFFERENT + + { + int written=0; + int readden=0; // sic. + while (1) { + const int bufsize=4096; + struct timeval *timeout = 0; // #### could have this + fd_set r; FD_ZERO(&r); + fd_set w; FD_ZERO(&w); + FD_SET( sStdout[0], &r ); + out.resize( readden+bufsize ); + if ( int(in.size()) > written ) + FD_SET( sStdin[1], &w ); + int highest = QMAX(sStdout[0],sStdin[1])+1; + select(highest, &r, &w, 0, timeout); + if ( FD_ISSET( sStdout[0], &r ) ) { + int n = read( sStdout[0], out.data()+readden, bufsize ); + if ( n > 0 ) + readden += n; + else + break; + } + if ( FD_ISSET( sStdin[1], &w ) ) { + int n = write( sStdin[1], in.data()+written, in.size()-written ); + if ( n > 0 ) + written += n; + } + } + out.resize(readden); + } + + // cleanup and return + delete[] arglistQ; + delete[] arglist; + ::close( sStdin[1] ); + ::close( sStdout[0] ); + ::close( sStderr[0] ); + return TRUE; + +error: +#if defined(QT_QPROCESS_DEBUG) + qDebug( "Process::start(): error starting process" ); +#endif + ::close( sStdin[1] ); + ::close( sStdout[0] ); + ::close( sStderr[0] ); + ::close( sStdin[0] ); + ::close( sStdout[1] ); + ::close( sStderr[1] ); + ::close( fd[0] ); + ::close( fd[1] ); + delete[] arglistQ; + delete[] arglist; + return FALSE; +} + + +#endif // QT_NO_PROCESS |