RubyGems - facter - Versions diffs - 3.12.2.cfacter.20181217 → 4.0.7.pre - Mend

facter 3.12.2.cfacter.20181217 → 4.0.7.pre

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1564) hide show

data/ext/facter/leatherman/execution/src/posix/generic/platform.cc DELETED

@@ -1,30 +0,0 @@
-#include <leatherman/execution/execution.hpp>
-#include <leatherman/locale/locale.hpp>
-#include "../platform.hpp"
-// Mark string for translation (alias for leatherman::locale::format)
-using leatherman::locale::_;
-namespace leatherman { namespace execution {
-    pid_t create_child(leatherman::util::option_set<execution_options> const& options,
-                       int in_fd, int out_fd, int err_fd, uint64_t max_fd,
-                       char const* program, char const** argv, char const** envp)
-    {
-        // Fork the child process
-        // Note: this uses vfork (unless the thread_safe execution option is specified), which is inherently unsafe
-        // (the parent's address space is shared with the child)
-        pid_t pid = options[execution_options::thread_safe] ? fork() : vfork();
-        if (pid < 0) {
-            throw execution_exception(format_error(_("failed to fork child process")));
-        }
-        if (pid == 0) {  // Is this the child process?
-            // Exec the child; this never returns
-            exec_child(in_fd, out_fd, err_fd, max_fd, program, argv, envp);
-        }
-        return pid;
-    }
-}}  // namespace leatherman::execution

data/ext/facter/leatherman/execution/src/posix/platform.hpp DELETED

@@ -1,15 +0,0 @@
-#include <unistd.h>
-#include <errno.h>
-namespace leatherman { namespace execution {
-    std::string format_error(std::string const& message = std::string(), int error = errno);
-    pid_t create_child(leatherman::util::option_set<execution_options> const& options,
-                       int in_fd, int out_fd, int err_fd, uint64_t max_fd,
-                       char const* program, char const** argv, char const** envp);
-    void exec_child(int in_fd, int out_fd, int err_fd, uint64_t max_fd,
-                    char const* program, char const** argv, char const** envp);
-}}  // namespace leatherman::execution

data/ext/facter/leatherman/execution/src/posix/solaris/platform.cc DELETED

