/home/Boris/posix_boost_1_36_0/boost/process/detail/file_handle.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_FILE_HANDLE_HPP 
#define BOOST_PROCESS_DETAIL_FILE_HANDLE_HPP 

#include <boost/process/config.hpp> 

#if defined(BOOST_POSIX_API) 
#  include <cerrno> 
#  include <unistd.h> 
#elif defined(BOOST_WINDOWS_API) 
#  include <windows.h> 
#else 
#  error "Unsupported platform." 
#endif 

#include <boost/assert.hpp> 
#include <boost/system/system_error.hpp> 
#include <boost/throw_exception.hpp> 

namespace boost { 
namespace process { 
namespace detail { 

class file_handle 
{ 
public: 
#if defined(BOOST_PROCESS_DOXYGEN) 

    typedef NativeSystemHandle handle_type; 
#elif defined(BOOST_POSIX_API) 
    typedef int handle_type; 
#elif defined(BOOST_WINDOWS_API) 
    typedef HANDLE handle_type; 
#endif 

    file_handle() 
        : handle_(invalid_value()) 
    { 
    } 

    file_handle(handle_type h) 
        : handle_(h) 
    { 
        BOOST_ASSERT(handle_ != invalid_value()); 
    } 

    file_handle(const file_handle &fh) 
        : handle_(fh.handle_) 
    { 
        fh.handle_ = invalid_value(); 
    } 

    ~file_handle() 
    { 
        if (valid()) 
            close(); 
    } 

    file_handle &operator=(const file_handle &fh) 
    { 
        handle_ = fh.handle_; 
        fh.handle_ = invalid_value(); 
        return *this; 
    } 

    bool valid() const 
    { 
        return handle_ != invalid_value(); 
    } 

    void close() 
    { 
        BOOST_ASSERT(valid()); 

#if defined(BOOST_POSIX_API) 
        ::close(handle_); 
#elif defined(BOOST_WINDOWS_API) 
        ::CloseHandle(handle_); 
#endif 

        handle_ = invalid_value(); 
    } 

    handle_type release() 
    { 
        BOOST_ASSERT(valid()); 

        handle_type h = handle_; 
        handle_ = invalid_value(); 
        return h; 
    } 

    handle_type get() const 
    { 
        BOOST_ASSERT(valid()); 

        return handle_; 
    } 

#if defined(BOOST_POSIX_API) || defined(BOOST_PROCESS_DOXYGEN) 

    void posix_remap(handle_type h) 
    { 
        BOOST_ASSERT(valid()); 

        if (::dup2(handle_, h) == -1) 
            boost::throw_exception(boost::system::system_error(boost::system::error_code(errno, boost::system::get_system_category()), "boost::process::detail::file_handle::posix_remap: dup2(2) failed")); 

        if (::close(handle_) == -1) 
        { 
            ::close(h); 
            boost::throw_exception(boost::system::system_error(boost::system::error_code(errno, boost::system::get_system_category()), "boost::process::detail::file_handle::posix_remap: close(2) failed")); 
        } 

        handle_ = h; 
    } 

    static file_handle posix_dup(int h1, int h2) 
    { 
        if (::dup2(h1, h2) == -1) 
            boost::throw_exception(boost::system::system_error(boost::system::error_code(errno, boost::system::get_system_category()), "boost::process::detail::file_handle::posix_dup: dup2(2) failed")); 

        return file_handle(h2); 
    } 
#endif 

#if defined(BOOST_WINDOWS_API) || defined(BOOST_PROCESS_DOXYGEN) 

    static file_handle win32_dup(HANDLE h, bool inheritable) 
    { 
        HANDLE h2; 
        if (!::DuplicateHandle(::GetCurrentProcess(), h, ::GetCurrentProcess(), &h2, 0, inheritable ? TRUE : FALSE, DUPLICATE_SAME_ACCESS)) 
            boost::throw_exception(boost::system::system_error(boost::system::error_code(::GetLastError(), boost::system::get_system_category()), "boost::process::detail::file_handle::win32_dup: DuplicateHandle failed")); 

        return file_handle(h2); 
    } 

    static file_handle win32_std(DWORD d, bool inheritable) 
    { 
        BOOST_ASSERT(d == STD_INPUT_HANDLE || d == STD_OUTPUT_HANDLE || d == STD_ERROR_HANDLE); 

        HANDLE h = ::GetStdHandle(d); 
        if (h == INVALID_HANDLE_VALUE) 
            boost::throw_exception(boost::system::system_error(boost::system::error_code(::GetLastError(), boost::system::get_system_category()), "boost::process::detail::file_handle::win32_std: GetStdHandle failed")); 

        return win32_dup(h, inheritable); 
    } 

    void win32_set_inheritable(bool i) 
    { 
        BOOST_ASSERT(valid()); 

        if (!::SetHandleInformation(handle_, HANDLE_FLAG_INHERIT, i ? HANDLE_FLAG_INHERIT : 0)) 
            boost::throw_exception(boost::system::system_error(boost::system::error_code(::GetLastError(), boost::system::get_system_category()), "boost::process::detail::file_handle::win32_set_inheritable: SetHandleInformation failed")); 
    } 
#endif 

private: 
    mutable handle_type handle_; 

    static const handle_type invalid_value() 
    { 
#if defined(BOOST_POSIX_API) 
        return -1; 
#elif defined(BOOST_WINDOWS_API) 
        return INVALID_HANDLE_VALUE; 
#endif 
    } 
}; 

} 
} 
} 

#endif 

---