Initial revision

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