@@ -1,197 +0,0 @@
-/*
- * Portions of this file were copied from OpenSSH's
- * openbsd-compat/port-solaris.c file, that file
- * contained the following copyright notice:
- *
- * Copyright (c) 2006 Chad Mynhier.
- *
- * Permission to use, copy, modify, and distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
- *
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- */
-#include <leatherman/execution/execution.hpp>
-#include <leatherman/locale/locale.hpp>
-#include <boost/format.hpp>
-#include <fcntl.h>
-#include <libcontract.h>
-#include <sys/ctfs.h>
-#include <sys/contract/process.h>
-#include "../platform.hpp"
-#define CT_TEMPLATE CTFS_ROOT "/process/template"
-#define CT_LATEST CTFS_ROOT "/process/latest"
-// Mark string for translation (alias for leatherman::locale::format)
-using leatherman::locale::_;
-using namespace std;
-namespace leatherman { namespace execution {
-    static int activate_new_contract_template(void)
-    {
-        int tmpl_fd;
-        int err;
-        // Open a template
-        if ((tmpl_fd = open(CT_TEMPLATE, O_RDWR)) == -1) {
-            err = errno;
-            goto fail;
-        }
-        // Set the template parameters and event sets
-        if ((err = ct_pr_tmpl_set_param(tmpl_fd, CT_PR_PGRPONLY)) != 0) {
-            goto close_fail;
-        }
-        if ((err = ct_pr_tmpl_set_fatal(tmpl_fd, CT_PR_EV_HWERR)) != 0) {
-            goto close_fail;
-        }
-        if ((err = ct_tmpl_set_critical(tmpl_fd, 0)) != 0) {
-            goto close_fail;
-        }
-        if ((err = ct_tmpl_set_informative(tmpl_fd, CT_PR_EV_HWERR)) != 0) {
-            goto close_fail;
-        }
-        // Now make this the active template for this process
-        if ((err = ct_tmpl_activate(tmpl_fd)) != 0) {
-            goto close_fail;
-        }
-        return tmpl_fd;
-    close_fail:
-        close(tmpl_fd);
-    fail:
-        throw execution_exception(format_error(_("failed to create process contract template"), err));
-    }
-    static int deactivate_contract_template(int tmpl_fd)
-    {
-        // WARNING: this function is potentially called from a vfork'd child
-        // Do not modify program state from this function; only call setpgid, dup2, close, execve, and _exit
-        // Do not allocate heap memory or throw exceptions
-        // The child is sharing the address space of the parent process, so carelessly modifying this
-        // function may lead to parent state corruption, memory leaks, and/or total protonic reversal
-        if (tmpl_fd < 0) {
-            return 0;
-        }
-        // Deactivate the template
-        int err = ct_tmpl_clear(tmpl_fd);
-        close(tmpl_fd);
-        return err;
-    }
-    // Lookup the latest child process contract ID
-    static ctid_t get_latest_child_contract_id(void)
-    {
-        int stat_fd;
-        ct_stathdl_t stathdl;
-        ctid_t ctid;
-        int err;
-        if ((stat_fd = open(CT_LATEST, O_RDONLY)) < 0) {
-            err = errno;
-            goto fail;
-        }
-        if ((err = ct_status_read(stat_fd, CTD_COMMON, &stathdl)) != 0) {
-            close(stat_fd);
-            goto fail;
-        }
-        ctid = ct_status_get_id(stathdl);
-        err = errno;
-        ct_status_free(stathdl);
-        close(stat_fd);
-        if (ctid < 0) {
-            goto fail;
-        }
-        return ctid;
-    fail:
-        throw execution_exception(format_error(_("failed to lookup the latest child process contract"), err));
-    }
-    static void abandon_latest_child_contract()
-    {
-        ctid_t ctid = get_latest_child_contract_id();
-        int ctl_fd;
-        int err;
-        if ((ctl_fd = open((boost::format { "%s/process/%d/ctl" } % CTFS_ROOT % ctid).str().c_str(), O_WRONLY)) < 0) {
-            err = errno;
-            goto fail;
-        }
-        // Abandon the contract created for the child process
-        err = ct_ctl_abandon(ctl_fd);
-        close(ctl_fd);
-        if (err == 0) {
-            return;
-        }
-    fail:
-        throw execution_exception(format_error(_("failed to abandon contract created for a child process"), err));
-    }
-    pid_t create_child(leatherman::util::option_set<execution_options> const& options,
-                       int in_fd, int out_fd, int err_fd, uint64_t max_fd,
-                       char const* program, char const** argv, char const** envp)
-    {
-        bool detach = options[execution_options::create_detached_process];
-        // Create a new process contract template & activate it
-        int tmpl_fd = detach ? activate_new_contract_template() : -1;
-        int err;
-        // Fork the child process
-        // Note: this uses vfork (unless the thread_safe execution option is specified), which is inherently unsafe
-        // (the parent's address space is shared with the child)
-        pid_t pid = options[execution_options::thread_safe] ? fork() : vfork();
-        if (pid < 0) {
-            err = errno;
-            deactivate_contract_template(tmpl_fd);
-            throw execution_exception(format_error(_("failed to fork child process"), err));
-        }
-        if (pid == 0) {  // Is this the child process?
-            if ((err = deactivate_contract_template(tmpl_fd)) != 0) {
-                _exit(err);
-            }
-            // Exec the child; this never returns
-            exec_child(in_fd, out_fd, err_fd, max_fd, program, argv, envp);
-        }
-        // This is the parent process
-        if ((err = deactivate_contract_template(tmpl_fd)) != 0) {
-            throw execution_exception(format_error(_("failed to deactivate contract template created for a child process"), err));
-        }
-        if (detach) {
-            // Abandon the contract created for the child process
-            abandon_latest_child_contract();
-        }
-        return pid;
-    }
-}}  // namespace leatherman::execution

data/ext/facter/leatherman/execution/src/windows/execution.cc DELETED

