Changeset 210

Timestamp:

Oct 7, 2009, 12:09:56 AM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

corelib: QProcess: Implemented QProcess->QProcess redirection.

Location:

trunk/src/corelib/io

Files:

• qprocess.cpp (modified) (1 diff)
• qprocess_os2.cpp (modified) (10 diffs)
• qprocess_p.h (modified) (1 diff)

trunk/src/corelib/io/qprocess.cpp ¶

@@ -515 +515 @@
     destroyPipe(childStartedPipe);
     destroyPipe(deathPipe);
+#else
+    pipeData[InPipe].bytesLeft = 0;
+    pipeData[OutPipe].bytesLeft = pipeData[ErrPipe].bytesLeft = 0;
+    pipeData[InPipe].newBytes = 0;
+    pipeData[OutPipe].newBytes = pipeData[ErrPipe].newBytes = 0;
 #endif
 #ifdef Q_OS_UNIX

trunk/src/corelib/io/qprocess_os2.cpp ¶

@@ -271 +271 @@
     APIRET arc = NO_ERROR;
     QProcessPrivate *d = process->d_func();
-    if (d->stdinChannel.pipe.server != HPIPE(~0)) {
+    if (d->stdinChannel.type == QProcessPrivate::Channel::Normal &&
+        d->stdinChannel.pipe.server != HPIPE(~0)) {
         arc = DosSetNPipeSem(d->stdinChannel.pipe.server, (HSEM)instance->eventSem,
                              toPipeKey(procKey, QProcessPrivate::InPipe));
     }
-    if (arc == NO_ERROR && d->stdoutChannel.pipe.server != HPIPE(~0)) {
+    if (arc == NO_ERROR &&
+        d->stdoutChannel.type == QProcessPrivate::Channel::Normal &&
+        d->stdoutChannel.pipe.server != HPIPE(~0)) {
         arc = DosSetNPipeSem(d->stdoutChannel.pipe.server, (HSEM)instance->eventSem,
                              toPipeKey(procKey, QProcessPrivate::OutPipe));
     }
-    if (arc == NO_ERROR && d->stderrChannel.pipe.server != HPIPE(~0)) {
+    if (arc == NO_ERROR &&
+        d->stderrChannel.type == QProcessPrivate::Channel::Normal &&
+        d->stderrChannel.pipe.server != HPIPE(~0)) {
         arc = DosSetNPipeSem(d->stderrChannel.pipe.server, (HSEM)instance->eventSem,
                              toPipeKey(procKey, QProcessPrivate::ErrPipe));
@@ -552 +557 @@
 }
 
-bool QProcessPrivate::createPipe(PipeType type, Channel::Pipe &pipe)
+bool QProcessPrivate::createPipe(PipeType type, Channel::Pipe &pipe,
+                                 const char *name /*= 0*/)
 {
     APIRET rc;
     char pathBuf[CCHMAXPATH];
+
+    pipe.server = HPIPE(~0);
+    pipe.client = HFILE(~0);
 
     // we need the process identifier to guarantee pipe name unicity
@@ -564 +573 @@
     case InPipe:
         // create our end of the pipe
-        sprintf(pathBuf, "\\pipe\\Qt4\\%08lX\\QProcess\\%p\\Stdin",
-                ppib->pib_ulpid, this->q_func());
+        sprintf(pathBuf, "\\pipe\\Qt4\\%08lX\\QProcess\\%p\\%s",
+                ppib->pib_ulpid, this->q_func(), name ? name : "Stdin");
         rc = DosCreateNPipe(pathBuf, &pipe.server,
-                            NP_ACCESS_OUTBOUND, NP_NOWAIT | NP_TYPE_BYTE | 1,
+                            NP_ACCESS_OUTBOUND | NP_NOINHERIT,
+                            NP_NOWAIT | NP_TYPE_BYTE | 1,
                             PIPE_SIZE_STDIN, 0, 0);
         if (rc == NO_ERROR) {
             DosConnectNPipe(pipe.server);
+            // ensure the other end blocks (vital for process->process redirections)
+            DosSetNPHState(pipe.server, NP_WAIT);
             // open the client end of the pipe
             ULONG action = 0;
@@ -582 +594 @@
         // create our end of the pipe
         sprintf(pathBuf, "\\pipe\\Qt4\\%08lX\\QProcess\\%p\\%s",
-                ppib->pib_ulpid, this->q_func(), type == OutPipe ? "Stdout" : "Stderr");
+                ppib->pib_ulpid, this->q_func(),
+                name ? name : type == OutPipe ? "Stdout" : "Stderr");
         rc = DosCreateNPipe(pathBuf, &pipe.server,
-                            NP_ACCESS_INBOUND, NP_NOWAIT | NP_TYPE_BYTE | 1,
+                            NP_ACCESS_INBOUND | NP_NOINHERIT,
+                            NP_NOWAIT | NP_TYPE_BYTE | 1,
                             0, type == OutPipe ? PIPE_SIZE_STDOUT : PIPE_SIZE_STDERR, 0);
         if (rc == NO_ERROR) {
             DosConnectNPipe(pipe.server);
+            // ensure the other end blocks (vital for process->process redirections)
+            DosSetNPHState(pipe.server, NP_WAIT);
             // open the client end of the pipe
             ULONG action = 0;
@@ -597 +613 @@
     }
 
-    if (rc != NO_ERROR)
-        qWarning("QProcessPrivate::createPipe: DosCreateNPipe or DosOpen "
-                 "returned %lu for PipeType(%d)", rc, type);
+    if (rc != NO_ERROR) {
+        qWarning("QProcessPrivate::createPipe: %s(%s) returned %lu",
+                 pipe.server == HPIPE(~0) ? "DosCreateNPipe" : "DosOpen",
+                 pathBuf, rc);
+    }
 
     return rc == NO_ERROR;
@@ -689 +707 @@
         Q_ASSERT_X(channel.process, "QProcess::start", "Internal error");
 
-        Channel *source;
-        Channel *sink;
+        // the first process started is the server, the second one is the client.
+        // the server stores handles to both ends in its channel.pipe member;
+        // the other part will pickup the handle of the client end from there.
 
         if (channel.type == Channel::PipeSource) {
             // we are the source
-            source = &channel;
-            sink = &channel.process->stdinChannel;
-
-            Q_ASSERT(source == &stdoutChannel);
-            Q_ASSERT(sink->process == this && sink->type == Channel::PipeSink);
+            Q_ASSERT(&channel == &stdoutChannel);
+            Q_ASSERT(channel.process->stdinChannel.process == this &&
+                     channel.process->stdinChannel.type == Channel::PipeSink);
+            if (channel.process->stdinChannel.pipe.server != HPIPE(~0)) {
+                // the other process has already started and became the server
+            } else {
+                // note: InPipe, since the type is relative to the other side
+                createPipe(InPipe, channel.pipe, "Source");
+            }
         } else {
-            // we are the sink;
-            source = &channel.process->stdoutChannel;
-            sink = &channel;
-
-            Q_ASSERT(sink == &stdinChannel);
-            Q_ASSERT(source->process == this && source->type == Channel::PipeSource);
-        }
-
-        if (source->pipe.server != HPIPE(~0)) {
-            // already created, do nothing
-            Q_ASSERT(source->pipe.client == HFILE(~0));
-            Q_ASSERT(sink->pipe.server == HPIPE(~0) && sink->pipe.client != HFILE(~0));
-            return true;
-        } else {
-            Q_ASSERT(source->pipe.server == HPIPE(~0) && source->pipe.client == HFILE(~0));
-            Q_ASSERT(sink->pipe.server == HPIPE(~0) && sink->pipe.client == HFILE(~0));
-
-            Channel::Pipe pipe;
-            createPipe(OutPipe, pipe);
-            sink->pipe.client = pipe.client;
-            source->pipe.server = pipe.server;
-
-            return true;
-        }
+            // we are the sink (and the server)
+            Q_ASSERT(channel.type == Channel::PipeSink);
+            Q_ASSERT(&channel == &stdinChannel);
+            Q_ASSERT(channel.process->stdoutChannel.process == this &&
+                     channel.process->stdoutChannel.type == Channel::PipeSource);
+            if (channel.process->stdoutChannel.pipe.server != HPIPE(~0)) {
+                // the other process has already started and became the server
+            } else {
+                // note: OutPipe, since the type is relative to the other side
+                createPipe(OutPipe, channel.pipe, "Sink");
+            }
+        }
+
+        return true;
     }
 }
@@ -877 +890 @@
         // save & copy the stdin handle
         if ((arc = DosDupHandle(realStdin, &tmpStdin)) == NO_ERROR) {
-            arc = DosDupHandle(stdinChannel.pipe.client, &realStdin);
+            HFILE handle = stdinChannel.pipe.client;
+            if (stdinChannel.type == Channel::PipeSink) {
+                // process -> process redirection
+                if (stdinChannel.pipe.server != HPIPE(~0)) {
+                    // we are the server
+                    handle = (HFILE)stdinChannel.pipe.server;
+                } else {
+                    // we are the client, use the server's variable
+                    handle = stdinChannel.process->stdoutChannel.pipe.client;
+                }
+                Q_ASSERT(handle != HFILE(~0));
+            }
+            arc = DosDupHandle(handle, &realStdin);
         }
         if (arc != NO_ERROR) {
@@ -890 +915 @@
             // save & copy the stdout handle
             if ((arc = DosDupHandle(realStdout, &tmpStdout)) == NO_ERROR) {
-                arc = DosDupHandle(stdoutChannel.pipe.client, &realStdout);
+                HFILE handle = stdoutChannel.pipe.client;
+                if (stdoutChannel.type == Channel::PipeSource) {
+                    // process -> process redirection
+                    if (stdoutChannel.pipe.server != HPIPE(~0)) {
+                        // we are the server
+                        handle = (HFILE)stdoutChannel.pipe.server;
+                    } else {
+                        // we are the client, use the server's variable
+                        handle = stdoutChannel.process->stdinChannel.pipe.client;
+                    }
+                    Q_ASSERT(handle != HFILE(~0));
+                }
+                arc = DosDupHandle(handle, &realStdout);
             }
             if (arc != NO_ERROR) {
@@ -904 +941 @@
                 // merge stdout and stderr if asked to
                 if (processChannelMode == QProcess::MergedChannels) {
-                    arc = DosDupHandle(stdoutChannel.pipe.client, &realStderr);
+                    arc = DosDupHandle(realStdout, &realStderr);
                 } else {
                     arc = DosDupHandle(stderrChannel.pipe.client, &realStderr);
@@ -959 +996 @@
     this->pid = Q_PID(pid);
 
-    // close the client ends (they are no more necessary)
-    if (stdinChannel.pipe.client != HFILE(~0)) {
-        DosClose(stdinChannel.pipe.client);
-        stdinChannel.pipe.client = HFILE(~0);
-    }
-    if (stdoutChannel.pipe.client != HFILE(~0)) {
-        DosClose(stdoutChannel.pipe.client);
-        stdoutChannel.pipe.client = HFILE(~0);
+    // close the client ends inherited by the started process (it's necessary to
+    // make sure that the started process owns the only handle to the client end
+    // and when it closes this handle the other party will notice it and e.g.
+    // stop waiting for new data).
+
+    if (stdinChannel.type == Channel::PipeSink) {
+        // process -> process redirection
+        if (stdinChannel.pipe.server != HPIPE(~0)) {
+            // we are the server, leave the handle for the other party
+        } else {
+            // we are the client, close the handle
+            DosClose(stdinChannel.process->stdoutChannel.pipe.client);
+            stdinChannel.process->stdoutChannel.pipe.client = HFILE(~0);
+        }
+    } else {
+        if (stdinChannel.pipe.client != HFILE(~0)) {
+            DosClose(stdinChannel.pipe.client);
+            stdinChannel.pipe.client = HFILE(~0);
+        }
+    }
+    if (stdoutChannel.type == Channel::PipeSource) {
+        // process -> process redirection
+        if (stdoutChannel.pipe.server != HPIPE(~0)) {
+            // we are the server, leave the handle for the other party
+        } else {
+            // we are the client, close the handle
+            DosClose(stdoutChannel.process->stdinChannel.pipe.client);
+            stdoutChannel.process->stdinChannel.pipe.client = HFILE(~0);
+        }
+    } else {
+        if (stdoutChannel.pipe.client != HFILE(~0)) {
+            DosClose(stdoutChannel.pipe.client);
+            stdoutChannel.pipe.client = HFILE(~0);
+        }
     }
     if (stderrChannel.pipe.client != HFILE(~0)) {

trunk/src/corelib/io/qprocess_p.h ¶

@@ -185 +185 @@
 #if defined(Q_OS_OS2)
     enum PipeType { InPipe = 0, OutPipe = 1, ErrPipe = 2 };
-    bool createPipe(PipeType type, Channel::Pipe &pipe);
+    bool createPipe(PipeType type, Channel::Pipe &pipe, const char *name = 0);
     void destroyPipe(Channel::Pipe &pipe);
 #else