Diffstat (limited to 'libopie2/opiecore/oprocess.cpp') (more/less context) (ignore whitespace changes)
-rw-r--r-- | libopie2/opiecore/oprocess.cpp | 12 |
1 files changed, 6 insertions, 6 deletions
diff --git a/libopie2/opiecore/oprocess.cpp b/libopie2/opiecore/oprocess.cpp index 0a361a1..6349c83 100644 --- a/libopie2/opiecore/oprocess.cpp +++ b/libopie2/opiecore/oprocess.cpp @@ -483,406 +483,406 @@ void OProcess::flushStdin ( ) do { d1 = input_total - input_sent; slotSendData ( 0 ); d2 = input_total - input_sent; } while ( d2 <= d1 ); } void OProcess::suspend() { if ( ( communication & Stdout ) && outnot ) outnot->setEnabled( false ); } void OProcess::resume() { if ( ( communication & Stdout ) && outnot ) outnot->setEnabled( true ); } bool OProcess::closeStdin() { bool rv; if ( communication & Stdin ) { communication = ( Communication ) ( communication & ~Stdin ); delete innot; innot = 0; close( in[ 1 ] ); rv = true; } else rv = false; return rv; } bool OProcess::closeStdout() { bool rv; if ( communication & Stdout ) { communication = ( Communication ) ( communication & ~Stdout ); delete outnot; outnot = 0; close( out[ 0 ] ); rv = true; } else rv = false; return rv; } bool OProcess::closeStderr() { bool rv; if ( communication & Stderr ) { communication = static_cast<Communication>( communication & ~Stderr ); delete errnot; errnot = 0; close( err[ 0 ] ); rv = true; } else rv = false; return rv; } void OProcess::slotChildOutput( int fdno ) { if ( !childOutput( fdno ) ) closeStdout(); } void OProcess::slotChildError( int fdno ) { if ( !childError( fdno ) ) closeStderr(); } void OProcess::slotSendData( int ) { if ( input_sent == input_total ) { innot->setEnabled( false ); input_data = 0; emit wroteStdin( this ); } else input_sent += ::write( in[ 1 ], input_data + input_sent, input_total - input_sent ); } void OProcess::processHasExited( int state ) { if ( runs ) { runs = false; status = state; commClose(); // cleanup communication sockets // also emit a signal if the process was run Blocking if ( DontCare != run_mode ) { emit processExited( this ); } } } int OProcess::childOutput( int fdno ) { if ( communication & NoRead ) { int len = -1; emit receivedStdout( fdno, len ); errno = 0; // Make sure errno doesn't read "EAGAIN" return len; } else { char buffer[ 1024 ]; int len; len = ::read( fdno, buffer, 1024 ); if ( 0 < len ) { emit receivedStdout( this, buffer, len ); } return len; } } int OProcess::childError( int fdno ) { char buffer[ 1024 ]; int len; len = ::read( fdno, buffer, 1024 ); if ( 0 < len ) emit receivedStderr( this, buffer, len ); return len; } int OProcess::setupCommunication( Communication comm ) { int ok; communication = comm; ok = 1; if ( comm & Stdin ) ok &= socketpair( AF_UNIX, SOCK_STREAM, 0, in ) >= 0; if ( comm & Stdout ) ok &= socketpair( AF_UNIX, SOCK_STREAM, 0, out ) >= 0; if ( comm & Stderr ) ok &= socketpair( AF_UNIX, SOCK_STREAM, 0, err ) >= 0; return ok; } int OProcess::commSetupDoneP() { int ok = 1; if ( communication != NoCommunication ) { if ( communication & Stdin ) close( in[ 0 ] ); if ( communication & Stdout ) close( out[ 1 ] ); if ( communication & Stderr ) close( err[ 1 ] ); // Don't create socket notifiers and set the sockets non-blocking if // blocking is requested. if ( run_mode == Block ) return ok; if ( communication & Stdin ) { // ok &= (-1 != fcntl(in[1], F_SETFL, O_NONBLOCK)); innot = new QSocketNotifier( in[ 1 ], QSocketNotifier::Write, this ); CHECK_PTR( innot ); innot->setEnabled( false ); // will be enabled when data has to be sent - QObject::connect( innot, SIGNAL( activated( int ) ), - this, SLOT( slotSendData( int ) ) ); + QObject::connect( innot, SIGNAL( activated(int) ), + this, SLOT( slotSendData(int) ) ); } if ( communication & Stdout ) { // ok &= (-1 != fcntl(out[0], F_SETFL, O_NONBLOCK)); outnot = new QSocketNotifier( out[ 0 ], QSocketNotifier::Read, this ); CHECK_PTR( outnot ); - QObject::connect( outnot, SIGNAL( activated( int ) ), - this, SLOT( slotChildOutput( int ) ) ); + QObject::connect( outnot, SIGNAL( activated(int) ), + this, SLOT( slotChildOutput(int) ) ); if ( communication & NoRead ) suspend(); } if ( communication & Stderr ) { // ok &= (-1 != fcntl(err[0], F_SETFL, O_NONBLOCK)); errnot = new QSocketNotifier( err[ 0 ], QSocketNotifier::Read, this ); CHECK_PTR( errnot ); - QObject::connect( errnot, SIGNAL( activated( int ) ), - this, SLOT( slotChildError( int ) ) ); + QObject::connect( errnot, SIGNAL( activated(int) ), + this, SLOT( slotChildError(int) ) ); } } return ok; } int OProcess::commSetupDoneC() { int ok = 1; struct linger so; memset( &so, 0, sizeof( so ) ); if ( communication & Stdin ) close( in[ 1 ] ); if ( communication & Stdout ) close( out[ 0 ] ); if ( communication & Stderr ) close( err[ 0 ] ); if ( communication & Stdin ) ok &= dup2( in[ 0 ], STDIN_FILENO ) != -1; else { int null_fd = open( "/dev/null", O_RDONLY ); ok &= dup2( null_fd, STDIN_FILENO ) != -1; close( null_fd ); } if ( communication & Stdout ) { ok &= dup2( out[ 1 ], STDOUT_FILENO ) != -1; ok &= !setsockopt( out[ 1 ], SOL_SOCKET, SO_LINGER, ( char* ) & so, sizeof( so ) ); } else { int null_fd = open( "/dev/null", O_WRONLY ); ok &= dup2( null_fd, STDOUT_FILENO ) != -1; close( null_fd ); } if ( communication & Stderr ) { ok &= dup2( err[ 1 ], STDERR_FILENO ) != -1; ok &= !setsockopt( err[ 1 ], SOL_SOCKET, SO_LINGER, reinterpret_cast<char *>( &so ), sizeof( so ) ); } else { int null_fd = open( "/dev/null", O_WRONLY ); ok &= dup2( null_fd, STDERR_FILENO ) != -1; close( null_fd ); } return ok; } void OProcess::commClose() { if ( NoCommunication != communication ) { bool b_in = ( communication & Stdin ); bool b_out = ( communication & Stdout ); bool b_err = ( communication & Stderr ); if ( b_in ) delete innot; if ( b_out || b_err ) { // If both channels are being read we need to make sure that one socket buffer // doesn't fill up whilst we are waiting for data on the other (causing a deadlock). // Hence we need to use select. // Once one or other of the channels has reached EOF (or given an error) go back // to the usual mechanism. int fds_ready = 1; fd_set rfds; int max_fd = 0; if ( b_out ) { fcntl( out[ 0 ], F_SETFL, O_NONBLOCK ); if ( out[ 0 ] > max_fd ) max_fd = out[ 0 ]; delete outnot; outnot = 0; } if ( b_err ) { fcntl( err[ 0 ], F_SETFL, O_NONBLOCK ); if ( err[ 0 ] > max_fd ) max_fd = err[ 0 ]; delete errnot; errnot = 0; } while ( b_out || b_err ) { // * If the process is still running we block until we // receive data. (p_timeout = 0, no timeout) // * If the process has already exited, we only check // the available data, we don't wait for more. // (p_timeout = &timeout, timeout immediately) struct timeval timeout; timeout.tv_sec = 0; timeout.tv_usec = 0; struct timeval *p_timeout = runs ? 0 : &timeout; FD_ZERO( &rfds ); if ( b_out ) FD_SET( out[ 0 ], &rfds ); if ( b_err ) FD_SET( err[ 0 ], &rfds ); fds_ready = select( max_fd + 1, &rfds, 0, 0, p_timeout ); if ( fds_ready <= 0 ) break; if ( b_out && FD_ISSET( out[ 0 ], &rfds ) ) { int ret = 1; while ( ret > 0 ) ret = childOutput( out[ 0 ] ); if ( ( ret == -1 && errno != EAGAIN ) || ret == 0 ) b_out = false; } if ( b_err && FD_ISSET( err[ 0 ], &rfds ) ) { int ret = 1; while ( ret > 0 ) ret = childError( err[ 0 ] ); if ( ( ret == -1 && errno != EAGAIN ) || ret == 0 ) b_err = false; } } } if ( b_in ) { communication = ( Communication ) ( communication & ~Stdin ); close( in[ 1 ] ); } if ( b_out ) { communication = ( Communication ) ( communication & ~Stdout ); close( out[ 0 ] ); } if ( b_err ) { communication = ( Communication ) ( communication & ~Stderr ); close( err[ 0 ] ); } } } void OProcess::setUseShell( bool useShell, const char *shell ) { if ( !d ) d = new OProcessPrivate; d->useShell = useShell; d->shell = shell; if ( d->shell.isEmpty() ) d->shell = searchShell(); } QString OProcess::quote( const QString &arg ) { QString res = arg; res.replace( QRegExp( QString::fromLatin1( "\'" ) ), QString::fromLatin1( "'\"'\"'" ) ); res.prepend( '\'' ); res.append( '\'' ); return res; } QCString OProcess::searchShell() { QCString tmpShell = QCString( getenv( "SHELL" ) ).stripWhiteSpace(); if ( !isExecutable( tmpShell ) ) { tmpShell = "/bin/sh"; } return tmpShell; } bool OProcess::isExecutable( const QCString &filename ) { struct stat fileinfo; if ( filename.isEmpty() ) return false; // CC: we've got a valid filename, now let's see whether we can execute that file |