/home/Boris/posix_boost_1_36_0/boost/process/detail/posix_ops.hpp

Go to the documentation of this file.

// 
// Boost.Process 
// ~~~~~~~~~~~~~ 
// 
// Copyright (c) 2006, 2007 Julio M. Merino Vidal 
// Copyright (c) 2008 Boris Schaeling 
// 
// Distributed under the Boost Software License, Version 1.0. (See accompanying 
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 
// 

#ifndef BOOST_PROCESS_DETAIL_POSIX_OPS_HPP 
#define BOOST_PROCESS_DETAIL_POSIX_OPS_HPP 

#include <boost/process/environment.hpp> 
#include <boost/process/detail/file_handle.hpp> 
#include <boost/process/detail/pipe.hpp> 
#include <boost/process/detail/stream_info.hpp> 
#include <boost/scoped_array.hpp> 
#include <boost/assert.hpp> 
#include <boost/system/system_error.hpp> 
#include <boost/throw_exception.hpp> 
#include <map> 
#include <utility> 
#include <string> 
#include <cerrno> 
#include <cstdlib> 
#include <cstring> 
#include <fcntl.h> 
#include <unistd.h> 

namespace boost { 
namespace process { 
namespace detail { 

template <class Arguments> 
inline std::pair<std::size_t, char**> collection_to_posix_argv(const Arguments &args) 
{ 
    std::size_t nargs = args.size(); 
    BOOST_ASSERT(nargs > 0); 

    char **argv = new char*[nargs + 1]; 
    typename Arguments::size_type i = 0; 
    for (typename Arguments::const_iterator it = args.begin(); it != args.end(); ++it) 
    { 
        argv[i] = new char[it->size() + 1]; 
        std::strncpy(argv[i], it->c_str(), it->size() + 1); 
        ++i; 
    } 
    argv[nargs] = 0; 

    return std::pair<std::size_t, char**>(nargs, argv); 
} 

inline char **environment_to_envp(const environment &env) 
{ 
    char **envp = new char*[env.size() + 1]; 

    environment::size_type i = 0; 
    for (environment::const_iterator it = env.begin(); it != env.end(); ++it) 
    { 
        std::string s = it->first + "=" + it->second; 
        envp[i] = new char[s.size() + 1]; 
        std::strncpy(envp[i], s.c_str(), s.size() + 1); 
        ++i; 
    } 
    envp[i] = 0; 

    return envp; 
} 

typedef std::map<int, stream_info> info_map; 

struct posix_setup 
{ 
    std::string work_directory; 

    std::string chroot; 

    uid_t uid; 

    uid_t euid; 

    gid_t gid; 

    gid_t egid; 

    posix_setup() 
        : uid(::getuid()), 
        euid(::geteuid()), 
        gid(::getgid()), 
        egid(::getegid()) 
    { 
    } 

