Add fdnull()

4 files changed, 104 insertions, 42 deletions

diff --git a/butl/fdstream b/butl/fdstream
index f144578..0be3708 100644
--- a/butl/fdstream
+++ b/butl/fdstream
@@ -142,7 +142,7 @@ namespace butl
   fdtranslate stdout_fdmode (fdtranslate);
   fdtranslate stderr_fdmode (fdtranslate);
 
-  // Low-level, nothrow file descriptor API. Primarily useful in tests.
+  // Low-level, nothrow file descriptor API.
   //
 
   // Close the file descriptor. Return true on success, set errno and return
@@ -150,6 +150,15 @@ namespace butl
   //
   bool
   fdclose (int) noexcept;
+
+  // Open the null device (e.g., /dev/null) that discards all data written to
+  // it and provides no data for read operations (i.e., yelds EOF on read).
+  // Return file descriptor on success, set errno and return -1 otherwise.
+  // Note that it's the caller's responsibility to close the returned file
+  // descriptor.
+  //
+  int
+  fdnull () noexcept;
 }
 
 #endif // BUTL_FDSTREAM
diff --git a/butl/fdstream.cxx b/butl/fdstream.cxx
index d99be70..13becfa 100644
--- a/butl/fdstream.cxx
+++ b/butl/fdstream.cxx
@@ -5,9 +5,11 @@
 #include <butl/fdstream>
 
 #ifndef _WIN32
+#  include <fcntl.h>  // open(), O_RDWR
 #  include <unistd.h> // close(), read(), write()
 #else
-#  include <io.h>     // _close(), _read(), _write(), _setmode()
+#  include <io.h>     // _close(), _read(), _write(), _setmode(), _sopen()
+#  include <share.h>  // _SH_DENYNO
 #  include <stdio.h>  // _fileno(), stdin, stdout, stderr
 #  include <fcntl.h>  // _O_BINARY, _O_TEXT
 #endif
@@ -153,6 +155,12 @@ namespace butl
     return close (fd) == 0;
   }
 
+  int
+  fdnull () noexcept
+  {
+    return open ("/dev/null", O_RDWR);
+  }
+
   fdtranslate
   fdmode (int, fdtranslate)
   {
@@ -185,6 +193,12 @@ namespace butl
     return _close (fd) == 0;
   }
 
