Subject: [Boost-commit] svn:boost r61904 - sandbox/SOC/2010/process/boost/process/details
From: fotanus_at_[hidden]
Date: 2010-05-11 01:26:57
Author: fotanus
Date: 2010-05-11 01:26:56 EDT (Tue, 11 May 2010)
New Revision: 61904
URL: http://svn.boost.org/trac/boost/changeset/61904
Log:
Missing files from previous commit
Added:
sandbox/SOC/2010/process/boost/process/details/
sandbox/SOC/2010/process/boost/process/details/file_handle.hpp (contents, props changed)
sandbox/SOC/2010/process/boost/process/details/pipe.hpp (contents, props changed)
sandbox/SOC/2010/process/boost/process/details/posix_ops.hpp (contents, props changed)
sandbox/SOC/2010/process/boost/process/details/stream_info.hpp (contents, props changed)
sandbox/SOC/2010/process/boost/process/details/systembuf.hpp (contents, props changed)
sandbox/SOC/2010/process/boost/process/details/win32_ops.hpp (contents, props changed)
Added: sandbox/SOC/2010/process/boost/process/details/file_handle.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/process/boost/process/details/file_handle.hpp 2010-05-11 01:26:56 EDT (Tue, 11 May 2010)
@@ -0,0 +1,406 @@
+//
+// Boost.Process
+// ~~~~~~~~~~~~~
+//
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008, 2009 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)
+//
+
+/**
+ * \file boost/process/detail/file_handle.hpp
+ *
+ * Includes the declaration of the file_handle class. This file is for
+ * internal usage only and must not be included by the library user.
+ */
+
+#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 {
+
+/**
+ * Simple RAII model for system file handles.
+ *
+ * The \a file_handle class is a simple RAII model for native system file
+ * handles. This class wraps one of such handles grabbing its ownership,
+ * and automaticaly closes it upon destruction. It is basically used
+ * inside the library to avoid leaking open file handles, shall an
+ * unexpected execution trace occur.
+ *
+ * A \a file_handle object can be copied but doing so invalidates the
+ * source object. There can only be a single valid \a file_handle object
+ * for a given system file handle. This is similar to std::auto_ptr's
+ * semantics.
+ *
+ * This class also provides some convenience methods to issue special file
+ * operations under their respective platforms.
+ */
+class file_handle
+{
+public:
+#if defined(BOOST_PROCESS_DOXYGEN)
+ /**
+ * Opaque name for the native handle type.
+ *
+ * Each operating system identifies file handles using a specific type.
+ * The \a handle_type type is used to transparently refer to file
+ * handles regarless of the operating system in which this class is
+ * used.
+ *
+ * If this class is used on a POSIX system, \a NativeSystemHandle is
+ * an integer type while it is a \a HANDLE on a Windows system.
+ */
+ typedef NativeSystemHandle handle_type;
+#elif defined(BOOST_POSIX_API)
+ typedef int handle_type;
+#elif defined(BOOST_WINDOWS_API)
+ typedef HANDLE handle_type;
+#endif
+
+ /**
+ * Constructs an invalid file handle.
+ *
+ * This constructor creates a new \a file_handle object that represents
+ * an invalid file handle. An invalid file handle can be copied but
+ * cannot be manipulated in any way (except checking for its validity).
+ *
+ * \see valid()
+ */
+ file_handle()
+ : handle_(invalid_value())
+ {
+ }
+
+ /**
+ * Constructs a new file handle from a native file handle.
+ *
+ * This constructor creates a new \a file_handle object that takes
+ * ownership of the given \a h native file handle. The user must not
+ * close \a h on his own during the lifetime of the new object.
+ * Ownership can be reclaimed using release().
+ *
+ * \pre The native file handle must be valid; a close operation must
+ * succeed on it.
+ * \see release()
+ */
+ file_handle(handle_type h)
+ : handle_(h)
+ {
+ BOOST_ASSERT(handle_ != invalid_value());
+ }
+
+ /**
+ * Copy constructor; invalidates the source handle.
+ *
+ * This copy constructor creates a new file handle from a given one.
+ * Ownership of the native file handle is transferred to the new
+ * object, effectively invalidating the source file handle. This
+ * avoids having two live \a file_handle objects referring to the
+ * same native file handle. The source file handle needs not be
+ * valid in the name of simplicity.
+ *
+ * \post The source file handle is invalid.
+ * \post The new file handle owns the source's native file handle.
+ */
+ file_handle(const file_handle &fh)
+ : handle_(fh.handle_)
+ {
+ fh.handle_ = invalid_value();
+ }
+
+ /**
+ * Releases resources if the handle is valid.
+ *
+ * If the file handle is valid, the destructor closes it.
+ *
+ * \see valid()
+ */
+ ~file_handle()
+ {
+ if (valid())
+ close();
+ }
+
+ /**
+ * Assignment operator; invalidates the source handle.
+ *
+ * This assignment operator transfers ownership of the RHS file
+ * handle to the LHS one, effectively invalidating the source file
+ * handle. This avoids having two live \a file_handle objects
+ * referring to the same native file handle. The source file
+ * handle needs not be valid in the name of simplicity.
+ *
+ * \post The RHS file handle is invalid.
+ * \post The LHS file handle owns RHS' native file handle.
+ * \return A reference to the LHS file handle.
+ */
+ file_handle &operator=(const file_handle &fh)
+ {
+ handle_ = fh.handle_;
+ fh.handle_ = invalid_value();
+ return *this;
+ }
+
+ /**
+ * Checks whether the file handle is valid or not.
+ *
+ * Returns a boolean indicating whether the file handle is valid or
+ * not. If the file handle is invalid, no other methods can be
+ * executed other than the destructor.
+ *
+ * \return true if the file handle is valid; false otherwise.
+ */
+ bool valid() const
+ {
+ return handle_ != invalid_value();
+ }
+
+ /**
+ * Closes the file handle.
+ *
+ * Explicitly closes the file handle, which must be valid. Upon
+ * exit, the handle is not valid any more.
+ *
+ * \pre The file handle is valid.
+ * \post The file handle is invalid.
+ * \post The native file handle is closed.
+ */
+ void close()
+ {
+ BOOST_ASSERT(valid());
+
+#if defined(BOOST_POSIX_API)
+ ::close(handle_);
+#elif defined(BOOST_WINDOWS_API)
+ ::CloseHandle(handle_);
+#endif
+
+ handle_ = invalid_value();
+ }
+
+ /**
+ * Reclaims ownership of the native file handle.
+ *
+ * Explicitly reclaims ownership of the native file handle contained
+ * in the \a file_handle object, returning the native file handle.
+ * The caller is responsible of closing it later on.
+ *
+ * \pre The file handle is valid.
+ * \post The file handle is invalid.
+ * \return The native file handle.
+ */
+ handle_type release()
+ {
+ BOOST_ASSERT(valid());
+
+ handle_type h = handle_;
+ handle_ = invalid_value();
+ return h;
+ }
+
+ /**
+ * Gets the native file handle.
+ *
+ * Returns the native file handle for the \a file_handle object.
+ * The caller can issue any operation on it except closing it.
+ * If closing is required, release() shall be used.
+ *
+ * \pre The file handle is valid.
+ * \post The file handle is valid.
+ * \return The native file handle.
+ */
+ handle_type get() const
+ {
+ BOOST_ASSERT(valid());
+
+ return handle_;
+ }
+
+#if defined(BOOST_POSIX_API) || defined(BOOST_PROCESS_DOXYGEN)
+ /**
+ * Changes the native file handle to the given one.
+ *
+ * Given a new native file handle \a h, this operation assigns this
+ * handle to the current object, closing its old native file handle.
+ * In other words, it first calls dup2() to remap the old handle to
+ * the new one and then closes the old handle.
+ *
+ * If \a h is open, it is automatically closed by dup2().
+ *
+ * This operation is only available in POSIX systems.
+ *
+ * \pre The file handle is valid.
+ * \pre The native file handle \a h is valid; i.e., it must be
+ * closeable.
+ * \post The file handle's native file handle is \a h.
+ * \throw boost::system::system_error If the internal remapping
+ * operation fails.
+ */
+ 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;
+ }
+
+ /**
+ * Duplicates an open native file handle.
+ *
+ * Given a native file handle \a h1, this routine duplicates it so
+ * that it ends up being identified by the native file handle \a h2
+ * and returns a new \a file_handle owning \a h2.
+ *
+ * This operation is only available in POSIX systems.
+ *
+ * \pre The native file handle \a h1 is open.
+ * \pre The native file handle \a h2 is valid (non-negative).
+ * \post The native file handle \a h1 is closed.
+ * \post The native file handle \a h2 is the same as the old \a h1
+ * from the operating system's point of view.
+ * \return A new \a file_handle object that owns \a h2.
+ * \throw boost::system::system_error If dup2() fails.
+ */
+ 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)
+ /**
+ * Duplicates the \a h native file handle.
+ *
+ * Given a native file handle \a h, this routine constructs a new
+ * \a file_handle object that owns a new duplicate of \a h. The
+ * duplicate's inheritable flag is set to the value of \a inheritable.
+ *
+ * This operation is only available in Windows systems.
+ *
+ * \pre The native file handle \a h is valid.
+ * \return A file handle owning a duplicate of \a h.
+ * \throw boost::system::system_error If DuplicateHandle() fails.
+ */
+ 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);
+ }
+
+ /**
+ * Creates a new duplicate of a standard file handle.
+ *
+ * Constructs a new \a file_handle object that owns a duplicate of a
+ * standard file handle. The \a d parameter specifies which standard
+ * file handle to duplicate and can be one of \a STD_INPUT_HANDLE,
+ * \a STD_OUTPUT_HANDLE or \a STD_ERROR_HANDLE. The duplicate's
+ * inheritable flag is set to the value of \a inheritable.
+ *
+ * This operation is only available in Windows systems.
+ *
+ * \pre \a d refers to one of the standard handles as described above.
+ * \return A file handle owning a duplicate of the standard handle
+ * referred to by \a d.
+ * \throw boost::system::system_error If GetStdHandle() or
+ * DuplicateHandle() fails.
+ */
+ 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);
+ }
+
+ /**
+ * Changes the file handle's inheritable flag.
+ *
+ * Changes the file handle's inheritable flag to \a i. It is not
+ * necessary for the file handle's flag to be different than \a i.
+ *
+ * This operation is only available in Windows systems.
+ *
+ * \pre The file handle is valid.
+ * \post The native file handle's inheritable flag is set to \a i.
+ * \throw boost::system::system_error If the property change fails.
+ */
+ 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:
+ /**
+ * Internal handle value.
+ *
+ * This variable holds the native handle value for the file handle
+ * hold by this object. It is interesting to note that this needs
+ * to be mutable because the copy constructor and the assignment
+ * operator invalidate the source object.
+ */
+ mutable handle_type handle_;
+
+ /**
+ * Constant function representing an invalid handle value.
+ *
+ * Returns the platform-specific handle value that represents an
+ * invalid handle. This is a constant function rather than a regular
+ * constant because, in the latter case, we cannot define it under
+ * Windows due to the value being of a complex type.
+ */
+ static const handle_type invalid_value()
+ {
+#if defined(BOOST_POSIX_API)
+ return -1;
+#elif defined(BOOST_WINDOWS_API)
+ return INVALID_HANDLE_VALUE;
+#endif
+ }
+};
+
+}
+}
+}
+
+#endif
Added: sandbox/SOC/2010/process/boost/process/details/pipe.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/process/boost/process/details/pipe.hpp 2010-05-11 01:26:56 EDT (Tue, 11 May 2010)
@@ -0,0 +1,187 @@
+//
+// Boost.Process
+// ~~~~~~~~~~~~~
+//
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008, 2009 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)
+//
+
+/**
+ * \file boost/process/detail/pipe.hpp
+ *
+ * Includes the declaration of the pipe class. This file is for
+ * internal usage only and must not be included by the library user.
+ */
+
+#ifndef BOOST_PROCESS_DETAIL_PIPE_HPP
+#define BOOST_PROCESS_DETAIL_PIPE_HPP
+
+#include <boost/process/config.hpp>
+
+#if defined(BOOST_POSIX_API)
+# include <unistd.h>
+# include <cerrno>
+#elif defined(BOOST_WINDOWS_API)
+# if defined(BOOST_PROCESS_WINDOWS_USE_NAMED_PIPE)
+# include <boost/lexical_cast.hpp>
+# include <string>
+# endif
+# include <windows.h>
+#else
+# error "Unsupported platform."
+#endif
+
+#include <boost/process/detail/file_handle.hpp>
+#include <boost/system/system_error.hpp>
+#include <boost/throw_exception.hpp>
+
+namespace boost {
+namespace process {
+namespace detail {
+
+/**
+ * Simple RAII model for anonymous pipes.
+ *
+ * The pipe class is a simple RAII model for anonymous pipes. It
+ * provides a portable constructor that allocates a new %pipe and creates
+ * a pipe object that owns the two file handles associated to it: the
+ * read end and the write end.
+ *
+ * These handles can be retrieved for modification according to
+ * file_handle semantics. Optionally, their ownership can be transferred
+ * to external \a file_handle objects which comes handy when the two
+ * ends need to be used in different places (i.e. after a POSIX fork()
+ * system call).
+ *
+ * Pipes can be copied following the same semantics as file handles.
+ * In other words, copying a %pipe object invalidates the source one.
+ *
+ * \see file_handle
+ */
+class pipe
+{
+public:
+ /**
+ * Creates a new %pipe.
+ *
+ * The default pipe constructor allocates a new anonymous %pipe
+ * and assigns its ownership to the created pipe object. On Windows
+ * when the macro BOOST_PROCESS_WINDOWS_USE_NAMED_PIPE is defined
+ * a named pipe is created. This is required if asynchronous I/O
+ * should be used as asynchronous I/O is only supported by named
+ * pipes on Windows.
+ *
+ * \throw boost::system::system_error If the anonymous %pipe
+ * creation fails.
+ */
+ pipe()
+ {
+ file_handle::handle_type hs[2];
+
+#if defined(BOOST_POSIX_API)
+ if (::pipe(hs) == -1)
+ boost::throw_exception(boost::system::system_error(boost::system::error_code(errno, boost::system::get_system_category()), "boost::process::detail::pipe::pipe: pipe(2) failed"));
+#elif defined(BOOST_WINDOWS_API)
+ SECURITY_ATTRIBUTES sa;
+ ZeroMemory(&sa, sizeof(sa));
+ sa.nLength = sizeof(sa);
+ sa.lpSecurityDescriptor = NULL;
+ sa.bInheritHandle = FALSE;
+
+# if defined(BOOST_PROCESS_WINDOWS_USE_NAMED_PIPE)
+ static unsigned int nextid = 0;
+ std::string pipe = "\\\\.\\pipe\\boost_process_" + boost::lexical_cast<std::string>(::GetCurrentProcessId()) + "_" + boost::lexical_cast<std::string>(nextid++);
+ hs[0] = ::CreateNamedPipeA(pipe.c_str(), PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED, 0, 1, 8192, 8192, 0, &sa);
+ if (hs[0] == INVALID_HANDLE_VALUE)
+ boost::throw_exception(boost::system::system_error(::GetLastError(), boost::system::system_category, "boost::process::detail::pipe::pipe: CreateNamedPipe failed"));
+ hs[1] = ::CreateFileA(pipe.c_str(), GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
+ if (hs[1] == INVALID_HANDLE_VALUE)
+ boost::throw_exception(boost::system::system_error(::GetLastError(), boost::system::system_category, "boost::process::detail::pipe::pipe: CreateFile failed"));
+
+ OVERLAPPED overlapped;
+ ZeroMemory(&overlapped, sizeof(overlapped));
+ overlapped.hEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
+ if (!overlapped.hEvent)
+ boost::throw_exception(boost::system::system_error(::GetLastError(), boost::system::system_category, "boost::process::detail::pipe::pipe: CreateEvent failed"));
+ BOOL b = ::ConnectNamedPipe(hs[0], &overlapped);
+ if (!b)
+ {
+ if (::GetLastError() == ERROR_IO_PENDING)
+ {
+ if (::WaitForSingleObject(overlapped.hEvent, INFINITE) == WAIT_FAILED)
+ {
+ ::CloseHandle(overlapped.hEvent);
+ boost::throw_exception(boost::system::system_error(::GetLastError(), boost::system::system_category, "boost::process::detail::pipe::pipe: WaitForSingleObject failed"));
+ }
+ }
+ else if (::GetLastError() != ERROR_PIPE_CONNECTED)
+ {
+ ::CloseHandle(overlapped.hEvent);
+ boost::throw_exception(boost::system::system_error(::GetLastError(), boost::system::system_category, "boost::process::detail::pipe::pipe: ConnectNamedPipe failed"));
+ }
+ }
+ ::CloseHandle(overlapped.hEvent);
+# else
+ if (!::CreatePipe(&hs[0], &hs[1], &sa, 0))
+ boost::throw_exception(boost::system::system_error(::GetLastError(), boost::system::system_category, "boost::process::detail::pipe::pipe: CreatePipe failed"));
+# endif
+#endif
+
+ read_end_ = file_handle(hs[0]);
+ write_end_ = file_handle(hs[1]);
+ }
+
+ /**
+ * Returns the %pipe's read end file handle.
+ *
+ * Obtains a reference to the %pipe's read end file handle. Care
+ * should be taken to not duplicate the returned object if ownership
+ * shall remain to the %pipe.
+ *
+ * Duplicating the returned object invalidates its corresponding file
+ * handle in the %pipe.
+ *
+ * \return A reference to the %pipe's read end file handle.
+ */
+ file_handle &rend()
+ {
+ return read_end_;
+ }
+
+ /**
+ * Returns the %pipe's write end file handle.
+ *
+ * Obtains a reference to the %pipe's write end file handle. Care
+ * should be taken to not duplicate the returned object if ownership
+ * shall remain to the %pipe.
+ *
+ * Duplicating the returned object invalidates its corresponding file
+ * handle in the %pipe.
+ *
+ * \return A reference to the %pipe's write end file handle.
+ */
+ file_handle &wend()
+ {
+ return write_end_;
+ }
+
+private:
+ /**
+ * The %pipe's read end file handle.
+ */
+ file_handle read_end_;
+
+ /**
+ * The %pipe's write end file handle.
+ */
+ file_handle write_end_;
+};
+
+}
+}
+}
+
+#endif
Added: sandbox/SOC/2010/process/boost/process/details/posix_ops.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/process/boost/process/details/posix_ops.hpp 2010-05-11 01:26:56 EDT (Tue, 11 May 2010)
@@ -0,0 +1,495 @@
+//
+// Boost.Process
+// ~~~~~~~~~~~~~
+//
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008, 2009 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)
+//
+
+/**
+ * \file boost/process/detail/posix_ops.hpp
+ *
+ * Provides some convenience functions to start processes under POSIX
+ * operating systems.
+ */
+
+#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 {
+
+/**
+ * Converts the command line to an array of C strings.
+ *
+ * Converts the command line's list of arguments to the format expected
+ * by the \a argv parameter in the POSIX execve() system call.
+ *
+ * This operation is only available on POSIX systems.
+ *
+ * \return The first argument of the pair is an integer that indicates
+ * how many strings are stored in the second argument. The
+ * second argument is a NULL-terminated, dynamically allocated
+ * array of dynamically allocated strings holding the arguments
+ * to the executable. The caller is responsible of freeing them.
+ */
+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);
+}
+
+/**
+ * Converts an environment to a char** table as used by execve().
+ *
+ * Converts the environment's contents to the format used by the
+ * execve() system call. The returned char** array is allocated
+ * in dynamic memory; the caller must free it when not used any
+ * more. Each entry is also allocated in dynamic memory and is a
+ * NULL-terminated string of the form var=value; these must also be
+ * released by the caller.
+ *
+ * \return A dynamically allocated char** array that represents
+ * the environment's content. Each array entry is a
+ * NULL-terminated string of the form var=value.
+ */
+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;
+}
+
+/**
+ * Holds a mapping between native file descriptors and their corresponding
+ * pipes to set up communication between the parent and the %child process.
+ */
+typedef std::map<int, stream_info> info_map;
+
+/**
+ * Helper class to configure a POSIX %child.
+ *
+ * This helper class is used to hold all the attributes that configure a
+ * new POSIX %child process and to centralize all the actions needed to
+ * make them effective.
+ *
+ * All its fields are public for simplicity. It is only intended for
+ * internal use and it is heavily coupled with the Context
+ * implementations.
+ */
+struct posix_setup
+{
+ /**
+ * The work directory.
+ *
+ * This string specifies the directory in which the %child process
+ * starts execution. It cannot be empty.
+ */
+ std::string work_directory;
+
+ /**
+ * The chroot directory, if any.
+ *
+ * Specifies the directory in which the %child process is chrooted
+ * before execution. Empty if this feature is not desired.
+ */
+ std::string chroot;
+
+ /**
+ * The user credentials.
+ *
+ * UID that specifies the user credentials to use to run the %child
+ * process. Defaults to the current UID.
+ */
+ uid_t uid;
+
+ /**
+ * The effective user credentials.
+ *
+ * EUID that specifies the effective user credentials to use to run
+ * the %child process. Defaults to the current EUID.
+ */
+ uid_t euid;
+
+ /**
+ * The group credentials.
+ *
+ * GID that specifies the group credentials to use to run the %child
+ * process. Defaults to the current GID.
+ */
+ gid_t gid;
+
+ /**
+ * The effective group credentials.
+ *
+ * EGID that specifies the effective group credentials to use to run
+ * the %child process. Defaults to the current EGID.
+ */
+ gid_t egid;
+
+ /**
+ * Creates a new properties set.
+ *
+ * Creates a new object that has sensible default values for all the
+ * properties.
+ */
+ posix_setup()
+ : uid(::getuid()),
+ euid(::geteuid()),
+ gid(::getgid()),
+ egid(::getegid())
+ {
+ }
+
+ /**
+ * Sets up the execution environment.
+ *
+ * Modifies the current execution environment (that of the %child) so
+ * that the properties become effective.
+ *
+ * \throw boost::system::system_error If any error ocurred during
+ * environment configuration. The child process should abort
+ * execution if this happens because its start conditions
+ * cannot be met.
+ */
+ 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"));
+ }
+};
+
+/**
+ * Configures child process' input streams.
+ *
+ * Sets up the current process' input streams to behave according to the
+ * information in the \a info map. \a closeflags is modified to reflect
+ * those descriptors that should not be closed because they where modified
+ * by the function.
+ *
+ * Modifies the current execution environment, so this should only be run
+ * on the child process after the fork(2) has happened.
+ *
+ * \throw boost::system::system_error If any error occurs during the
+ * configuration.
+ */
+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;
+ }
+ }
+ }
+}
+
+/**
+ * Configures child process' output streams.
+ *
+ * Sets up the current process' output streams to behave according to the
+ * information in the \a info map. \a closeflags is modified to reflect
+ * those descriptors that should not be closed because they where
+ * modified by the function.
+ *
+ * Modifies the current execution environment, so this should only be run
+ * on the child process after the fork(2) has happened.
+ *
+ * \throw boost::system::system_error If any error occurs during the
+ * configuration.
+ */
+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();
+ }
+}
+
+/**
+ * Starts a new child process in a POSIX operating system.
+ *
+ * This helper functions is provided to simplify the Context's task when
+ * it comes to starting up a new process in a POSIX operating system.
+ * The function hides all the details of the fork/exec pair of calls as
+ * well as all the setup of communication pipes and execution environment.
+ *
+ * \param exe The executable to spawn the child process.
+ * \param args The arguments for the executable.
+ * \param env The environment variables that the new child process
+ * receives.
+ * \param infoin A map describing all input file descriptors to be
+ * redirected.
+ * \param infoout A map describing all output file descriptors to be
+ * redirected.
+ * \param setup A helper object used to configure the child's execution
+ * environment.
+ * \return The new process' PID. The caller is responsible of creating
+ * an appropriate Child representation for it.
+ */
+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);
+ std::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);
+ std::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;
+}
+
+/**
+ * Locates a communication pipe and returns one of its endpoints.
+ *
+ * Given a \a info map, and a file descriptor \a desc, searches for its
+ * communicataion pipe in the map and returns one of its endpoints as
+ * indicated by the \a out flag. This is intended to be used by a
+ * parent process after a fork(2) call.
+ *
+ * \pre If the info map contains the given descriptor, it is configured
+ * to use a pipe.
+ * \post The info map does not contain the given descriptor.
+ * \return If the file descriptor is found in the map, returns the pipe's
+ * read end if out is true; otherwise its write end. If the
+ * descriptor is not found returns an invalid file handle.
+ */
+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
Added: sandbox/SOC/2010/process/boost/process/details/stream_info.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/process/boost/process/details/stream_info.hpp 2010-05-11 01:26:56 EDT (Tue, 11 May 2010)
@@ -0,0 +1,176 @@
+//
+// Boost.Process
+// ~~~~~~~~~~~~~
+//
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008, 2009 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)
+//
+
+/**
+ * \file boost/process/detail/stream_info.hpp
+ *
+ * Provides the definition of the stream_info structure.
+ */
+
+#ifndef BOOST_PROCESS_DETAIL_STREAM_INFO_HPP
+#define BOOST_PROCESS_DETAIL_STREAM_INFO_HPP
+
+#include <boost/process/config.hpp>
+
+#if defined(BOOST_POSIX_API)
+# include <unistd.h>
+#elif defined(BOOST_WINDOWS_API)
+#else
+# error "Unsupported platform."
+#endif
+
+#include <boost/process/stream_behavior.hpp>
+#include <boost/process/detail/file_handle.hpp>
+#include <boost/process/detail/pipe.hpp>
+#include <boost/optional.hpp>
+#include <boost/assert.hpp>
+#include <string>
+
+namespace boost {
+namespace process {
+namespace detail {
+
+/**
+ * Configuration data for a file descriptor.
+ *
+ * This convenience structure provides a compact way to pass information
+ * around on how to configure a file descriptor. It is a lower-level
+ * representation of stream_behavior, as it can hold the same information
+ * but in a way that can be used by the underlying operating system.
+ */
+struct stream_info
+{
+ /**
+ * Supported stream types.
+ */
+ enum type
+ {
+ /**
+ * Matches stream_behavior::close.
+ */
+ close,
+
+ /**
+ * Matches stream_behavior::inherit.
+ */
+ inherit,
+
+ /**
+ * Matches stream_behavior::redirect_to_stdout and
+ * stream_behavior::posix_redirect.
+ */
+ redirect,
+
+ /**
+ * Matches stream_behavior::silence.
+ */
+ use_file,
+
+ /**
+ * TODO: Matches nothing yet ...
+ */
+ use_handle,
+
+ /**
+ * Matches stream_behavior::capture.
+ */
+ use_pipe
+ };
+
+ /**
+ * Stream type.
+ */
+ type type_;
+
+ /**
+ * Descriptor to use when stream type is set to \a redirect.
+ */
+ int desc_to_;
+
+ /**
+ * File to use when stream type is set to \a use_file.
+ */
+ std::string file_;
+
+ /**
+ * Handle to use when stream type is set to \a use_handle.
+ */
+ file_handle handle_;
+
+ /**
+ * Pipe to use when stream type is set to \a use_pipe.
+ */
+ boost::optional<pipe> pipe_;
+
+ /**
+ * Constructs a new stream_info object.
+ */
+ stream_info(const stream_behavior &sb, bool out)
+ {
+ switch (sb.type_)
+ {
+ case stream_behavior::close:
+ {
+ type_ = close;
+ break;
+ }
+ case stream_behavior::inherit:
+ {
+ type_ = inherit;
+ break;
+ }
+ case stream_behavior::redirect_to_stdout:
+ {
+ type_ = redirect;
+#if defined(BOOST_POSIX_API)
+ desc_to_ = STDOUT_FILENO;
+#elif defined(BOOST_WINDOWS_API)
+ desc_to_ = 1;
+#endif
+ break;
+ }
+#if defined(BOOST_POSIX_API)
+ case stream_behavior::posix_redirect:
+ {
+ type_ = redirect;
+ desc_to_ = sb.desc_to_;
+ break;
+ }
+#endif
+ case stream_behavior::silence:
+ {
+ type_ = use_file;
+#if defined(BOOST_POSIX_API)
+ file_ = out ? "/dev/null" : "/dev/zero";
+#elif defined(BOOST_WINDOWS_API)
+ file_ = "NUL";
+#endif
+ break;
+ }
+ case stream_behavior::capture:
+ {
+ type_ = use_pipe;
+ pipe_ = pipe();
+ break;
+ }
+ default:
+ {
+ BOOST_ASSERT(false);
+ }
+ }
+ }
+};
+
+}
+}
+}
+
+#endif
Added: sandbox/SOC/2010/process/boost/process/details/systembuf.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/process/boost/process/details/systembuf.hpp 2010-05-11 01:26:56 EDT (Tue, 11 May 2010)
@@ -0,0 +1,231 @@
+//
+// Boost.Process
+// ~~~~~~~~~~~~~
+//
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008, 2009 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)
+//
+
+/**
+ * \file boost/process/detail/systembuf.hpp
+ *
+ * Includes the declaration of the systembuf class. This file is for
+ * internal usage only and must not be included by the library user.
+ */
+
+#ifndef BOOST_PROCESS_DETAIL_SYSTEMBUF_HPP
+#define BOOST_PROCESS_DETAIL_SYSTEMBUF_HPP
+
+#include <boost/process/config.hpp>
+
+#if defined(BOOST_POSIX_API)
+# include <sys/types.h>
+# include <unistd.h>
+#elif defined(BOOST_WINDOWS_API)
+# include <windows.h>
+#else
+# error "Unsupported platform."
+#endif
+
+#include <boost/noncopyable.hpp>
+#include <boost/scoped_array.hpp>
+#include <boost/assert.hpp>
+#include <streambuf>
+#include <cstddef>
+
+namespace boost {
+namespace process {
+
+class postream;
+
+namespace detail {
+
+/**
+ * std::streambuf implementation for system file handles.
+ *
+ * systembuf provides a std::streambuf implementation for system file
+ * handles. Contrarywise to file_handle, this class does \b not take
+ * ownership of the native file handle; this should be taken care of
+ * somewhere else.
+ *
+ * This class follows the expected semantics of a std::streambuf object.
+ * However, it is not copyable to avoid introducing inconsistences with
+ * the on-disk file and the in-memory buffers.
+ */
+class systembuf : public std::streambuf, public boost::noncopyable
+{
+ friend class ::boost::process::postream;
+
+public:
+#if defined(BOOST_PROCESS_DOXYGEN)
+ /**
+ * Opaque name for the native handle type.
+ */
+ typedef NativeHandleType handle_type;
+#elif defined(BOOST_POSIX_API)
+ typedef int handle_type;
+#elif defined(BOOST_WINDOWS_API)
+ typedef HANDLE handle_type;
+#endif
+
+ /**
+ * Constructs a new systembuf for the given file handle.
+ *
+ * This constructor creates a new systembuf object that reads or
+ * writes data from/to the \a h native file handle. This handle
+ * is \b not owned by the created systembuf object; the code
+ * should take care of it externally.
+ *
+ * This class buffers input and output; the buffer size may be
+ * tuned through the \a bufsize parameter, which defaults to 8192
+ * bytes.
+ *
+ * \see pistream and postream
+ */
+ explicit systembuf(handle_type h, std::size_t bufsize = 8192)
+ : handle_(h),
+ bufsize_(bufsize),
+ read_buf_(new char[bufsize]),
+ write_buf_(new char[bufsize])
+ {
+#if defined(BOOST_POSIX_API)
+ BOOST_ASSERT(handle_ >= 0);
+#elif defined(BOOST_WINDOWS_API)
+ BOOST_ASSERT(handle_ != INVALID_HANDLE_VALUE);
+#endif
+ BOOST_ASSERT(bufsize_ > 0);
+
+ setp(write_buf_.get(), write_buf_.get() + bufsize_);
+ }
+
+protected:
+ /**
+ * Reads new data from the native file handle.
+ *
+ * This operation is called by input methods when there is no more
+ * data in the input buffer. The function fills the buffer with new
+ * data, if available.
+ *
+ * \pre All input positions are exhausted (gptr() >= egptr()).
+ * \post The input buffer has new data, if available.
+ * \returns traits_type::eof() if a read error occurrs or there are
+ * no more data to be read. Otherwise returns
+ * traits_type::to_int_type(*gptr()).
+ */
+ virtual int_type underflow()
+ {
+ BOOST_ASSERT(gptr() >= egptr());
+
+ bool ok;
+#if defined(BOOST_POSIX_API)
+ ssize_t cnt = ::read(handle_, read_buf_.get(), bufsize_);
+ ok = (cnt != -1 && cnt != 0);
+#elif defined(BOOST_WINDOWS_API)
+ DWORD cnt;
+ BOOL res = ::ReadFile(handle_, read_buf_.get(), bufsize_, &cnt, NULL);
+ ok = (res && cnt > 0);
+#endif
+
+ if (!ok)
+ return traits_type::eof();
+ else
+ {
+ setg(read_buf_.get(), read_buf_.get(), read_buf_.get() + cnt);
+ return traits_type::to_int_type(*gptr());
+ }
+ }
+
+ /**
+ * Makes room in the write buffer for additional data.
+ *
+ * This operation is called by output methods when there is no more
+ * space in the output buffer to hold a new element. The function
+ * first flushes the buffer's contents to disk and then clears it to
+ * leave room for more characters. The given \a c character is
+ * stored at the beginning of the new space.
+ *
+ * \pre All output positions are exhausted (pptr() >= epptr()).
+ * \post The output buffer has more space if no errors occurred
+ * during the write to disk.
+ * \post *(pptr() - 1) is \a c.
+ * \returns traits_type::eof() if a write error occurrs. Otherwise
+ * returns traits_type::not_eof(c).
+ */
+ virtual int_type overflow(int c)
+ {
+ BOOST_ASSERT(pptr() >= epptr());
+
+ if (sync() == -1)
+ return traits_type::eof();
+
+ if (!traits_type::eq_int_type(c, traits_type::eof()))
+ {
+ traits_type::assign(*pptr(), c);
+ pbump(1);
+ }
+
+ return traits_type::not_eof(c);
+ }
+
+ /**
+ * Flushes the output buffer to disk.
+ *
+ * Synchronizes the systembuf buffers with the contents of the file
+ * associated to this object through the native file handle. The
+ * output buffer is flushed to disk and cleared to leave new room
+ * for more data.
+ *
+ * \returns 0 on success, -1 if an error occurred.
+ */
+ virtual int sync()
+ {
+#if defined(BOOST_POSIX_API)
+ ssize_t cnt = pptr() - pbase();
+#elif defined(BOOST_WINDOWS_API)
+ long cnt = pptr() - pbase();
+#endif
+
+ bool ok;
+#if defined(BOOST_POSIX_API)
+ ok = ::write(handle_, pbase(), cnt) == cnt;
+#elif defined(BOOST_WINDOWS_API)
+ DWORD rcnt;
+ BOOL res = ::WriteFile(handle_, pbase(), cnt, &rcnt, NULL);
+ ok = (res && static_cast<long>(rcnt) == cnt);
+#endif
+
+ if (ok)
+ pbump(-cnt);
+ return ok ? 0 : -1;
+ }
+
+private:
+ /**
+ * Native file handle used by the systembuf object.
+ */
+ handle_type handle_;
+
+ /**
+ * Internal buffer size used during read and write operations.
+ */
+ std::size_t bufsize_;
+
+ /**
+ * Internal buffer used during read operations.
+ */
+ boost::scoped_array<char> read_buf_;
+
+ /**
+ * Internal buffer used during write operations.
+ */
+ boost::scoped_array<char> write_buf_;
+};
+
+}
+}
+}
+
+#endif
Added: sandbox/SOC/2010/process/boost/process/details/win32_ops.hpp
==============================================================================
--- (empty file)
+++ sandbox/SOC/2010/process/boost/process/details/win32_ops.hpp 2010-05-11 01:26:56 EDT (Tue, 11 May 2010)
@@ -0,0 +1,355 @@
+//
+// Boost.Process
+// ~~~~~~~~~~~~~
+//
+// Copyright (c) 2006, 2007 Julio M. Merino Vidal
+// Copyright (c) 2008, 2009 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)
+//
+
+/**
+ * \file boost/process/detail/win32_ops.hpp
+ *
+ * Provides some convenience functions to start processes under
+ * Windows-compatible operating systems.
+ */
+
+#ifndef BOOST_PROCESS_DETAIL_WIN32_OPS_HPP
+#define BOOST_PROCESS_DETAIL_WIN32_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_ptr.hpp>
+#include <boost/shared_array.hpp>
+#include <boost/scoped_array.hpp>
+#include <boost/assert.hpp>
+#include <boost/system/system_error.hpp>
+#include <boost/throw_exception.hpp>
+#include <vector>
+#include <string>
+#include <cstddef>
+#include <string.h>
+#include <windows.h>
+
+namespace boost {
+namespace process {
+namespace detail {
+
+/**
+ * Converts the command line to a plain string. Converts the command line's
+ * list of arguments to the format expected by the \a lpCommandLine parameter
+ * in the CreateProcess() system call.
+ *
+ * This operation is only available on Windows systems.
+ *
+ * \return A dynamically allocated string holding the command line
+ * to be passed to the executable. It is returned in a
+ * shared_array object to ensure its release at some point.
+ */
+template <class Arguments>
+inline boost::shared_array<char> collection_to_win32_cmdline(const Arguments &args)
+{
+ typedef std::vector<std::string> arguments_t;
+ arguments_t args2;
+ typename Arguments::size_type i = 0;
+ std::size_t size = 0;
+ for (typename Arguments::const_iterator it = args.begin(); it != args.end(); ++it)
+ {
+ std::string arg = *it;
+
+ std::string::size_type pos = 0;
+ while ( (pos = arg.find('"', pos)) != std::string::npos)
+ {
+ arg.replace(pos, 1, "\\\"");
+ pos += 2;
+ }
+
+ if (arg.find(' ') != std::string::npos)
+ arg = '\"' + arg + '\"';
+
+ if (i++ != args.size() - 1)
+ arg += ' ';
+
+ args2.push_back(arg);
+ size += arg.size() + 1;
+ }
+
+ boost::shared_array<char> cmdline(new char[size]);
+ cmdline.get()[0] = '\0';
+ for (arguments_t::size_type i = 0; i < args.size(); ++i)
+#if defined(__CYGWIN__) || defined(_SCL_SECURE_NO_DEPRECATE)
+ ::strncat(cmdline.get(), args2[i].c_str(), args2[i].size());
+#else
+ ::strcat_s(cmdline.get(), size, args2[i].c_str());
+#endif
+
+ return cmdline;
+}
+
+/**
+ * Converts an environment to a string used by CreateProcess().
+ *
+ * Converts the environment's contents to the format used by the
+ * CreateProcess() system call. The returned char* string is
+ * allocated in dynamic memory; the caller must free it when not
+ * used any more. This is enforced by the use of a shared pointer.
+ *
+ * \return A dynamically allocated char* string that represents
+ * the environment's content. This string is of the form
+ * var1=value1\\0var2=value2\\0\\0.
+ */
+inline boost::shared_array<char> environment_to_win32_strings(const environment &env)
+{
+ boost::shared_array<char> envp;
+
+ if (env.empty())
+ {
+ envp.reset(new char[2]);
+ ::ZeroMemory(envp.get(), 2);
+ }
+ else
+ {
+ std::string s;
+ for (environment::const_iterator it = env.begin(); it != env.end(); ++it)
+ {
+ s += it->first + "=" + it->second;
+ s.push_back(0);
+ }
+
+ envp.reset(new char[s.size() + 1]);
+#if defined(__CYGWIN__) || defined(_SCL_SECURE_NO_DEPRECATE)
+ ::memcpy(envp.get(), s.c_str(), s.size() + 1);
+#else
+ ::memcpy_s(envp.get(), s.size() + 1, s.c_str(), s.size() + 1);
+#endif
+ }
+
+ return envp;
+}
+
+/**
+ * Helper class to configure a Win32 %child.
+ *
+ * This helper class is used to hold all the attributes that configure a
+ * new Win32 %child process.
+ *
+ * All its fields are public for simplicity. It is only intended for
+ * internal use and it is heavily coupled with the Context
+ * implementations.
+ */
+struct win32_setup
+{
+ /**
+ * The work directory.
+ *
+ * This string specifies the directory in which the %child process
+ * starts execution. It cannot be empty.
+ */
+ std::string work_directory;
+
+ /**
+ * The process startup properties.
+ *
+ * This Win32-specific object holds a list of properties that describe
+ * how the new process should be started. The \a STARTF_USESTDHANDLES
+ * flag should not be set in it because it is automatically configured
+ * by win32_start().
+ */
+ STARTUPINFOA *startupinfo;
+};
+
+/**
+ * Starts a new child process in a Win32 operating system.
+ *
+ * This helper functions is provided to simplify the Context's task when
+ * it comes to starting up a new process in a Win32 operating system.
+ *
+ * \param exe The executable to spawn the child process.
+ * \param args The arguments for the executable.
+ * \param env The environment variables that the new child process
+ * receives.
+ * \param infoin Information that describes stdin's behavior.
+ * \param infoout Information that describes stdout's behavior.
+ * \param infoerr Information that describes stderr's behavior.
+ * \param setup A helper object holding extra child information.
+ * \return The new process' information as returned by the CreateProcess()
+ * system call. The caller is responsible of creating an
+ * appropriate Child representation for it.
+ * \pre \a setup.startupinfo_ cannot have the \a STARTF_USESTDHANDLES set
+ * in the \a dwFlags field.
+ */
+template <class Executable, class Arguments>
+inline PROCESS_INFORMATION win32_start(const Executable &exe, const Arguments &args, const environment &env, stream_info &infoin, stream_info &infoout, stream_info &infoerr, const win32_setup &setup)
+{
+ file_handle chin, chout, cherr;
+
+ BOOST_ASSERT(setup.startupinfo->cb >= sizeof(STARTUPINFOA));
+ BOOST_ASSERT(!(setup.startupinfo->dwFlags & STARTF_USESTDHANDLES));
+
+ boost::scoped_ptr<STARTUPINFOA> si(new STARTUPINFOA);
+ ::CopyMemory(si.get(), setup.startupinfo, sizeof(*setup.startupinfo));
+ si->dwFlags |= STARTF_USESTDHANDLES;
+
+ switch (infoin.type_)
+ {
+ case stream_info::close:
+ {
+ break;
+ }
+ case stream_info::inherit:
+ {
+ chin = file_handle::win32_std(STD_INPUT_HANDLE, true);
+ break;
+ }
+ case stream_info::use_file:
+ {
+ HANDLE h = ::CreateFileA(infoin.file_.c_str(), GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+ 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::win32_start: CreateFile failed"));
+ chin = file_handle(h);
+ break;
+ }
+ case stream_info::use_handle:
+ {
+ chin = infoin.handle_;
+ chin.win32_set_inheritable(true);
+ break;
+ }
+ case stream_info::use_pipe:
+ {
+ infoin.pipe_->rend().win32_set_inheritable(true);
+ chin = infoin.pipe_->rend();
+ break;
+ }
+ default:
+ {
+ BOOST_ASSERT(false);
+ break;
+ }
+ }
+
+ si->hStdInput = chin.valid() ? chin.get() : INVALID_HANDLE_VALUE;
+
+ switch (infoout.type_)
+ {
+ case stream_info::close:
+ {
+ break;
+ }
+ case stream_info::inherit:
+ {
+ chout = file_handle::win32_std(STD_OUTPUT_HANDLE, true);
+ break;
+ }
+ case stream_info::use_file:
+ {
+ HANDLE h = ::CreateFileA(infoout.file_.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+ 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::win32_start: CreateFile failed"));
+ chout = file_handle(h);
+ break;
+ }
+ case stream_info::use_handle:
+ {
+ chout = infoout.handle_;
+ chout.win32_set_inheritable(true);
+ break;
+ }
+ case stream_info::use_pipe:
+ {
+ infoout.pipe_->wend().win32_set_inheritable(true);
+ chout = infoout.pipe_->wend();
+ break;
+ }
+ default:
+ {
+ BOOST_ASSERT(false);
+ break;
+ }
+ }
+
+ si->hStdOutput = chout.valid() ? chout.get() : INVALID_HANDLE_VALUE;
+
+ switch (infoerr.type_)
+ {
+ case stream_info::close:
+ {
+ break;
+ }
+ case stream_info::inherit:
+ {
+ cherr = file_handle::win32_std(STD_ERROR_HANDLE, true);
+ break;
+ }
+ case stream_info::redirect:
+ {
+ BOOST_ASSERT(infoerr.desc_to_ == 1);
+ BOOST_ASSERT(chout.valid());
+ cherr = file_handle::win32_dup(chout.get(), true);
+ break;
+ }
+ case stream_info::use_file:
+ {
+ HANDLE h = ::CreateFileA(infoerr.file_.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+ 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::win32_start: CreateFile failed"));
+ cherr = file_handle(h);
+ break;
+ }
+ case stream_info::use_handle:
+ {
+ cherr = infoerr.handle_;
+ cherr.win32_set_inheritable(true);
+ break;
+ }
+ case stream_info::use_pipe:
+ {
+ infoerr.pipe_->wend().win32_set_inheritable(true);
+ cherr = infoerr.pipe_->wend();
+ break;
+ }
+ default:
+ {
+ BOOST_ASSERT(false);
+ break;
+ }
+ }
+
+ si->hStdError = cherr.valid() ? cherr.get() : INVALID_HANDLE_VALUE;
+
+ PROCESS_INFORMATION pi;
+ ::ZeroMemory(&pi, sizeof(pi));
+
+ boost::shared_array<char> cmdline = collection_to_win32_cmdline(args);
+
+ boost::scoped_array<char> executable(new char[exe.size() + 1]);
+#if defined(__CYGWIN__) || defined(_SCL_SECURE_NO_DEPRECATE)
+ ::strcpy(executable.get(), exe.c_str());
+#else
+ ::strcpy_s(executable.get(), exe.size() + 1, exe.c_str());
+#endif
+
+ boost::scoped_array<char> workdir(new char[setup.work_directory.size() + 1]);
+#if defined(__CYGWIN__) || defined(_SCL_SECURE_NO_DEPRECATE)
+ ::strcpy(workdir.get(), setup.work_directory.c_str());
+#else
+ ::strcpy_s(workdir.get(), setup.work_directory.size() + 1, setup.work_directory.c_str());
+#endif
+
+ boost::shared_array<char> envstrs = environment_to_win32_strings(env);
+
+ if (!::CreateProcessA(executable.get(), cmdline.get(), NULL, NULL, TRUE, 0, envstrs.get(), workdir.get(), si.get(), &pi))
+ boost::throw_exception(boost::system::system_error(boost::system::error_code(::GetLastError(), boost::system::get_system_category()), "boost::process::detail::win32_start: CreateProcess failed"));
+
+ return pi;
+}
+
+}
+}
+}
+
+#endif