Correct the approach to std file handles by simplifying the approach

and taking better advantage of apr's now-proper support.

Already verified by Randy Kobes and Tom Donovan

git-svn-id: https://svn.apache.org/repos/asf/httpd/httpd/trunk@580433 13f79535-47bb-0310-9956-ffa450edef68

diff --git a/server/mpm/winnt/mpm_winnt.c b/server/mpm/winnt/mpm_winnt.c
index 5aec640d4cc6bb8f3f24fc778f8685619041ca0e..a5a726337eb4fcfa638f0f19df33d29e89243425 100644 (file)
--- a/server/mpm/winnt/mpm_winnt.c
+++ b/server/mpm/winnt/mpm_winnt.c
@@ -1034,7 +1034,7 @@ void winnt_rewrite_args(process_rec *process)
     pid = getenv("AP_PARENT_PID");
     if (pid)
     {
-        HANDLE filehand, newhand;
+        HANDLE filehand;
         HANDLE hproc = GetCurrentProcess();
 
         /* This is the child */
@@ -1047,17 +1047,12 @@ void winnt_rewrite_args(process_rec *process)
         /* The parent gave us stdin, we need to remember this
          * handle, and no longer inherit it at our children
          * (we can't slurp it up now, we just aren't ready yet).
+         * The original handle is closed below, at apr_file_dup2()
          */
         pipe = GetStdHandle(STD_INPUT_HANDLE);
-
-        if (osver.dwPlatformId == VER_PLATFORM_WIN32_NT) {
-            /* This doesn't work for 9x, but it's cleaner. */
-            SetHandleInformation(pipe, HANDLE_FLAG_INHERIT, 0);
-        }
-        else if (DuplicateHandle(hproc, pipe,
-                                 hproc, &filehand, 0, FALSE,
-                                 DUPLICATE_SAME_ACCESS)) {
-            CloseHandle(pipe);
+        if (DuplicateHandle(hproc, pipe,
+                            hproc, &filehand, 0, FALSE,
+                            DUPLICATE_SAME_ACCESS)) {
             pipe = filehand;
         }
 
@@ -1067,13 +1062,18 @@ void winnt_rewrite_args(process_rec *process)
          * Don't infect child processes with our stdin
          * handle, use another handle to NUL!
          */
-        if ((filehand = GetStdHandle(STD_OUTPUT_HANDLE))
-            && DuplicateHandle(hproc, filehand, 
-                               hproc, &newhand, 0,
-                               TRUE, DUPLICATE_SAME_ACCESS)) {
-            SetStdHandle(STD_INPUT_HANDLE, newhand);
+        {
+            apr_file_t *infile, *outfile;
+            if ((apr_file_open_stdout(&outfile, process->pool) == APR_SUCCESS)
+             && (apr_file_open_stdin(&infile, process->pool) == APR_SUCCESS))
+                apr_file_dup2(infile, outfile, process->pool);
         }
 
+        /* This child needs the existing stderr opened for logging,
+         * already 
+         */
+
+
         /* The parent is responsible for providing the
          * COMPLETE ARGUMENTS REQUIRED to the child.
          *
@@ -1239,19 +1239,10 @@ void winnt_rewrite_args(process_rec *process)
             if ((rv = apr_file_open(&nullfile, "NUL",
                                     APR_READ | APR_WRITE, APR_OS_DEFAULT,
                                     process->pool)) == APR_SUCCESS) {
-                HANDLE hproc = GetCurrentProcess();
-                HANDLE nullstdout = NULL;
-                HANDLE nullhandle;
-
-                /* Duplicate the handle to be inherited by children */
-                if ((apr_os_file_get(&nullhandle, nullfile) == APR_SUCCESS)
-                    && DuplicateHandle(hproc, nullhandle,
-                                       hproc, &nullstdout,
-                                       0, TRUE, DUPLICATE_SAME_ACCESS)) {
-                    SetStdHandle(STD_OUTPUT_HANDLE, nullstdout);
-                }
-
-                /* Close the original handle, we used the duplicate */
+                apr_file_t *nullstdout;
+                if (apr_file_open_stdout(&nullstdout, process->pool)
+                        == APR_SUCCESS)
+                    apr_file_dup2(nullstdout, nullfile, process->pool);
                 apr_file_close(nullfile);
             }
         }

diff --git a/server/mpm/winnt/nt_eventlog.c b/server/mpm/winnt/nt_eventlog.c
index a0ae68c9966e6d2826aec053e33315f00015be6b..baa1a88bed838481568535277607046e6b2d0d1d 100644 (file)
--- a/server/mpm/winnt/nt_eventlog.c
+++ b/server/mpm/winnt/nt_eventlog.c
@@ -21,6 +21,7 @@
 #include "mpm_winnt.h"
 #include "apr_strings.h"
 #include "apr_lib.h"
+#include "apr_portable.h"
 #include "ap_regkey.h"
 
 static char  *display_name  = NULL;
@@ -138,7 +139,8 @@ void mpm_nt_eventlog_stderr_open(char *argv0, apr_pool_t *p)
     HANDLE hPipeWrite = NULL;
     HANDLE hDup = NULL;
     DWORD  threadid;
-    int    fd;
+    apr_file_t *eventlog_file;
+    apr_file_t *stderr_file;
 
     display_name = argv0;
 
@@ -159,27 +161,11 @@ void mpm_nt_eventlog_stderr_open(char *argv0, apr_pool_t *p)
 
     WaitForSingleObject(stderr_ready, INFINITE);
 
-    /* Flush stderr and unset its buffer, then commit and replace stderr.
-     * This is typically a noop for Win2K/XP since services with NULL std
-     * handles [but valid FILE *'s, oddly enough], but is required
-     * for NT 4.0 and to use this code outside of services.
-     */
-    fflush(stderr);
-    setvbuf(stderr, NULL, _IONBF, 0);
-    _commit(2 /* stderr */);
-    fd = _open_osfhandle((long) hPipeWrite,
-                         _O_WRONLY | _O_BINARY);
-    _dup2(fd, 2);
-    _close(fd);
-    _setmode(2, _O_BINARY);
-
-    /* hPipeWrite was _close()'ed above, and _dup2()'ed
-     * to fd 2 creating a new, inherited Win32 handle.
-     * Recover that real handle from fd 2.
-     */
-    hPipeWrite = (HANDLE)_get_osfhandle(2);
-
-    SetStdHandle(STD_ERROR_HANDLE, hPipeWrite);
+    if ((apr_file_open_stderr(&stderr_file, p) 
+             == APR_SUCCESS)
+     && (apr_os_file_put(&eventlog_file, &hPipeWrite, APR_WRITE, p)
+             == APR_SUCCESS))
+        apr_file_dup2(stderr_file, eventlog_file, p);
 
     /* The code above _will_ corrupt the StdHandle...
      * and we must do so anyways.  We set this up only