    void operator()() const 
    { 
        if (!chroot.empty() && ::chroot(chroot.c_str()) == -1) 
            boost::throw_exception(boost::system::system_error(boost::system::error_code(errno, boost::system::get_system_category()), "boost::process::detail::posix_setup: chroot(2) failed")); 

        if (gid != ::getgid() && ::setgid(gid) == -1) 
            boost::throw_exception(boost::system::system_error(boost::system::error_code(errno, boost::system::get_system_category()), "boost::process::detail::posix_setup: setgid(2) failed")); 

        if (egid != ::getegid() && ::setegid(egid) == -1) 
            boost::throw_exception(boost::system::system_error(boost::system::error_code(errno, boost::system::get_system_category()), "boost::process::detail::posix_setup: setegid(2) failed")); 

        if (uid != ::getuid() && ::setuid(uid) == -1) 
            boost::throw_exception(boost::system::system_error(boost::system::error_code(errno, boost::system::get_system_category()), "boost::process::detail::posix_setup: setuid(2) failed")); 

        if (euid != ::geteuid() && ::seteuid(euid) == -1) 
            boost::throw_exception(boost::system::system_error(boost::system::error_code(errno, boost::system::get_system_category()), "boost::process::detail::posix_setup: seteuid(2) failed")); 

        BOOST_ASSERT(!work_directory.empty()); 
        if (::chdir(work_directory.c_str()) == -1) 
            boost::throw_exception(boost::system::system_error(boost::system::error_code(errno, boost::system::get_system_category()), "boost::process::detail::posix_setup: chdir(2) failed")); 
    } 
}; 

inline void setup_input(info_map &info, bool *closeflags, int maxdescs) 
{ 
    for (info_map::iterator it = info.begin(); it != info.end(); ++it) 
    { 
        int d = it->first; 
        stream_info &si = it->second; 

        BOOST_ASSERT(d < maxdescs); 
        closeflags[d] = false; 

        switch (si.type_) 
        { 
        case stream_info::use_file: 
            { 
                int fd = ::open(si.file_.c_str(), O_RDONLY); 
                if (fd == -1) 
                    boost::throw_exception(boost::system::system_error(boost::system::error_code(errno, boost::system::get_system_category()), "boost::process::detail::setup_input: open(2) of " + si.file_ + " failed")); 
                if (fd != d) 
                { 
                    file_handle h(fd); 
                    h.posix_remap(d); 
                    h.release(); 
                } 
                break; 
            } 
        case stream_info::use_handle: 
            { 
                if (si.handle_.get() != d) 
                    si.handle_.posix_remap(d); 
                break; 
            } 
        case stream_info::use_pipe: 
            { 
                si.pipe_->wend().close(); 
                if (d != si.pipe_->rend().get()) 
                    si.pipe_->rend().posix_remap(d); 
                break; 
            } 
        default: 
            { 
                BOOST_ASSERT(si.type_ == stream_info::inherit); 
                break; 
            } 
        } 
    } 
} 

inline void setup_output(info_map &info, bool *closeflags, int maxdescs) 
{ 
    for (info_map::iterator it = info.begin(); it != info.end(); ++it) 
    { 
        int d = it->first; 
        stream_info &si = it->second; 

        BOOST_ASSERT(d < maxdescs); 
        closeflags[d] = false; 

        switch (si.type_) 
        { 
        case stream_info::redirect: 
            { 
                break; 
            } 
        case stream_info::use_file: 
            { 
                int fd = ::open(si.file_.c_str(), O_WRONLY); 
                if (fd == -1) 
                    boost::throw_exception(boost::system::system_error(boost::system::error_code(errno, boost::system::get_system_category()), "boost::process::detail::setup_output: open(2) of " + si.file_ + " failed")); 
                if (fd != d) 
                { 
                    file_handle h(fd); 
                    h.posix_remap(d); 
                    h.release(); 
                } 
                break; 
            } 
        case stream_info::use_handle: 
            { 
                if (si.handle_.get() != d) 
                    si.handle_.posix_remap(d); 
                break; 
            } 
        case stream_info::use_pipe: 
            { 
                si.pipe_->rend().close(); 
                if (d != si.pipe_->wend().get()) 
                    si.pipe_->wend().posix_remap(d); 
                break; 
            } 
        default: 
            { 
                BOOST_ASSERT(si.type_ == stream_info::inherit); 
                break; 
            } 
        } 
    } 

    for (info_map::const_iterator it = info.begin(); it != info.end(); ++it) 
    { 
        int d = it->first; 
        const stream_info &si = it->second; 

        if (si.type_ == stream_info::redirect) 
            file_handle::posix_dup(si.desc_to_, d).release(); 
    } 
} 

template <class Executable, class Arguments> 
inline pid_t posix_start(const Executable &exe, const Arguments &args, const environment &env, info_map &infoin, info_map &infoout, const posix_setup &setup) 
{ 
    pid_t pid = ::fork(); 
    if (pid == -1) 
        boost::throw_exception(boost::system::system_error(boost::system::error_code(errno, boost::system::get_system_category()), "boost::process::detail::posix_start: fork(2) failed")); 
    else if (pid == 0) 
    { 
#if defined(F_MAXFD) 
        int maxdescs = ::fcntl(-1, F_MAXFD, 0); 
        if (maxdescs == -1) 
            maxdescs = ::sysconf(_SC_OPEN_MAX); 
#else 
        int maxdescs = ::sysconf(_SC_OPEN_MAX); 
#endif 
        if (maxdescs == -1) 
            maxdescs = 1024; 
        try 
        { 
            boost::scoped_array<bool> closeflags(new bool[maxdescs]); 
            for (int i = 0; i < maxdescs; ++i) 
                closeflags[i] = true; 

            setup_input(infoin, closeflags.get(), maxdescs); 
            setup_output(infoout, closeflags.get(), maxdescs); 

            for (int i = 0; i < maxdescs; ++i) 
            { 
                if (closeflags[i]) 
                    ::close(i); 
            } 

            setup(); 
        } 
        catch (const boost::system::system_error &e) 
        { 
            ::write(STDERR_FILENO, e.what(), std::strlen(e.what())); 
            ::write(STDERR_FILENO, "\n", 1); 
            ::exit(EXIT_FAILURE); 
        } 

        std::pair<std::size_t, char**> argcv = collection_to_posix_argv(args); 
        char **envp = environment_to_envp(env); 

        ::execve(exe.c_str(), argcv.second, envp); 
        boost::system::system_error e(boost::system::error_code(errno, boost::system::get_system_category()), "boost::process::detail::posix_start: execve(2) failed"); 

        for (std::size_t i = 0; i < argcv.first; ++i) 
            delete[] argcv.second[i]; 
        delete[] argcv.second; 

        for (std::size_t i = 0; i < env.size(); ++i) 
            delete[] envp[i]; 
        delete[] envp; 

        ::write(STDERR_FILENO, e.what(), std::strlen(e.what())); 
        ::write(STDERR_FILENO, "\n", 1); 
        ::exit(EXIT_FAILURE); 
    } 

    BOOST_ASSERT(pid > 0); 

    for (info_map::iterator it = infoin.begin(); it != infoin.end(); ++it) 
    { 
        stream_info &si = it->second; 
        if (si.type_ == stream_info::use_pipe) 
            si.pipe_->rend().close(); 
    } 

    for (info_map::iterator it = infoout.begin(); it != infoout.end(); ++it) 
    { 
        stream_info &si = it->second; 
        if (si.type_ == stream_info::use_pipe) 
            si.pipe_->wend().close(); 
    } 

    return pid; 
} 

inline file_handle posix_info_locate_pipe(info_map &info, int desc, bool out) 
{ 
    file_handle fh; 

    info_map::iterator it = info.find(desc); 
    if (it != info.end()) 
    { 
        stream_info &si = it->second; 
        if (si.type_ == stream_info::use_pipe) 
        { 
            fh = out ? si.pipe_->rend().release() : si.pipe_->wend().release(); 
            BOOST_ASSERT(fh.valid()); 
        } 
        info.erase(it); 
    } 

    return fh; 
} 

} 
} 
} 

#endif 

---