aboutsummaryrefslogtreecommitdiff
path: root/butl/process.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'butl/process.cxx')
-rw-r--r--butl/process.cxx192
1 files changed, 91 insertions, 101 deletions
diff --git a/butl/process.cxx b/butl/process.cxx
index 6b515b7..41645e4 100644
--- a/butl/process.cxx
+++ b/butl/process.cxx
@@ -12,8 +12,7 @@
#else
# include <butl/win32-utility>
-# include <io.h> // _open_osfhandle(), _get_osfhandle(), _close()
-# include <fcntl.h> // _O_TEXT
+# include <io.h> // _get_osfhandle(), _close()
# include <stdlib.h> // _MAX_PATH, getenv()
# include <sys/types.h> // stat
# include <sys/stat.h> // stat(), S_IS*
@@ -34,6 +33,7 @@
#include <errno.h>
+#include <ios> // ios_base::failure
#include <cassert>
#include <cstddef> // size_t
#include <cstring> // strlen(), strchr()
@@ -227,49 +227,56 @@ namespace butl
const process_path& pp, const char* args[],
int in, int out, int err)
{
- using pipe = auto_fd[2];
-
- pipe out_fd;
- pipe in_ofd;
- pipe in_efd;
+ fdpipe out_fd;
+ fdpipe in_ofd;
+ fdpipe in_efd;
auto fail = [](bool child) {throw process_error (errno, child);};
- auto create_pipe = [&fail](pipe& p)
+ auto open_pipe = [] () -> fdpipe
{
- int pd[2];
- if (::pipe (pd) == -1)
- fail (false);
-
- p[0].reset (pd[0]);
- p[1].reset (pd[1]);
+ try
+ {
+ return fdopen_pipe ();
+ }
+ catch (const ios_base::failure&)
+ {
+ // Translate to process_error.
+ //
+ // For old versions of g++ (as of 4.9) ios_base::failure is not derived
+ // from system_error and so we cannot recover the errno value. On the
+ // other hand the only possible values are EMFILE and ENFILE. Lets use
+ // EMFILE as the more probable. This is a temporary code after all.
+ //
+ throw process_error (EMFILE, false);
+ }
};
- auto create_null = [&fail](auto_fd& n)
+ auto open_null = [&fail] () -> auto_fd
{
- int fd (fdnull ());
- if (fd == -1)
+ auto_fd fd (fdnull ());
+ if (fd.get () == -1)
fail (false);
- n.reset (fd);
+ return fd;
};
// If we are asked to open null (-2) then open "half-pipe".
//
if (in == -1)
- create_pipe (out_fd);
+ out_fd = open_pipe ();
else if (in == -2)
- create_null (out_fd[0]);
+ out_fd.in = open_null ();
if (out == -1)
- create_pipe (in_ofd);
+ in_ofd = open_pipe ();
else if (out == -2)
- create_null (in_ofd[1]);
+ in_ofd.out = open_null ();
if (err == -1)
- create_pipe (in_efd);
+ in_efd = open_pipe ();
else if (err == -2)
- create_null (in_efd[1]);
+ in_efd.out = open_null ();
handle = fork ();
@@ -284,17 +291,17 @@ namespace butl
// 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)
+ auto duplicate = [&fail](int sd, int fd, fdpipe& pd)
{
if (fd == -1 || fd == -2)
- fd = pd[sd == STDIN_FILENO ? 0 : 1].get ();
+ fd = (sd == STDIN_FILENO ? pd.in : pd.out).get ();
assert (fd > -1);
if (dup2 (fd, sd) == -1)
fail (true);
- pd[0].reset (); // Close.
- pd[1].reset (); // Close.
+ pd.in.reset (); // Silently close.
+ pd.out.reset (); // Silently close.
};
if (in != STDIN_FILENO)
@@ -333,9 +340,9 @@ namespace butl
assert (handle != 0); // Shouldn't get here unless in the parent process.
- this->out_fd = move (out_fd[1]);
- this->in_ofd = move (in_ofd[0]);
- this->in_efd = move (in_efd[0]);
+ this->out_fd = move (out_fd.out);
+ this->in_ofd = move (in_ofd.in);
+ this->in_efd = move (in_efd.in);
}
bool process::
@@ -616,37 +623,65 @@ namespace butl
const process_path& pp, const char* args[],
int in, int out, int err)
{
- using pipe = auto_handle[2];
-
- pipe out_h;
- pipe in_oh;
- pipe in_eh;
+ fdpipe out_fd;
+ fdpipe in_ofd;
+ fdpipe in_efd;
- SECURITY_ATTRIBUTES sa;
- sa.nLength = sizeof (SECURITY_ATTRIBUTES);
- sa.bInheritHandle = true;
- sa.lpSecurityDescriptor = 0;
+ auto open_pipe = [] () -> fdpipe
+ {
+ try
+ {
+ return fdopen_pipe ();
+ }
+ catch (const ios_base::failure&)
+ {
+ // Translate to process_error.
+ //
+ // For old versions of g++ (as of 4.9) ios_base::failure is not derived
+ // from system_error and so we cannot recover the errno value. On the
+ // other hand the only possible values are EMFILE and ENFILE. Lets use
+ // EMFILE as the more probable. Also let's make no distinction for VC.
+ // This is a temporary code after all.
+ //
+ throw process_error (EMFILE);
+ }
+ };
auto fail = [](const char* m = nullptr)
{
throw process_error (m == nullptr ? last_error_msg () : m);
};
- // Create a pipe and clear the inherit flag on the parent side.
- //
- auto create_pipe = [&sa, &fail](pipe& p, int parent)
+ auto open_null = [&fail] () -> auto_fd
{
- HANDLE ph[2];
- if (!CreatePipe (&ph[0], &ph[1], &sa, 0))
+ // Note that we are using a faster, temporary file-based emulation of
+ // NUL since we have no way of making sure the child buffers things
+ // properly (and by default they seem no to).
+ //
+ auto_fd fd (fdnull (true));
+ if (fd.get () == -1)
fail ();
- p[0].reset (ph[0]);
- p[1].reset (ph[1]);
-
- if (!SetHandleInformation (p[parent].get (), HANDLE_FLAG_INHERIT, 0))
- fail ();
+ return fd;
};
+ // If we are asked to open null (-2) then open "half-pipe".
+ //
+ if (in == -1)
+ out_fd = open_pipe ();
+ else if (in == -2)
+ out_fd.in = open_null ();
+
+ if (out == -1)
+ in_ofd = open_pipe ();
+ else if (out == -2)
+ in_ofd.out = open_null ();
+
+ if (err == -1)
+ in_efd = open_pipe ();
+ else if (err == -2)
+ in_efd.out = open_null ();
+
// 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
@@ -672,35 +707,6 @@ namespace butl
return h;
};
- auto create_null = [&get_osfhandle, &fail](auto_handle& n)
- {
- // Note that we are using a faster, temporary file-based emulation of
- // NUL since we have no way of making sure the child buffers things
- // properly (and by default they seem no to).
- //
- auto_fd fd (fdnull (true));
- 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.
//
@@ -738,7 +744,6 @@ namespace butl
//
STARTUPINFO si;
PROCESS_INFORMATION pi;
-
memset (&si, 0, sizeof (STARTUPINFO));
memset (&pi, 0, sizeof (PROCESS_INFORMATION));
@@ -746,19 +751,19 @@ namespace butl
si.dwFlags |= STARTF_USESTDHANDLES;
si.hStdInput = in == -1 || in == -2
- ? out_h[0].get ()
+ ? get_osfhandle (out_fd.in.get ())
: in == STDIN_FILENO
? GetStdHandle (STD_INPUT_HANDLE)
: get_osfhandle (in);
si.hStdOutput = out == -1 || out == -2
- ? in_oh[1].get ()
+ ? get_osfhandle (in_ofd.out.get ())
: out == STDOUT_FILENO
? GetStdHandle (STD_OUTPUT_HANDLE)
: get_osfhandle (out);
si.hStdError = err == -1 || err == -2
- ? in_eh[1].get ()
+ ? get_osfhandle (in_efd.out.get ())
: err == STDERR_FILENO
? GetStdHandle (STD_ERROR_HANDLE)
: get_osfhandle (err);
@@ -792,24 +797,9 @@ namespace butl
auto_handle (pi.hThread).reset (); // Close.
auto_handle process (pi.hProcess);
- // Convert file handles to file descriptors. Note that the handle is
- // closed when _close() is called for the returned file descriptor.
- //
- auto open_osfhandle = [&fail](auto_handle& h) -> int
- {
- int fd (
- _open_osfhandle (reinterpret_cast<intptr_t> (h.get ()), _O_TEXT));
-
- if (fd == -1)
- fail ("unable to convert file handle to file descriptor");
-
- h.release ();
- return fd;
- };
-
- this->out_fd.reset (in == -1 ? open_osfhandle (out_h[1]) : -1);
- this->in_ofd.reset (out == -1 ? open_osfhandle (in_oh[0]) : -1);
- this->in_efd.reset (err == -1 ? open_osfhandle (in_eh[0]) : -1);
+ this->out_fd = move (out_fd.out);
+ this->in_ofd = move (in_ofd.in);
+ this->in_efd = move (in_efd.in);
this->handle = process.release ();
generated by cgit v1.1 at 2024-11-06 13:41:55 +0000