+  int
+  fdnull () noexcept
+  {
+    return _sopen ("nul", _O_RDWR, _SH_DENYNO);
+  }
+
   fdtranslate
   fdmode (int fd, fdtranslate m)
   {
diff --git a/butl/process b/butl/process
index 0f68943..54a8dae 100644
--- a/butl/process
+++ b/butl/process
@@ -38,11 +38,16 @@ namespace butl
   {
   public:
     // Start another process using the specified command line. The default
-    // values to the in, out and err arguments indicate that the child
-    // process should inherit the parent process stdin, stdout, and stderr,
+    // values to the in, out and err arguments indicate that the child process
+    // should inherit the parent process stdin, stdout, and stderr,
     // respectively. If -1 is passed instead, then the corresponding child
     // process descriptor is connected (via a pipe) to out_fd for stdin,
-    // in_ofd for stdout, and in_efd for stderr (see data members below).
+    // in_ofd for stdout, and in_efd for stderr (see data members below). If
+    // -2 is passed, then the corresponding child process descriptor is
+    // replaced with the null device descriptor (e.g., /dev/null). This
+    // results in the child process not being able to read anything from stdin
+    // (gets immediate EOF) and all data written to stdout/stderr being
+    // discarded.
     //
     // On Windows parent process pipe descriptors are set to text mode to be
     // consistent with the default (text) mode of standard file descriptors of
@@ -52,8 +57,8 @@ namespace butl
     // translated into the 0xD, 0xA sequence. Use the _setmode() function to
     // change the mode, if required.
     //
-    // Instead of passing -1 or the default value, you can also pass your own
-    // descriptors. Note, however, that in this case they are not closed by
+    // Instead of passing -1, -2 or the default value, you can also pass your
+    // own descriptors. Note, however, that in this case they are not closed by
     // the parent. So you should do this yourself, if required.  For example,
     // to redirect the child process stdout to stderr, you can do:
     //
diff --git a/butl/process.cxx b/butl/process.cxx
index 1a795ea..4b834fb 100644
--- a/butl/process.cxx
+++ b/butl/process.cxx
@@ -25,6 +25,8 @@
 
 #include <cassert>
 
+#include <butl/fdstream> // fdnull(), fdclose()
+
 using namespace std;
 
 namespace butl
@@ -56,16 +58,13 @@ namespace butl
     {
       if (fd_ != -1)
       {
-#ifndef _WIN32
-        int r (close (fd_));
-#else
-        int r (_close (fd_));
-#endif
+        bool r (fdclose (fd_));
+
         // The valid file descriptor that has no IO operations being
         // performed on it should close successfully, unless something is
         // severely damaged.
         //
-        assert (r != -1);
+        assert (r);
       }
 
       fd_ = fd;
@@ -98,14 +97,31 @@ namespace butl
       p[1].reset (pd[1]);
     };
 
+    auto create_null = [&fail](auto_fd& n)
+    {
+      int fd (fdnull ());
+      if (fd == -1)
+        fail (false);
+
+      n.reset (fd);
+    };
+
+    // If we are asked to open null (-2) then open "half-pipe".
+    //
     if (in == -1)
       create_pipe (out_fd);
+    else if (in == -2)
+      create_null (out_fd[0]);
 
     if (out == -1)
       create_pipe (in_ofd);
+    else if (out == -2)
+      create_null (in_ofd[1]);
 
     if (err == -1)
       create_pipe (in_efd);
+    else if (err == -2)
+      create_null (in_efd[1]);
 
     handle = fork ();
 
@@ -116,16 +132,16 @@ namespace butl
     {
       // Child.
       //
-      // Duplicate the user-supplied (fd != -1) or the created pipe descriptor
+      // Duplicate the user-supplied (fd > -1) or the created pipe descriptor
       // to the standard stream descriptor (read end for STDIN_FILENO, write
       // end otherwise). Close the the pipe afterwards.
       //
       auto duplicate = [&fail](int sd, int fd, pipe& pd)
       {
-        if (fd == -1)
+        if (fd == -1 || fd == -2)
           fd = pd[sd == STDIN_FILENO ? 0 : 1].get ();
 
-        assert (fd != -1);
+        assert (fd > -1);
         if (dup2 (fd, sd) == -1)
           fail (true);
 
@@ -385,14 +401,55 @@ namespace butl
         fail ();
     };
 
+    // Resolve file descriptor to HANDLE and make sure it is inherited. Note
+    // that the handle is closed either when CloseHandle() is called for it or
+    // when _close() is called for the associated file descriptor. Make sure
+    // that either the original file descriptor or the resulted HANDLE is
+    // closed but not both of them.
+    //
+    auto get_osfhandle = [&fail](int fd) -> HANDLE
+    {
+      HANDLE h (reinterpret_cast<HANDLE> (_get_osfhandle (fd)));
+      if (h == INVALID_HANDLE_VALUE)
+        fail ("unable to obtain file handle");
+
+      // SetHandleInformation() fails for standard handles. We assume they are
+      // inherited by default.
+      //
+      if (fd != STDIN_FILENO && fd != STDOUT_FILENO && fd != STDERR_FILENO)
+      {
+        if (!SetHandleInformation (
+              h, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT))
+          fail ();
+      }
+
+      return h;
+    };
+
+    auto create_null = [&get_osfhandle, &fail](auto_handle& n)
+    {
+      auto_fd fd (fdnull ());
+      if (fd.get () == -1)
+        fail ();
+
+      n.reset (get_osfhandle (fd.get ()));
+      fd.release (); // Not to close the handle twice.
+    };
+
     if (in == -1)
       create_pipe (out_h, 1);
+    else if (in == -2)
+      create_null (out_h[0]);
 
     if (out == -1)
       create_pipe (in_oh, 0);
+    else if (out == -2)
+      create_null (in_oh[1]);
 
     if (err == -1)
       create_pipe (in_eh, 0);
+    else if (err == -2)
+      create_null (in_eh[1]);
 
     // Create the process.
     //
@@ -447,42 +504,19 @@ namespace butl
     si.cb = sizeof (STARTUPINFO);
     si.dwFlags |= STARTF_USESTDHANDLES;
 
-    // Resolve file descriptor to HANDLE and make sure it is inherited. Note
-    // that the handle is closed when _close() is called for the associated
-    // file descriptor.
-    //
-    auto get_osfhandle = [&fail](int fd) -> HANDLE
-    {
-      HANDLE h (reinterpret_cast<HANDLE> (_get_osfhandle (fd)));
-      if (h == INVALID_HANDLE_VALUE)
-        fail ("unable to obtain file handle");
-
-      // SetHandleInformation() fails for standard handles. We assume they are
-      // inherited by default.
-      //
-      if (fd != STDIN_FILENO && fd != STDOUT_FILENO && fd != STDERR_FILENO)
-      {
-        if (!SetHandleInformation (
-              h, HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT))
-          fail ();
-      }
-
-      return h;
-    };
-
-    si.hStdInput = in == -1
+    si.hStdInput = in == -1 || in == -2
       ? out_h[0].get ()
       : in == STDIN_FILENO
         ? GetStdHandle (STD_INPUT_HANDLE)
         : get_osfhandle (in);
 
-    si.hStdOutput = out == -1
+    si.hStdOutput = out == -1 || out == -2
       ? in_oh[1].get ()
       : out == STDOUT_FILENO
         ? GetStdHandle (STD_OUTPUT_HANDLE)
         : get_osfhandle (out);
 
-    si.hStdError = err == -1
+    si.hStdError = err == -1 || err == -2
       ? in_eh[1].get ()
       : err == STDERR_FILENO
         ? GetStdHandle (STD_ERROR_HANDLE)