@@ -1,698 +0,0 @@
-#include <leatherman/execution/execution.hpp>
-#include <leatherman/util/environment.hpp>
-#include <leatherman/util/scope_exit.hpp>
-#include <leatherman/util/windows/scoped_handle.hpp>
-#include <leatherman/util/scoped_env.hpp>
-#include <leatherman/windows/system_error.hpp>
-#include <leatherman/windows/windows.hpp>
-#include <leatherman/logging/logging.hpp>
-#include <leatherman/locale/locale.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/algorithm/string.hpp>
-#include <boost/nowide/convert.hpp>
-#include <boost/uuid/uuid.hpp>
-#include <boost/uuid/uuid_generators.hpp>
-#include <boost/uuid/uuid_io.hpp>
-#include <cstdlib>
-#include <cstdio>
-#include <sstream>
-#include <cstring>
-#include <random>
-// Mark string for translation (alias for leatherman::locale::format)
-using leatherman::locale::_;
-using namespace std;
-using namespace leatherman::windows;
-using namespace leatherman::logging;
-using namespace leatherman::util;
-using namespace leatherman::util::windows;
-using namespace boost::filesystem;
-using namespace boost::algorithm;
-namespace leatherman { namespace execution {
-    void log_execution(string const& file, vector<string> const* arguments);
-    const char *const command_shell = "cmd.exe";
-    const char *const command_args = "/c";
-    struct extpath_helper
-    {
-        vector<string> const& ext_paths() const
-        {
-            return _extpaths;
-        }
-        bool contains(const string & ext) const
-        {
-            return binary_search(_extpaths.begin(), _extpaths.end(), to_lower_copy(ext));
-        }
-     private:
-        // Use sorted, lower-case operations to ignore case and use binary search.
-        vector<string> _extpaths = {".bat", ".cmd", ".com", ".exe"};;
-    };
-    static bool is_executable(path const& p, extpath_helper const* helper = nullptr)
-    {
-        // If there's an error accessing file status, we assume is_executable
-        // is false and return. The reason for failure doesn't matter to us.
-        boost::system::error_code ec;
-        bool isfile = is_regular_file(p, ec);
-        if (ec) {
-            LOG_TRACE("error reading status of path {1}: {2} ({3})", p, ec.message(), ec.value());
-        }
-        if (helper) {
-            // Checking extensions aren't needed if we explicitly specified it.
-            // If helper was passed, then we haven't and should check the ext.
-            isfile &= helper->contains(p.extension().string());
-        }
-        return isfile;
-    }
-    string which(string const& file, vector<string> const& directories)
-    {
-        // On Windows, everything has execute permission; Ruby determined
-        // executability based on extension {com, exe, bat, cmd}. We'll do the
-        // same check here using extpath_helper.
-        static extpath_helper helper;
-        // If the file is already absolute, return it if it's executable.
-        path p = file;
-        if (p.is_absolute()) {
-            return is_executable(p, &helper) ? p.string() : string();
-        }
-        // On Windows, treat 'echo' as a command that can be found
-        if (file == "echo") {
-            return "echo";
-        }
-        // Otherwise, check for an executable file under the given search paths
-        for (auto const& dir : directories) {
-            path p = path(dir) / file;
-            if (!p.has_extension()) {
-                path pext = p;
-                for (auto const&ext : helper.ext_paths()) {
-                    pext.replace_extension(ext);
-                    if (is_executable(pext)) {
-                        return pext.string();
-                    }
-                }
-            }
-            if (is_executable(p, &helper)) {
-                return p.string();
-            }
-        }
-        return {};
-    }
-    // Create a pipe, throwing if there's an error. Returns {read, write} handles.
-    // Always creates overlapped pipes.
-    static tuple<scoped_handle, scoped_handle> CreatePipeThrow()
-    {
-        static LONG counter = 0;
-        static boost::uuids::random_generator rand_uuid;
-        SECURITY_ATTRIBUTES attributes = {};
-        attributes.nLength = sizeof(SECURITY_ATTRIBUTES);
-        attributes.bInheritHandle = TRUE;
-        attributes.lpSecurityDescriptor = NULL;
-        // Format a name for the pipe. Use the thread id to ensure no two threads try to use the same
-        // pipe, and a counter to generate multiple pipes for the same process invocation.
-        // A scenario exists using timeouts where we could release the invoking end of a named pipe
-        // but the other end doesn't release. Then the invoking thread shuts down and another with
-        // the same thread id is started and reconnects to the existing named pipe. Use the process
-        // id and a random UUID to make that highly unlikely.
-        wstring name = boost::nowide::widen(_("\\\\.\\Pipe\\leatherman.{1}.{2}.{3}.{4}",
-            GetCurrentProcessId(),
-            GetCurrentThreadId(),
-            InterlockedIncrement(&counter),
-            to_string(rand_uuid())));
-        // Create the read pipe
-        scoped_handle read_handle(CreateNamedPipeW(
-            name.c_str(),
-            PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED,
-            PIPE_TYPE_BYTE | PIPE_WAIT,
-            1,
-            4096,
-            4096,
-            0,
-            &attributes));
-        if (read_handle == INVALID_HANDLE_VALUE) {
-            LOG_ERROR("failed to create read pipe: {1}.", windows::system_error());
-            throw execution_exception(_("failed to create read pipe."));
-        }
-        // Open the write pipe
-        scoped_handle write_handle(CreateFileW(
-            name.c_str(),
-            GENERIC_WRITE,
-            0,
-            &attributes,
-            OPEN_EXISTING,
-            FILE_ATTRIBUTE_NORMAL,
-            nullptr));
-        if (write_handle == INVALID_HANDLE_VALUE) {
-            LOG_ERROR("failed to create write pipe: {1}.", windows::system_error());
-            throw execution_exception(_("failed to create write pipe."));
-        }
-        return make_tuple(move(read_handle), move(write_handle));
-    }
-    // Source: http://blogs.msdn.com/b/twistylittlepassagesallalike/archive/2011/04/23/everyone-quotes-arguments-the-wrong-way.aspx
-    static string ArgvToCommandLine(vector<string> const& arguments, bool preserve = false)
-    {
-        // Unless we're told otherwise, don't quote unless we actually need to do so - hopefully avoid problems if
-        // programs won't parse quotes properly.
-        string commandline;
-        for (auto const& arg : arguments) {
-            if (arg.empty()) {
-                continue;
-            } else if (preserve || arg.find_first_of(" \t\n\v\"") == arg.npos) {
-                commandline += arg;
-            } else {
-                commandline += '"';
-                for (auto it = arg.begin(); ; ++it) {
-                    unsigned num_back_slashes = 0;
-                    while (it != arg.end() && *it == '\\') {
-                        ++it;
-                        ++num_back_slashes;
-                    }
-                    if (it == arg.end()) {
-                        // Escape all backslashes, but let the terminating double quotation mark we add below be
-                        // interpreted as a metacharacter.
-                        commandline.append(num_back_slashes * 2, '\\');
-                        break;
-                    } else if (*it == '"') {
-                        // Escape all backslashes and the following double quotation mark.
-                        commandline.append(num_back_slashes * 2 + 1, '\\');
-                        commandline.push_back(*it);
-                    } else {
-                        // Backslashes aren't special here.
-                        commandline.append(num_back_slashes, '\\');
-                        commandline.push_back(*it);
-                    }
-                }
-                commandline += '"';
-            }
-            commandline += ' ';
-        }
-        // Strip the trailing space.
-        boost::trim_right(commandline);
-        return commandline;
-    }
-    // Represents information about a pipe
-    struct pipe
-    {
-        // cppcheck-suppress passedByValue
-        pipe(string pipe_name, scoped_handle pipe_handle, function<bool(string const&)> cb) :
-            name(move(pipe_name)),
-            handle(move(pipe_handle)),
-            overlapped{},
-            pending(false),
-            read(true),
-            callback(move(cb))
-        {
-            init();
-        }
-        // cppcheck-suppress passedByValue
-        pipe(string pipe_name, scoped_handle pipe_handle, string buf) :
-            name(move(pipe_name)),
-            handle(move(pipe_handle)),
-            overlapped{},
-            pending(false),
-            read(false),
-            buffer(move(buf))
-        {
-            init();
-        }
-        const string name;
-        scoped_handle handle;
-        OVERLAPPED overlapped;
-        scoped_handle event;
-        bool pending;
-        bool read;
-        string buffer;
-        function<bool(string const&)> callback;
-     private:
-        void init()
-        {
-            if (handle != INVALID_HANDLE_VALUE) {
-                event = scoped_handle(CreateEvent(nullptr, TRUE, FALSE, nullptr));
-                if (!event) {
-                    LOG_ERROR("failed to create {1} read event: {2}.", name, windows::system_error());
-                    throw execution_exception(_("failed to create read event."));
-                }
-                overlapped.hEvent = event;
-            }
-        }
-    };
-    static void rw_from_child(DWORD child, array<pipe, 3>& pipes, uint32_t timeout, HANDLE timer, bool convert_newlines)
-    {
-        vector<HANDLE> wait_handles;
-        while (true)
-        {
-            // Process all pipes
-            for (auto& pipe : pipes) {
-                // If the handle is closed or is pending, skip
-                if (pipe.handle == INVALID_HANDLE_VALUE || pipe.pending) {
-                    continue;
-                }
-                // Process the pipe until pending
-                while (true) {
-                    // Before doing anything, check to see if there's been a timeout
-                    // This is done pre-emptively in case ReadFile never returns ERROR_IO_PENDING
-                    if (timeout && WaitForSingleObject(timer, 0) == WAIT_OBJECT_0) {
-                        throw timeout_exception(_("command timed out after {1} seconds.", timeout), static_cast<size_t>(child));
-                    }
-                    if (pipe.read) {
-                        // Read the data
-                        pipe.buffer.resize(4096);
-                    }
-                    DWORD count = 0;
-                    auto success = pipe.read ?
-                        ReadFile(pipe.handle, &pipe.buffer[0], pipe.buffer.size(), &count, &pipe.overlapped) :
-                        WriteFile(pipe.handle, pipe.buffer.c_str(), pipe.buffer.size(), &count, &pipe.overlapped);
-                    if (!success) {
-                        // Treat broken pipes as closed pipes
-                        if (GetLastError() == ERROR_BROKEN_PIPE) {
-                            pipe.handle = {};
-                            break;
-                        }
-                        // Check to see if it's a pending operation
-                        if (GetLastError() == ERROR_IO_PENDING) {
-                            pipe.pending = true;
-                            break;
-                        }
-                        LOG_ERROR("{1} pipe i/o failed: {2}.", pipe.name, windows::system_error());
-                        throw execution_exception(_("child i/o failed."));
-                    }
-                    // Check for closed pipe
-                    if (count == 0) {
-                        pipe.handle = {};
-                        break;
-                    }
-                    if (pipe.read) {
-                        // Read completed immediately, process the data
-                        pipe.buffer.resize(count);
-                        if (convert_newlines) {
-                            pipe.buffer.erase(
-                                std::remove(pipe.buffer.begin(), pipe.buffer.end(), '\r'),
-                                pipe.buffer.end());
-                        }
-                        if (!pipe.callback(pipe.buffer)) {
-                            // Callback signaled that we're done
-                            return;
-                        }
-                    } else {
-                        // Register written data
-                        pipe.buffer.erase(0, count);
-                    }
-                }
-            }
-            // All pipes should be pending now
-            wait_handles.clear();
-            for (auto const& pipe : pipes) {
-                if (pipe.handle == INVALID_HANDLE_VALUE || !pipe.pending) {
-                    continue;
-                }
-                wait_handles.push_back(pipe.event);
-            }
-            // If no wait handles, then we're done processing
-            if (wait_handles.empty()) {
-                return;
-            }
-            if (timeout) {
-                wait_handles.push_back(timer);
-            }
-            // Wait for data (and, optionally, timeout)
-            auto result = WaitForMultipleObjects(wait_handles.size(), wait_handles.data(), FALSE, INFINITE);
-            if (result >= (WAIT_OBJECT_0 + wait_handles.size())) {
-                LOG_ERROR("failed to wait for child process i/o: {1}.", windows::system_error());
-                throw execution_exception(_("failed to wait for child process i/o."));
-            }
-            // Check for timeout
-            DWORD index = result - WAIT_OBJECT_0;
-            if (timeout && wait_handles[index] == timer) {
-                throw timeout_exception(_("command timed out after {1} seconds.", timeout), static_cast<size_t>(child));
-            }
-            // Find the pipe for the event that was signalled
-            for (auto& pipe : pipes) {
-                if (pipe.handle == INVALID_HANDLE_VALUE || !pipe.pending || pipe.event != wait_handles[index]) {
-                    continue;
-                }
-                // Pipe is no longer pending
-                pipe.pending = false;
-                // Get the overlapped result and process it
-                DWORD count = 0;
-                if (!GetOverlappedResult(pipe.handle, &pipe.overlapped, &count, FALSE)) {
-                    if (GetLastError() != ERROR_BROKEN_PIPE) {
-                        LOG_ERROR("asynchronous i/o on {1} failed: {2}.", pipe.name, windows::system_error());
-                        throw execution_exception(_("asynchronous i/o failed."));
-                    }
-                    // Treat a broken pipe as nothing left to read
-                    count = 0;
-                }
-                // Check for closed pipe
-                if (count == 0) {
-                    pipe.handle = {};
-                    break;
-                }
-                if (pipe.read) {
-                    // Read completed, process the data
-                    pipe.buffer.resize(count);
-                    if (convert_newlines) {
-                        pipe.buffer.erase(
-                            std::remove(pipe.buffer.begin(), pipe.buffer.end(), '\r'),
-                            pipe.buffer.end());
-                    }
-                    if (!pipe.callback(pipe.buffer)) {
-                        // Callback signaled that we're done
-                        return;
-                    }
-                } else {
-                    // Register written data
-                    pipe.buffer.erase(0, count);
-                }
-                break;
-            }
-        }
-    }
-    result execute(
-        string const& file,
-        vector<string> const* arguments,
-        string const* input,
-        map<string, string> const* environment,
-        function<void(size_t)> const& pid_callback,
-        function<bool(string&)> const& stdout_callback,
-        function<bool(string&)> const& stderr_callback,
-        option_set<execution_options> const& options,
-        uint32_t timeout)
-    {
-        // Since we use a job object in the windows world, we want to
-        // be sure we're not in a job object, or at least able to
-        // break our processes out if we are in one.
-        BOOL in_job;
-        bool use_job_object = true;
-        if (!IsProcessInJob(GetCurrentProcess(), nullptr, &in_job)) {
-            throw execution_exception(_("could not determine if the parent process is running in a job object"));
-        }
-        if (in_job) {
-            JOBOBJECT_BASIC_LIMIT_INFORMATION limits;
-            if (!QueryInformationJobObject(nullptr, JobObjectBasicLimitInformation, &limits, sizeof(limits), nullptr)
-                || !(limits.LimitFlags & JOB_OBJECT_LIMIT_BREAKAWAY_OK)) {  // short-circuits if QueryInformationJobObject fails
-                use_job_object = false;
-            }
-        }
-        // Search for the executable
-        string executable = which(file);
-        log_execution(executable.empty() ? file : executable, arguments);
-        if (executable.empty()) {
-            LOG_DEBUG("{1} was not found on the PATH.", file);
-            if (options[execution_options::throw_on_nonzero_exit]) {
-                throw child_exit_exception(_("child process returned non-zero exit status."), 127, {}, {});
-            }
-            return {false, "", "", 127, 0};
-        }
-        // Setup the execution environment
-        vector<wchar_t> modified_environ;
-        vector<scoped_env> scoped_environ;
-        if (options[execution_options::merge_environment]) {
-            // Modify the existing environment, then restore it after. There's no way to modify environment variables
-            // after the child has started. An alternative would be to use GetEnvironmentStrings and add/modify the block,
-            // but searching for and modifying existing environment strings to update would be cumbersome in that form.
-            // See http://msdn.microsoft.com/en-us/library/windows/desktop/ms682009(v=vs.85).aspx
-            if (!options[execution_options::inherit_locale]) {
-                // Unless inherit_locale is specified, override with a C locale to ensure consistent behavior from
-                // command-line tools.
-                if (!environment || environment->count("LC_ALL") == 0) {
-                    scoped_environ.emplace_back("LC_ALL", "C");
-                }
-                if (!environment || environment->count("LANG") == 0) {
-                    scoped_environ.emplace_back("LANG", "C");
-                }
-            }
-            if (environment) {
-                for (auto const& kv : *environment) {
-                    // Use scoped_env to save the old state and restore it on return.
-                    LOG_DEBUG("child environment {1}={2}", kv.first, kv.second);
-                    scoped_environ.emplace_back(kv.first, kv.second);
-                }
-            }
-        } else {
-            // We aren't inheriting the environment, so create an environment block instead of changing existing env.
-            // Environment variables must be sorted alphabetically and case-insensitive,
-            // so copy them all into the same map with case-insensitive key compare:
-            //   http://msdn.microsoft.com/en-us/library/windows/desktop/ms682009(v=vs.85).aspx
-            map<string, string, bool(*)(string const&, string const&)> sortedEnvironment(
-                [](string const& a, string const& b) { return ilexicographical_compare(a, b); });
-            if (environment) {
-                sortedEnvironment.insert(environment->begin(), environment->end());
-            }
-            // Insert LANG and LC_ALL if they aren't already present. Emplace ensures this behavior.
-            string locale_env;
-            if (options[execution_options::inherit_locale] && environment::get("LC_ALL", locale_env)) {
-                sortedEnvironment.emplace("LC_ALL", locale_env);
-            } else if (!options[execution_options::inherit_locale]) {
-                sortedEnvironment.emplace("LC_ALL", "C");
-            }
-            if (options[execution_options::inherit_locale] && environment::get("LANG", locale_env)) {
-                sortedEnvironment.emplace("LANG", locale_env);
-            } else if (!options[execution_options::inherit_locale]) {
-                sortedEnvironment.emplace("LANG", "C");
-            }
-            // An environment block is a NULL-terminated list of NULL-terminated strings.
-            for (auto const& variable : sortedEnvironment) {
-                LOG_DEBUG("child environment {1}={2}", variable.first, variable.second);
-                string var = variable.first + "=" + variable.second;
-                for (auto c : boost::nowide::widen(var)) {
-                    modified_environ.push_back(c);
-                }
-                modified_environ.push_back(L'\0');
-            }
-            modified_environ.push_back(L'\0');
-            if (sortedEnvironment.empty()) {
-                // The environment block is terminated by two nulls, so if the environment is
-                // empty add a second one.
-                modified_environ.push_back(L'\0');
-            }
-        }
-        // Execute the command, reading the results into a buffer until there's no more to read.
-        // See http://msdn.microsoft.com/en-us/library/windows/desktop/ms682499(v=vs.85).aspx
-        // for details on redirecting input/output.
-        scoped_handle stdInRd, stdInWr;
-        tie(stdInRd, stdInWr) = CreatePipeThrow();
-        if (!SetHandleInformation(stdInWr, HANDLE_FLAG_INHERIT, 0)) {
-            throw execution_exception(_("pipe could not be modified"));
-        }
-        scoped_handle stdOutRd, stdOutWr;
-        tie(stdOutRd, stdOutWr) = CreatePipeThrow();
-        if (!SetHandleInformation(stdOutRd, HANDLE_FLAG_INHERIT, 0)) {
-            throw execution_exception(_("pipe could not be modified"));
-        }
-        scoped_handle stdErrRd, stdErrWr;
-        if (!options[execution_options::redirect_stderr_to_stdout]) {
-            // If redirecting to null, open the "NUL" device and inherit the handle
-            if (options[execution_options::redirect_stderr_to_null]) {
-                SECURITY_ATTRIBUTES attributes = {};
-                attributes.nLength = sizeof(SECURITY_ATTRIBUTES);
-                attributes.bInheritHandle = TRUE;
-                stdErrWr = scoped_handle(CreateFileW(L"nul", GENERIC_WRITE, FILE_SHARE_WRITE, &attributes, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr));
-                if (stdErrWr == INVALID_HANDLE_VALUE) {
-                    throw execution_exception(_("cannot open NUL device for redirecting stderr."));
-                }
-            } else {
-                // Otherwise, we're reading from stderr, so create a pipe
-                tie(stdErrRd, stdErrWr) = CreatePipeThrow();
-                if (!SetHandleInformation(stdErrRd, HANDLE_FLAG_INHERIT, 0)) {
-                    throw execution_exception(_("pipe could not be modified"));
-                }
-            }
-        }
-        // Execute the command with arguments. Prefix arguments with the executable, or quoted arguments won't work.
-        auto commandLine = arguments ?
-            boost::nowide::widen(ArgvToCommandLine({ executable }) + " " + ArgvToCommandLine(*arguments, options[execution_options::preserve_arguments])) : L"";
-        STARTUPINFO startupInfo = {};
-        startupInfo.cb = sizeof(startupInfo);
-        startupInfo.dwFlags |= STARTF_USESTDHANDLES;
-        startupInfo.hStdInput = stdInRd;
-        startupInfo.hStdOutput = stdOutWr;
-        // Set up stderr redirection to out or the pipe (which may be INVALID_HANDLE_VALUE, i.e. "null")
-        if (options[execution_options::redirect_stderr_to_stdout]) {
-            startupInfo.hStdError = stdOutWr;
-        } else {
-            startupInfo.hStdError = stdErrWr;
-        }
-        PROCESS_INFORMATION procInfo = {};
-        // Set up flags for CreateProcess based on whether the create_detached_process
-        // option was set and the parent process is running in a Job object.
-        auto creation_flags = CREATE_NO_WINDOW | CREATE_UNICODE_ENVIRONMENT;
-        if (use_job_object) {
-            creation_flags |= CREATE_BREAKAWAY_FROM_JOB;
-        }
-        if (options[execution_options::create_detached_process]) {
-            creation_flags |= CREATE_NEW_PROCESS_GROUP;
-        }
-        if (!CreateProcessW(
-            boost::nowide::widen(executable).c_str(),
-            &commandLine[0], /* Pass a modifiable string buffer; the contents may be modified */
-            NULL,           /* Don't allow child process to inherit process handle */
-            NULL,           /* Don't allow child process to inherit thread handle */
-            TRUE,           /* Inherit handles from the calling process for communication */
-            creation_flags,
-            options[execution_options::merge_environment] ? NULL : modified_environ.data(),
-            NULL,           /* Use existing current directory */
-            &startupInfo,   /* STARTUPINFO for child process */
-            &procInfo)) {   /* PROCESS_INFORMATION pointer for output */
-            LOG_ERROR("failed to create process: {1}.", windows::system_error());
-            throw execution_exception(_("failed to create child process."));
-        }
-        // Release unused pipes, to avoid any races in process completion.
-        if (!input) {
-            stdInWr.release();
-        }
-        stdInRd.release();
-        stdOutWr.release();
-        stdErrWr.release();
-        scoped_handle hProcess(procInfo.hProcess);
-        scoped_handle hThread(procInfo.hThread);
-        // Use a Job Object to group any child processes spawned by the CreateProcess invocation, so we can
-        // easily stop them in case of a timeout.
-        bool create_job_object = use_job_object && !options[execution_options::create_detached_process];
-        scoped_handle hJob;
-        if (create_job_object) {
-            hJob = scoped_handle(CreateJobObjectW(nullptr, nullptr));
-            if (hJob == NULL) {
-                LOG_ERROR("failed to create job object: {1}.", windows::system_error());
-                throw execution_exception(_("failed to create job object."));
-            } else if (!AssignProcessToJobObject(hJob, hProcess)) {
-                LOG_ERROR("failed to associate process with job object: {1}.", windows::system_error());
-                throw execution_exception(_("failed to associate process with job object."));
-            }
-        }
-        bool terminate = true;
-        scope_exit reaper([&]() {
-            if (terminate) {
-                // Terminate the process on an exception
-                if (create_job_object) {
-                    if (!TerminateJobObject(hJob, -1)) {
-                        LOG_ERROR("failed to terminate process: {1}.", windows::system_error());
-                    }
-                } else {
-                    LOG_WARNING("could not terminate process {1} because a job object could not be used.", procInfo.dwProcessId);
-                }
-            }
-        });
-        // Create a waitable timer if given a timeout
-        scoped_handle timer;
-        if (timeout) {
-            timer = scoped_handle(CreateWaitableTimer(nullptr, TRUE, nullptr));
-            if (!timer) {
-                LOG_ERROR("failed to create waitable timer: {1}.", windows::system_error());
-                throw execution_exception(_("failed to create waitable timer."));
-            }
-            // "timeout" in X intervals in the future (1 interval = 100 ns)
-            // The negative value indicates relative to the current time
-            LARGE_INTEGER future;
-            future.QuadPart = timeout * -10000000ll;
-            if (!SetWaitableTimer(timer, &future, 0, nullptr, nullptr, FALSE)) {
-                LOG_ERROR("failed to set waitable timer: {1}.", windows::system_error());
-                throw execution_exception(_("failed to set waitable timer."));
-            }
-        }
-        // Execute the PID callback
-        if (pid_callback) {
-            pid_callback(procInfo.dwProcessId);
-        }
-        string output, error;
-        tie(output, error) = process_streams(options[execution_options::trim_output], stdout_callback, stderr_callback, [&](function<bool(string const&)> const& process_stdout, function<bool(string const&)> const& process_stderr) {
-            // Read the child output
-            array<pipe, 3> pipes = { {
-                input ? pipe("stdin", move(stdInWr), *input) : pipe("stdin", {}, ""),
-                pipe("stdout", move(stdOutRd), process_stdout),
-                pipe("stderr", move(stdErrRd), process_stderr)
-            } };
-            rw_from_child(procInfo.dwProcessId, pipes, timeout, timer, options[execution_options::convert_newlines]);
-        });
-        HANDLE handles[2] = { hProcess, timer };
-        auto wait_result = WaitForMultipleObjects(timeout ? 2 : 1, handles, FALSE, INFINITE);
-        if (wait_result == WAIT_OBJECT_0) {
-            // Process has terminated
-            terminate = false;
-        } else if (wait_result == WAIT_OBJECT_0 + 1) {
-            // Timeout while waiting on the process to complete
-            throw timeout_exception(_("command timed out after {1} seconds.", timeout), static_cast<size_t>(procInfo.dwProcessId));
-        } else {
-            LOG_ERROR("failed to wait for child process to terminate: {1}.", windows::system_error());
-            throw execution_exception(_("failed to wait for child process to terminate."));
-        }
-        // Now check the process return status.
-        DWORD exit_code;
-        if (!GetExitCodeProcess(hProcess, &exit_code)) {
-            throw execution_exception(_("error retrieving exit code of completed process"));
-        }
-        LOG_DEBUG("process exited with exit code {1}.", exit_code);
-        if (exit_code != 0 && options[execution_options::throw_on_nonzero_exit]) {
-            throw child_exit_exception(_("child process returned non-zero exit status."), exit_code, output, error);
-        }
-        return {exit_code == 0, move(output), move(error), static_cast<int>(exit_code), static_cast<size_t>(procInfo.dwProcessId)};
-    }
-}}  // namespace leatherman::execution