diff options
Diffstat (limited to 'plugins/New_GPG/src/include')
48 files changed, 3776 insertions, 0 deletions
diff --git a/plugins/New_GPG/src/include/boost/process.hpp b/plugins/New_GPG/src/include/boost/process.hpp new file mode 100644 index 0000000000..2271e9b49e --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process.hpp @@ -0,0 +1,22 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011 Jeff Flinn, Boris Schaeling +// Copyright (c) 2012 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.hpp + * + * Convenience header which includes all public Boost.Process header files. + */ + +#ifndef BOOST_PROCESS_HPP +#define BOOST_PROCESS_HPP + +#include <boost/process/all.hpp> + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/all.hpp b/plugins/New_GPG/src/include/boost/process/all.hpp new file mode 100644 index 0000000000..234dd05d4c --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/all.hpp @@ -0,0 +1,30 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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/all.hpp + * + * Convenience header which includes all public Boost.Process header files. + */ + +#ifndef BOOST_PROCESS_ALL_HPP +#define BOOST_PROCESS_ALL_HPP + +#include <boost/process/child.hpp> +#include <boost/process/create_pipe.hpp> +#include <boost/process/execute.hpp> +#include <boost/process/executor.hpp> +#include <boost/process/initializers.hpp> +#include <boost/process/pipe.hpp> +#include <boost/process/search_path.hpp> +#include <boost/process/shell_path.hpp> +#include <boost/process/terminate.hpp> +#include <boost/process/wait_for_exit.hpp> + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/child.hpp b/plugins/New_GPG/src/include/boost/process/child.hpp new file mode 100644 index 0000000000..ec129fc936 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/child.hpp @@ -0,0 +1,74 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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/child.hpp + * + * Defines a child process class. + */ + +#ifndef BOOST_PROCESS_CHILD_HPP +#define BOOST_PROCESS_CHILD_HPP + +#include <boost/process/config.hpp> + +#include BOOST_PROCESS_PLATFORM_PROMOTE_PATH(child) +BOOST_PROCESS_PLATFORM_PROMOTE_NAMESPACE(child) + +#if defined(BOOST_PROCESS_DOXYGEN) +namespace boost { namespace process { + +/** + * Represents a child process. + * + * On Windows child is movable but non-copyable. The destructor + * automatically closes handles to the child process. + */ +struct child +{ + /** + * Process information. + * + * \remark <em>Windows only.</em> + */ + PROCESS_INFORMATION proc_info; + + /** + * Constructor. + * + * \remark <em>Windows only.<em/> + */ + explicit child(const PROCESS_INFORMATION &pi) : proc_info(pi) {} + + /** + * Returns the process handle. + * + * \remark <em>Windows only.</em> + */ + HANDLE process_handle() const { return proc_info.hProcess; } + + /** + * Process identifier. + * + * \remark <em>POSIX only.</em> + */ + pid_t pid; + + /** + * Constructor. + * + * \remark <em>POSIX only.</em> + */ + explicit child(pid_t p) : pid(p) {} +}; + +}} +#endif + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/config.hpp b/plugins/New_GPG/src/include/boost/process/config.hpp new file mode 100644 index 0000000000..7aae4d3ca4 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/config.hpp @@ -0,0 +1,82 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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/config.hpp + * + * Defines various macros. + */ + +#ifndef BOOST_PROCESS_CONFIG_HPP +#define BOOST_PROCESS_CONFIG_HPP + +#include <boost/config.hpp> +#include <boost/system/config.hpp> +#include <boost/system/error_code.hpp> +#include <boost/system/system_error.hpp> + +#if defined(BOOST_POSIX_API) +# include <errno.h> +# define BOOST_PROCESS_LAST_ERROR errno +# define BOOST_PROCESS_PLATFORM posix +#elif defined(BOOST_WINDOWS_API) +# include <Windows.h> +# define BOOST_PROCESS_LAST_ERROR GetLastError() +# define BOOST_PROCESS_PLATFORM windows +#endif + +/** \cond */ +#define BOOST_PROCESS_PLATFORM_PROMOTE_PATH(COMPONENT) \ + <boost/process/BOOST_PROCESS_PLATFORM/COMPONENT.hpp> +#define BOOST_PROCESS_PLATFORM_PROMOTE_NAMESPACE(COMPONENT) \ + namespace boost { namespace process { using BOOST_PROCESS_PLATFORM::COMPONENT; }} +#define BOOST_PROCESS_PLATFORM_PROMOTE_INITIALIZERS_NAMESPACE \ + namespace boost { namespace process { namespace initializers { \ + using namespace boost::process::BOOST_PROCESS_PLATFORM::initializers; }}} +/** \endcond */ + +#if defined(BOOST_PROCESS_DOXYGEN) +/** + * \def BOOST_POSIX_API + * + * This macro is defined on POSIX. + */ +#define BOOST_POSIX_API +/** + * \def BOOST_WINDOWS_API + * + * This macro is defined on Windows. + */ +#define BOOST_WINDOWS_API +#endif + +/** + * \def BOOST_PROCESS_THROW(EX) + * + * Defines how exceptions are thrown. Set this macro for example + * to \c BOOST_THROW_EXCEPTION if you like to use Boost.Exception. + */ +#define BOOST_PROCESS_THROW(EX) throw EX + +/** \cond */ +#define BOOST_PROCESS_SOURCE_LOCATION \ + "in file '" __FILE__ "', line " BOOST_STRINGIZE(__LINE__) ": " + +#define BOOST_PROCESS_THROW_LAST_SYSTEM_ERROR(what) \ + BOOST_PROCESS_THROW(boost::system::system_error( \ + boost::system::error_code(BOOST_PROCESS_LAST_ERROR, \ + boost::system::system_category()), \ + BOOST_PROCESS_SOURCE_LOCATION what)) + +#define BOOST_PROCESS_RETURN_LAST_SYSTEM_ERROR(ec) \ + ec = boost::system::error_code(BOOST_PROCESS_LAST_ERROR, \ + boost::system::system_category()) +/** \endcond */ + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/create_pipe.hpp b/plugins/New_GPG/src/include/boost/process/create_pipe.hpp new file mode 100644 index 0000000000..6c34ecf44b --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/create_pipe.hpp @@ -0,0 +1,48 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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/create_pipe.hpp + * + * Defines a function to create a pipe. + */ + +#ifndef BOOST_PROCESS_CREATE_PIPE_HPP +#define BOOST_PROCESS_CREATE_PIPE_HPP + +#include <boost/process/config.hpp> + +#include BOOST_PROCESS_PLATFORM_PROMOTE_PATH(create_pipe) +BOOST_PROCESS_PLATFORM_PROMOTE_NAMESPACE(create_pipe) + +#if defined(BOOST_PROCESS_DOXYGEN) +namespace boost { namespace process { + +/** + * Creates an anonymous pipe. + * + * \note On Windows anonymous pipes don't support + * asynchronous I/O. + * + * \throws boost::system::system_error in case of an error + */ +pipe create_pipe(); + +/** + * Creates an anonymous pipe. + * + * \note On Windows anonymous pipes don't support + * asynchronous I/O. + */ +pipe create_pipe(boost::system::error_code &ec); + +}} +#endif + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/execute.hpp b/plugins/New_GPG/src/include/boost/process/execute.hpp new file mode 100644 index 0000000000..608831171e --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/execute.hpp @@ -0,0 +1,38 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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/execute.hpp + * + * Defines a function to execute a program. + */ + +#ifndef BOOST_PROCESS_EXECUTE_HPP +#define BOOST_PROCESS_EXECUTE_HPP + +#include <boost/process/config.hpp> + +#include BOOST_PROCESS_PLATFORM_PROMOTE_PATH(execute) +BOOST_PROCESS_PLATFORM_PROMOTE_NAMESPACE(execute) + +#if defined(BOOST_PROCESS_DOXYGEN) +namespace boost { namespace process { + +/** + * Starts a program. + * + * \tparam initializers define what and how the program is started + */ +template <class Initializer, class... Initializers> +child execute(const Initializer &initializer, const Initializers... &initializers); + +}} +#endif + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/executor.hpp b/plugins/New_GPG/src/include/boost/process/executor.hpp new file mode 100644 index 0000000000..905d7f84cc --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/executor.hpp @@ -0,0 +1,176 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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/executor.hpp + * + * Defines an executor which can create child processes. + */ + +#ifndef BOOST_PROCESS_EXECUTOR_HPP +#define BOOST_PROCESS_EXECUTOR_HPP + +#include <boost/process/config.hpp> + +#include BOOST_PROCESS_PLATFORM_PROMOTE_PATH(executor) +BOOST_PROCESS_PLATFORM_PROMOTE_NAMESPACE(executor) + +#if defined(BOOST_PROCESS_DOXYGEN) +namespace boost { namespace process { + +/** + * Starts a program. + * + * boost::process::executor is a functor which calls the system functions + * to start a program. Before system functions are called it iterates + * over initializers and calls a member function passing a reference + * to itself as a parameter. Initializers get then a chance to setup + * the executor. If system functions fail boost::process::executor again + * iterates over initializers and calls another member function passing a + * reference to itself as a parameter. This gives initializers a + * chance to handle the error. + * + * \note Library users shouldn't need to use boost::process::executor. + * It is recommended to call boost::process::execute which uses + * boost::pocess::executor internally. + */ +struct executor +{ + /** + * Default constructor. + */ + executor(); + + /** + * Starts a program. + * + * \tparam initializers define what and how the program is started + */ + template <class Initializer, class... Initializers> + child operator()(const Initializer &initializer, const Initializers... &initializers); + + ///\defgroup WindowsOnly Windows only. + ///@{ + + /** + * Program name. + * + * \remark <em>Windows only.</em> + */ + LPCTSTR exe; + + /** + * Command line. + * + * \remark <em>Windows only.</em> + */ + LPTSTR cmd_line; + + /** + * Process attributes. + * + * \remark <em>Windows only.</em> + */ + LPSECURITY_ATTRIBUTES proc_attrs; + + /** + * Thread attributes. + * + * \remark <em>Windows only.</em> + */ + LPSECURITY_ATTRIBUTES thread_attrs; + + /** + * Flag to inherit handles. + * + * \remark <em>Windows only.</em> + */ + BOOL inherit_handles; + + /** + * Creation flags. + * + * \remark <em>Windows only.</em> + */ + DWORD creation_flags; + + /** + * Environment variables. + * + * \remark <em>Windows only.</em> + */ + LPVOID env; + + /** + * Work directory. + * + * \remark <em>Windows only.</em> + */ + LPCTSTR work_dir; + + /** + * Startupinfo structure. + * + * \remark <em>Windows only.</em> + */ + STARTUPINFO startup_info; + + /** + * Startupinfoex structure. + * + * If this member variable is available, \c startup_info is a reference + * to \c StartupInfo in STARTUPINFOEX. + * + * \remark <em>Windows Vista, Windows Server 2008 or better.</em> + */ + STARTUPINFOEX startup_info_ex; + + /** + * Process information. + * + * \c proc_info contains the result after a child process + * could be started successfully. + * + * \remark <em>Windows only.</em> + */ + PROCESS_INFORMATION proc_info; + + ///@} + + ///\defgroup POSIXOnly POSIX only. + ///@{ + + /** + * Program name. + * + * \remark <em>POSIX only.</em> + */ + const char *exe; + + /** + * Command line arguments. + * + * \remark <em>POSIX only.</em> + */ + char **cmd_line; + + /** + * Environment variables. + * + * \remark <em>POSIX only.</em> + */ + char **env; + + ///@} +}; + +}} +#endif + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/initializers.hpp b/plugins/New_GPG/src/include/boost/process/initializers.hpp new file mode 100644 index 0000000000..c7175d1425 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/initializers.hpp @@ -0,0 +1,497 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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/initializers.hpp + * + * Defines initializers. + */ + +#ifndef BOOST_PROCESS_INITIALIZERS_HPP +#define BOOST_PROCESS_INITIALIZERS_HPP + +#include <boost/process/config.hpp> + +#include BOOST_PROCESS_PLATFORM_PROMOTE_PATH(initializers) +BOOST_PROCESS_PLATFORM_PROMOTE_INITIALIZERS_NAMESPACE + +#if defined(BOOST_PROCESS_DOXYGEN) +namespace boost { namespace process { namespace initializers { + +/** + * Binds the standard error stream. + */ +class bind_stderr : public initializer_base +{ +public: + /** + * Constructor. + */ + explicit bind_stderr(const boost::iostreams::file_descriptor_sink &sink); +}; + +/** + * Binds the standard input stream. + */ +class bind_stdin : public initializer_base +{ +public: + /** + * Constructor. + */ + explicit bind_stdin(const boost::iostreams::file_descriptor_source &source); +}; + +/** + * Binds the standard output stream. + */ +class bind_stdout : public initializer_base +{ +public: + /** + * Constructor. + */ + explicit bind_stdout(const boost::iostreams::file_descriptor_sink &sink); +}; + +/** + * Binds a file descriptor. + * + * \remark <em>POSIX only.</em> + */ +class bind_fd : public initializer_base +{ +public: + /** + * Constructor. + */ + bind_fd(int id, const boost::iostreams::file_descriptor &fd); +}; + +/** + * Closes a file descriptor. + * + * \remark <em>POSIX only.</em> + */ +class close_fd : public initializer_base +{ + /** + * Constructor. + */ + explicit close_fd(int fd); +}; + +/** + * Closes file descriptors. + * + * \remark <em>POSIX only.</em> + */ +class close_fds : public initializer_base +{ +public: + /** + * Constructor. + * + * \c range_type must be an <tt>int</tt>-range. + */ + explicit close_fds(const range_type &fds); +}; + +/** + * Closes all file descriptors a predicate returns + * true for. + * + * This initializer doesn't close file descriptors + * immediately. Instead it sets the \c FD_CLOEXEC + * flag. File descriptors are closed when \c execve + * is called and the call succeeds. + * + * \remark <em>POSIX only.</em> + */ +class close_fds_if : public initializer_base +{ +public: + /** + * Constructor. + * + * \c predicate_type must be a function or functor with + * this signature: <tt>bool(int)</tt> + */ + explicit close_fds_if(const predicate_type &pred); +}; + +/** + * Closes the standard error stream. + */ +class close_stderr : public initializer_base +{ + /** + * Constructor. + */ + close_stderr(); +}; + +/** + * Closes the standard input stream. + */ +class close_stdin : public initializer_base +{ + /** + * Constructor. + */ + close_stdin(); +}; + +/** + * Closes the standard output stream. + */ +class close_stdout : public initializer_base +{ + /** + * Constructor. + */ + close_stdout(); +}; + +/** + * Hides the console. + */ +class hide_console : public initializer_base +{ +public: + /** + * Constructor. + */ + hide_console(); +}; + +/** + * Inherits environment variables. + */ +class inherit_env : public initializer_base +{ +public: + /** + * Constructor. + */ + inherit_env(); +}; + +/** + * Notifies an I/O service object of fork-related events. + * + * \see boost::asio::io_service::notify_fork + * + * \remark <em>POSIX only.</em> + */ +class notify_io_service : public initializer_base +{ +public: + /** + * Constructor. + */ + explicit notify_io_service(boost::asio::io_service &io_service); +}; + +/** + * Generic initializer to execute any code if \c execve + * failed. + * + * \remark <em>POSIX only.</em> + */ +class on_exec_error : public initializer_base +{ +public: + /** + * Constructor. + * + * \c handler_type must be a function or functor with + * this signature: <tt>void(executor&)</tt> + */ + explicit on_exec_error(handler_type handler); +}; + +/** + * Generic initializer to execute any code before \c execve + * is called. + * + * \remark <em>POSIX only.</em> + */ +class on_exec_setup : public initializer_base +{ +public: + /** + * Constructor. + * + * \c handler_type must be a function or functor with + * this signature: <tt>void(executor&)</tt> + */ + explicit on_exec_setup(handler_type handler); +}; + +/** + * Generic initializer to execute any code if \c fork + * failed. + * + * \remark <em>POSIX only.</em> + */ +class on_fork_error : public initializer_base +{ +public: + /** + * Constructor. + * + * \c handler_type must be a function or functor with + * this signature: <tt>void(executor&)</tt> + */ + explicit on_fork_error(handler_type handler); +}; + +/** + * Generic initializer to execute any code before \c fork + * is called. + * + * \remark <em>POSIX only.</em> + */ +class on_fork_setup : public initializer_base +{ +public: + /** + * Constructor. + * + * \c handler_type must be a function or functor with + * this signature: <tt>void(executor&)</tt> + */ + explicit on_fork_setup(handler_type handler); +}; + +/** + * Generic initializer to execute any code in the parent + * process after \c fork has been called successfully. + * + * \remark <em>POSIX only.</em> + */ +class on_fork_success : public initializer_base +{ +public: + /** + * Constructor. + * + * \c handler_type must be a function or functor with + * this signature: <tt>void(executor&)</tt> + */ + explicit on_fork_success(handler_type handler); +}; + +/** + * Generic initializer to execute any code if \c CreateProcess + * failed. + * + * \remark <em>Windows only.</em> + */ +class on_CreateProcess_error : public initializer_base +{ +public: + /** + * Constructor. + * + * \c handler_type must be a function or functor with + * this signature: <tt>void(executor&)</tt> + */ + explicit on_CreateProcess_error(handler_type handler); +}; + +/** + * Generic initializer to execute any code before \c CreateProcess + * is called. + * + * \remark <em>Windows only.</em> + */ +class on_CreateProcess_setup : public initializer_base +{ +public: + /** + * Constructor. + * + * \c handler_type must be a function or functor with + * this signature: <tt>void(executor&)</tt> + */ + explicit on_CreateProcess_setup(handler_type handler); +}; + +/** + * Generic initializer to execute any code after \c CreateProcess + * has been called successfully. + * + * \remark <em>Windows only.</em> + */ +class on_CreateProcess_success : public initializer_base +{ +public: + /** + * Constructor. + * + * \c handler_type must be a function or functor with + * this signature: <tt>void(executor&)</tt> + */ + explicit on_CreateProcess_success(handler_type handler); +}; + +/** + * Specifies the executable to start. + * + * This initializer must always be used. The only exception is + * if you use \c set_args or a generic initializer which + * specifies the executable. + */ +class run_exe : public initializer_base +{ +public: + /** + * Constructor. + * + * On Windows \c string_type must be <tt>const char*</tt>, + * <tt>std::string</tt> or <tt>boost::filesystem::path</tt>. + * If Unicode is used, \c string_type must be + * <tt>const wchar_t*</tt>, <tt>std::wstring</tt> or + * <tt>boost::filesystem::path</tt>. + * + * On POSIX \c string_type must be <tt>const char*</tt>, + * <tt>std::string</tt> or <tt>boost::filesystem::path</tt>. + */ + explicit run_exe(const string_type &s); +}; + +/** + * Sets the command line arguments. + * + * The first argument specifies the executable to start unless + * \c run_exe is used. + * + * Use \c set_cmd_line if you don't want to pass a collection of + * command line arguments but set the command line as one string. + */ +class set_args : public initializer_base +{ +public: + /** + * Constructor. + * + * On Windows \c range_type must be a <tt>std::string</tt>-range. + * If Unicode is used, \c range_type must be a + * <tt>std::wstring</tt>-range. + * + * On POSIX \c range_type must be a <tt>std::string</tt>-range. + */ + explicit set_args(const range_type &r); +}; + +/** + * Sets the command line. + * + * Use \c set_args if you don't want to set the command line as + * one string but pass a collection of command line arguments. + */ +class set_cmd_line : public initializer_base +{ +public: + /** + * Constructor. + * + * On Windows \c string_type must be <tt>const char*</tt>, + * <tt>std::string</tt> or <tt>boost::filesystem::path</tt>. + * If Unicode is used, \c string_type must be + * <tt>const wchar_t*</tt>, <tt>std::wstring</tt> or + * <tt>boost::filesystem::path</tt>. + * + * On POSIX \c string_type must be <tt>const char*</tt>, + * <tt>std::string</tt> or <tt>boost::filesystem::path</tt>. + */ + explicit set_cmd_line(const string_type &s); +}; + +/** + * Sets the environment. + */ +class set_env : public initializer_base +{ +public: + /** + * Constructor. + * + * On Windows \c range_type must be a <tt>std::string</tt>-range. + * If Unicode is used, \c range_type must be a + * <tt>std::wstring</tt>-range. + * + * On POSIX \c range_type must be a <tt>std::string</tt>-range. + */ + explicit set_env(const range_type &r); +}; + +/** + * Sets an error if a child process can't be created. + */ +class set_on_error : public initializer_base +{ +public: + /** + * Constructor. + */ + explicit set_on_error(boost::system::error_code &ec); +}; + +/** + * Sets the flag \c wShowWindow in \c STARTUPINFO. + * + * \remark <em>Windows only.</em> + */ +class show_window : public initializer_base +{ +public: + /** + * Constructor. + */ + explicit show_window(WORD flags); +}; + +/** + * Sets the work directory. + */ +class start_in_dir : public initializer_base +{ +public: + /** + * Constructor. + * + * On Windows \c string_type must be <tt>const char*</tt>, + * <tt>std::string</tt> or <tt>boost::filesystem::path</tt>. + * If Unicode is used, \c string_type must be + * <tt>const wchar_t*</tt>, <tt>std::wstring</tt> or + * <tt>boost::filesystem::path</tt>. + * + * On POSIX \c string_type must be <tt>const char*</tt>, + * <tt>std::string</tt> or <tt>boost::filesystem::path</tt>. + */ + explicit start_in_dir(const string_type &s); +}; + +/** + * Throws an error if a child process can't be created. + * + * The type of the error thrown is \c boost::system::system_error. + */ +class throw_on_error : public initializer_base +{ +public: +}; + +}}} +#endif + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/mitigate.hpp b/plugins/New_GPG/src/include/boost/process/mitigate.hpp new file mode 100644 index 0000000000..6838984aa1 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/mitigate.hpp @@ -0,0 +1,104 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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/mitigate.hpp + * + * Helpers to mitigate platform differences. + */ + +#ifndef BOOST_PROCESS_MITIGATE_HPP +#define BOOST_PROCESS_MITIGATE_HPP + +#include <boost/asio.hpp> +#if defined(BOOST_POSIX_API) +# include <sys/wait.h> +#endif + +namespace boost { namespace process { + +#if defined(BOOST_WINDOWS_API) +typedef boost::asio::windows::stream_handle pipe_end; +#elif defined(BOOST_POSIX_API) +typedef boost::asio::posix::stream_descriptor pipe_end; +#endif + +inline const char *zero_device() +{ +#if defined(BOOST_WINDOWS_API) + return "NUL"; +#elif defined(BOOST_POSIX_API) + return "/dev/zero"; +#endif +} + +inline const char *null_device() +{ +#if defined(BOOST_WINDOWS_API) + return "NUL"; +#elif defined(BOOST_POSIX_API) + return "/dev/null"; +#endif +} + +#if defined(BOOST_WINDOWS_API) +# define BOOST_PROCESS_EXITSTATUS(a) static_cast<int>(a) +#elif defined(BOOST_POSIX_API) +# define BOOST_PROCESS_EXITSTATUS WEXITSTATUS +#endif + +#if defined(BOOST_PROCESS_DOXYGEN) +/** + * Type definition for the end of a pipe. + * + * On Windows the type is based on boost::asio::windows::stream_handle. On + * POSIX it is based on boost::asio::posix::stream_descriptor. + * + * You can use this type definition for asynchronous I/O with streams of + * child processes. + */ +typedef boost_asio_type pipe_end; + +/** + * Gets the name of the zero device. + * + * You can use zero_device to initialize a + * boost::iostreams::file_descriptor_source to read + * null characters from. + * + * \returns NUL on Windows and /dev/zero on POSIX. + */ +const char *zero_device(); + +/** + * Gets the name of the null device. + * + * You can use null_device to initialize a + * boost::iostreams::file_descriptor_sink which discards + * data written to it. + * + * \returns NUL on Windows and /dev/null on POSIX. + */ +const char *null_device(); + +/** + * \def BOOST_PROCESS_EXITSTATUS + * + * On Windows \c BOOST_PROCESS_EXITSTATUS is a static cast to \c int. + * On POSIX it is set to \c WEXITSTATUS. + * + * You can use \c BOOST_PROCESS_EXITSTATUS for the return value of + * boost::process::wait_for_exit to get the exit status of a process. + */ +#define BOOST_PROCESS_EXITSTATUS +#endif + +}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/pipe.hpp b/plugins/New_GPG/src/include/boost/process/pipe.hpp new file mode 100644 index 0000000000..35f2a4470d --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/pipe.hpp @@ -0,0 +1,64 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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/pipe.hpp + * + * Defines a pipe. + */ + +#ifndef BOOST_PROCESS_PIPE_HPP +#define BOOST_PROCESS_PIPE_HPP + +#include <boost/process/config.hpp> + +#include BOOST_PROCESS_PLATFORM_PROMOTE_PATH(pipe) +BOOST_PROCESS_PLATFORM_PROMOTE_NAMESPACE(pipe) +BOOST_PROCESS_PLATFORM_PROMOTE_NAMESPACE(make_pipe) + +#if defined(BOOST_PROCESS_DOXYGEN) +namespace boost { namespace process { + +/** + * Represents a pipe. + */ +struct pipe +{ + /** + * Read-end. + */ + pipe_end_type source; + + /** + * Write-end. + */ + pipe_end_type sink; + + /** + * Constructor. + */ + pipe(pipe_end_type source, pipe_end_type sink); +}; + +/** + * Returns a pipe instance. + * + * This is a helper function to instantiate boost::process::pipe. + * + * \note boost::process::make_pipe does not create a pipe. + * You must pass existing pipe ends to this function. + * If you want to create an anonymous pipe, call + * boost::process::create_pipe. + */ +pipe make_pipe(pipe_end_type source, pipe_end_type sink); + +}} +#endif + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/search_path.hpp b/plugins/New_GPG/src/include/boost/process/search_path.hpp new file mode 100644 index 0000000000..20bff060b6 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/search_path.hpp @@ -0,0 +1,51 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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/search_path.hpp + * + * Defines a function to search for an executable in path. + */ + +#ifndef BOOST_PROCESS_SEARCH_PATH_HPP +#define BOOST_PROCESS_SEARCH_PATH_HPP + +#include <boost/process/config.hpp> + +#include BOOST_PROCESS_PLATFORM_PROMOTE_PATH(search_path) +BOOST_PROCESS_PLATFORM_PROMOTE_NAMESPACE(search_path) + +#if defined(BOOST_PROCESS_DOXYGEN) +namespace boost { namespace process { + +/** + * Searches for an executable in path. + * + * filename must be a basename including the file extension. + * It must not include any directory separators (like a slash). + * On Windows the file extension may be omitted. The function + * will then try the various file extensions for executables on + * Windows to find filename. + * + * path must be a set of directories. Directories must be + * separated by colons on POSIX and by semicolons on Windows. + * If path is empty, the environment variable PATH is used. + * + * \returns the absolute path to the executable filename or an + * empty string if filename isn't found + * + * \throws std::runtime_error if path is empty and no environment + * variable PATH exists + */ +string_type search_path(const string_type &filename, string_type path = ""); + +}} +#endif + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/shell_path.hpp b/plugins/New_GPG/src/include/boost/process/shell_path.hpp new file mode 100644 index 0000000000..92e9f0814b --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/shell_path.hpp @@ -0,0 +1,46 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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/shell_path.hpp + * + * Defines a function to return the absolute path to a shell executable. + */ + +#ifndef BOOST_PROCESS_SHELL_PATH_HPP +#define BOOST_PROCESS_SHELL_PATH_HPP + +#include <boost/process/config.hpp> + +#include BOOST_PROCESS_PLATFORM_PROMOTE_PATH(shell_path) +BOOST_PROCESS_PLATFORM_PROMOTE_NAMESPACE(shell_path) + +#if defined(BOOST_PROCESS_DOXYGEN) +namespace boost { namespace process { + +/** + * Returns the absolute path to a shell executable. + * + * \returns the path to cmd.exe on Windows and /bin/sh on POSIX. + * + * \throws boost::system::system_error in case of an error + */ +boost::filesystem::path shell_path(); + +/** + * Returns the absolute path to a shell executable. + * + * \returns the path to cmd.exe on Windows and /bin/sh on POSIX. + */ +boost::filesystem::path shell_path(boost::system::error_code &ec); + +}} +#endif + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/terminate.hpp b/plugins/New_GPG/src/include/boost/process/terminate.hpp new file mode 100644 index 0000000000..140eba7e8d --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/terminate.hpp @@ -0,0 +1,52 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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/terminate.hpp + * + * Defines a function to terminate a process. + */ + +#ifndef BOOST_PROCESS_TERMINATE_HPP +#define BOOST_PROCESS_TERMINATE_HPP + +#include <boost/process/config.hpp> + +#include BOOST_PROCESS_PLATFORM_PROMOTE_PATH(terminate) +BOOST_PROCESS_PLATFORM_PROMOTE_NAMESPACE(terminate) + +#if defined(BOOST_PROCESS_DOXYGEN) +namespace boost { namespace process { + +/** + * Terminates a process. + * + * \warning Call this function only as a last resort. The process + * is terminated immediately and forcefully and has no + * chance to close or clean up resources properly. + * + * \throws boost::system::system_error in case of an error + */ +template <class Process> +void terminate(const Process &p); + +/** + * Terminates a process. + * + * \warning Call this function only as a last resort. The process + * is terminated immediately and forcefully and has no + * chance to close or clean up resources properly. + */ +template <class Process> +void terminate(const Process &p, boost::system::error_code &ec); + +}} +#endif + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/wait_for_exit.hpp b/plugins/New_GPG/src/include/boost/process/wait_for_exit.hpp new file mode 100644 index 0000000000..d9b118695d --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/wait_for_exit.hpp @@ -0,0 +1,58 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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/wait_for_exit.hpp + * + * Defines a function to wait for a process to exit. + */ + +#ifndef BOOST_PROCESS_WAIT_FOR_EXIT_HPP +#define BOOST_PROCESS_WAIT_FOR_EXIT_HPP + +#include <boost/process/config.hpp> + +#include BOOST_PROCESS_PLATFORM_PROMOTE_PATH(wait_for_exit) +BOOST_PROCESS_PLATFORM_PROMOTE_NAMESPACE(wait_for_exit) + +#if defined(BOOST_PROCESS_DOXYGEN) +namespace boost { namespace process { + +/** + * Waits for a process to exit. + * + * On Window boost::process::wait_for_exit returns the exit code + * of the process. On POSIX the exit status is returned. You must + * use the macro \c WEXITSTATUS (defined in sys/wait.h) to fetch + * the exit code from the exit status. + * + * \note This is a blocking function. + * + * \throws boost::system::system_error in case of an error + */ +template <class Process> +int_type wait_for_exit(const Process &p); + +/** + * Waits for a process to exit. + * + * On Window boost::process::wait_for_exit returns the exit code + * of the process. On POSIX the exit status is returned. You must + * use the macro \c WEXITSTATUS (defined in sys/wait.h) to fetch + * the exit code from the exit status. + * + * \note This is a blocking function. + */ +template <class Process> +int_type wait_for_exit(const Process &p, boost::system::error_code &ec); + +}} +#endif + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/child.hpp b/plugins/New_GPG/src/include/boost/process/windows/child.hpp new file mode 100644 index 0000000000..083cd29da0 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/child.hpp @@ -0,0 +1,55 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_CHILD_HPP +#define BOOST_PROCESS_WINDOWS_CHILD_HPP + +#include <boost/move/move.hpp> +#include <Windows.h> + +namespace boost { namespace process { namespace windows { + +class child +{ +public: + PROCESS_INFORMATION proc_info; + + explicit child(const PROCESS_INFORMATION &pi) : proc_info(pi) {} + + ~child() + { + ::CloseHandle(proc_info.hProcess); + ::CloseHandle(proc_info.hThread); + } + + child(BOOST_RV_REF(child) c) : proc_info(c.proc_info) + { + c.proc_info.hProcess = INVALID_HANDLE_VALUE; + c.proc_info.hThread = INVALID_HANDLE_VALUE; + } + + child &operator=(BOOST_RV_REF(child) c) + { + ::CloseHandle(proc_info.hProcess); + ::CloseHandle(proc_info.hThread); + proc_info = c.proc_info; + c.proc_info.hProcess = INVALID_HANDLE_VALUE; + c.proc_info.hThread = INVALID_HANDLE_VALUE; + return *this; + } + + HANDLE process_handle() const { return proc_info.hProcess; } + +private: + BOOST_MOVABLE_BUT_NOT_COPYABLE(child); +}; + +}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/create_pipe.hpp b/plugins/New_GPG/src/include/boost/process/windows/create_pipe.hpp new file mode 100644 index 0000000000..fe1e49751d --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/create_pipe.hpp @@ -0,0 +1,40 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_CREATE_PIPE_HPP +#define BOOST_PROCESS_WINDOWS_CREATE_PIPE_HPP + +#include <boost/process/config.hpp> +#include <boost/process/windows/pipe.hpp> +#include <boost/system/error_code.hpp> +#include <Windows.h> + +namespace boost { namespace process { namespace windows { + +inline pipe create_pipe() +{ + HANDLE handles[2]; + if (!::CreatePipe(&handles[0], &handles[1], NULL, 0)) + BOOST_PROCESS_THROW_LAST_SYSTEM_ERROR("CreatePipe() failed"); + return make_pipe(handles[0], handles[1]); +} + +inline pipe create_pipe(boost::system::error_code &ec) +{ + HANDLE handles[2]; + if (!::CreatePipe(&handles[0], &handles[1], NULL, 0)) + BOOST_PROCESS_RETURN_LAST_SYSTEM_ERROR(ec); + else + ec.clear(); + return make_pipe(handles[0], handles[1]); +} + +}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/execute.hpp b/plugins/New_GPG/src/include/boost/process/windows/execute.hpp new file mode 100644 index 0000000000..43067521ea --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/execute.hpp @@ -0,0 +1,82 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_EXECUTE_HPP +#define BOOST_PROCESS_WINDOWS_EXECUTE_HPP + +#include <boost/process/windows/executor.hpp> +#include <boost/process/windows/child.hpp> +#include <boost/fusion/tuple/make_tuple.hpp> +#include <boost/ref.hpp> + +namespace boost { namespace process { namespace windows { + +template <class I0> +child execute(const I0 &i0) +{ + return executor()(boost::fusion::make_tuple(boost::cref(i0))); +} + +template <class I0, class I1> +child execute(const I0 &i0, const I1 &i1) +{ + return executor()(boost::fusion::make_tuple(boost::cref(i0), boost::cref(i1))); +} + +template <class I0, class I1, class I2> +child execute(const I0 &i0, const I1 &i1, const I2 &i2) +{ + return executor()(boost::fusion::make_tuple(boost::cref(i0), boost::cref(i1), boost::cref(i2))); +} + +template <class I0, class I1, class I2, class I3> +child execute(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3) +{ + return executor()(boost::fusion::make_tuple(boost::cref(i0), boost::cref(i1), boost::cref(i2), boost::cref(i3))); +} + +template <class I0, class I1, class I2, class I3, class I4> +child execute(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3, const I4 &i4) +{ + return executor()(boost::fusion::make_tuple(boost::cref(i0), boost::cref(i1), boost::cref(i2), boost::cref(i3), boost::cref(i4))); +} + +template <class I0, class I1, class I2, class I3, class I4, class I5> +child execute(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3, const I4 &i4, const I5 &i5) +{ + return executor()(boost::fusion::make_tuple(boost::cref(i0), boost::cref(i1), boost::cref(i2), boost::cref(i3), boost::cref(i4), boost::cref(i5))); +} + +template <class I0, class I1, class I2, class I3, class I4, class I5, class I6> +child execute(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3, const I4 &i4, const I5 &i5, const I6 &i6) +{ + return executor()(boost::fusion::make_tuple(boost::cref(i0), boost::cref(i1), boost::cref(i2), boost::cref(i3), boost::cref(i4), boost::cref(i5), boost::cref(i6))); +} + +template <class I0, class I1, class I2, class I3, class I4, class I5, class I6, class I7> +child execute(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3, const I4 &i4, const I5 &i5, const I6 &i6, const I7 &i7) +{ + return executor()(boost::fusion::make_tuple(boost::cref(i0), boost::cref(i1), boost::cref(i2), boost::cref(i3), boost::cref(i4), boost::cref(i5), boost::cref(i6), boost::cref(i7))); +} + +template <class I0, class I1, class I2, class I3, class I4, class I5, class I6, class I7, class I8> +child execute(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3, const I4 &i4, const I5 &i5, const I6 &i6, const I7 &i7, const I8 &i8) +{ + return executor()(boost::fusion::make_tuple(boost::cref(i0), boost::cref(i1), boost::cref(i2), boost::cref(i3), boost::cref(i4), boost::cref(i5), boost::cref(i6), boost::cref(i7), boost::cref(i8))); +} + +template <class I0, class I1, class I2, class I3, class I4, class I5, class I6, class I7, class I8, class I9> +child execute(const I0 &i0, const I1 &i1, const I2 &i2, const I3 &i3, const I4 &i4, const I5 &i5, const I6 &i6, const I7 &i7, const I8 &i8, const I9 &i9) +{ + return executor()(boost::fusion::make_tuple(boost::cref(i0), boost::cref(i1), boost::cref(i2), boost::cref(i3), boost::cref(i4), boost::cref(i5), boost::cref(i6), boost::cref(i7), boost::cref(i8), boost::cref(i9))); +} + +}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/executor.hpp b/plugins/New_GPG/src/include/boost/process/windows/executor.hpp new file mode 100644 index 0000000000..1560f30793 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/executor.hpp @@ -0,0 +1,130 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_EXECUTOR_HPP +#define BOOST_PROCESS_WINDOWS_EXECUTOR_HPP + +#include <boost/process/windows/child.hpp> +#include <boost/fusion/algorithm/iteration/for_each.hpp> +#include <Windows.h> + +namespace boost { namespace process { namespace windows { + +struct executor +{ + executor() : exe(0), cmd_line(0), proc_attrs(0), thread_attrs(0), + inherit_handles(FALSE), +#if (_WIN32_WINNT >= 0x0600) + creation_flags(EXTENDED_STARTUPINFO_PRESENT), +#else + creation_flags(0), +#endif + env(0), work_dir(0) +#if (_WIN32_WINNT >= 0x0600) + ,startup_info(startup_info_ex.StartupInfo) +#endif + { +#if (_WIN32_WINNT >= 0x0600) + ZeroMemory(&startup_info_ex, sizeof(STARTUPINFOEX)); + startup_info.cb = sizeof(STARTUPINFOEX); +#else + ZeroMemory(&startup_info, sizeof(STARTUPINFO)); + startup_info.cb = sizeof(STARTUPINFO); +#endif + startup_info.hStdInput = INVALID_HANDLE_VALUE; + startup_info.hStdOutput = INVALID_HANDLE_VALUE; + startup_info.hStdError = INVALID_HANDLE_VALUE; + } + + struct call_on_CreateProcess_setup + { + executor &e_; + + call_on_CreateProcess_setup(executor &e) : e_(e) {} + + template <class Arg> + void operator()(Arg &arg) const + { + arg.on_CreateProcess_setup(e_); + } + }; + + struct call_on_CreateProcess_error + { + executor &e_; + + call_on_CreateProcess_error(executor &e) : e_(e) {} + + template <class Arg> + void operator()(Arg &arg) const + { + arg.on_CreateProcess_error(e_); + } + }; + + struct call_on_CreateProcess_success + { + executor &e_; + + call_on_CreateProcess_success(executor &e) : e_(e) {} + + template <class Arg> + void operator()(Arg &arg) const + { + arg.on_CreateProcess_success(e_); + } + }; + + template <class InitializerSequence> + child operator()(const InitializerSequence &seq) + { + boost::fusion::for_each(seq, call_on_CreateProcess_setup(*this)); + + if (!::CreateProcess( + exe, + cmd_line, + proc_attrs, + thread_attrs, + inherit_handles, + creation_flags, + env, + work_dir, + &startup_info, + &proc_info)) + { + boost::fusion::for_each(seq, call_on_CreateProcess_error(*this)); + } + else + { + boost::fusion::for_each(seq, call_on_CreateProcess_success(*this)); + } + + return child(proc_info); + } + + LPCTSTR exe; + LPTSTR cmd_line; + LPSECURITY_ATTRIBUTES proc_attrs; + LPSECURITY_ATTRIBUTES thread_attrs; + BOOL inherit_handles; + DWORD creation_flags; + LPVOID env; + LPCTSTR work_dir; +#if (_WIN32_WINNT >= 0x0600) + STARTUPINFOEX startup_info_ex; + STARTUPINFO &startup_info; +#else + STARTUPINFO startup_info; +#endif + PROCESS_INFORMATION proc_info; +}; + +}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/initializers.hpp b/plugins/New_GPG/src/include/boost/process/windows/initializers.hpp new file mode 100644 index 0000000000..2d7098c034 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/initializers.hpp @@ -0,0 +1,33 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_INITIALIZERS_HPP +#define BOOST_PROCESS_WINDOWS_INITIALIZERS_HPP + +#include <boost/process/windows/initializers/bind_stderr.hpp> +#include <boost/process/windows/initializers/bind_stdin.hpp> +#include <boost/process/windows/initializers/bind_stdout.hpp> +#include <boost/process/windows/initializers/close_stderr.hpp> +#include <boost/process/windows/initializers/close_stdin.hpp> +#include <boost/process/windows/initializers/close_stdout.hpp> +#include <boost/process/windows/initializers/hide_console.hpp> +#include <boost/process/windows/initializers/inherit_env.hpp> +#include <boost/process/windows/initializers/on_CreateProcess_error.hpp> +#include <boost/process/windows/initializers/on_CreateProcess_setup.hpp> +#include <boost/process/windows/initializers/on_CreateProcess_success.hpp> +#include <boost/process/windows/initializers/run_exe.hpp> +#include <boost/process/windows/initializers/set_args.hpp> +#include <boost/process/windows/initializers/set_cmd_line.hpp> +#include <boost/process/windows/initializers/set_env.hpp> +#include <boost/process/windows/initializers/set_on_error.hpp> +#include <boost/process/windows/initializers/show_window.hpp> +#include <boost/process/windows/initializers/start_in_dir.hpp> +#include <boost/process/windows/initializers/throw_on_error.hpp> + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/initializers/bind_stderr.hpp b/plugins/New_GPG/src/include/boost/process/windows/initializers/bind_stderr.hpp new file mode 100644 index 0000000000..de3ee30dc5 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/initializers/bind_stderr.hpp @@ -0,0 +1,39 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_INITIALIZERS_BIND_STDERR_HPP +#define BOOST_PROCESS_WINDOWS_INITIALIZERS_BIND_STDERR_HPP + +#include <boost/process/windows/initializers/initializer_base.hpp> +#include <boost/iostreams/device/file_descriptor.hpp> +#include <Windows.h> + +namespace boost { namespace process { namespace windows { namespace initializers { + +class bind_stderr : public initializer_base +{ +public: + explicit bind_stderr(const boost::iostreams::file_descriptor_sink &sink) : sink_(sink) {} + + template <class WindowsExecutor> + void on_CreateProcess_setup(WindowsExecutor &e) const + { + ::SetHandleInformation(sink_.handle(), HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT); + e.startup_info.hStdError = sink_.handle(); + e.startup_info.dwFlags |= STARTF_USESTDHANDLES; + e.inherit_handles = true; + } + +private: + boost::iostreams::file_descriptor_sink sink_; +}; + +}}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/initializers/bind_stdin.hpp b/plugins/New_GPG/src/include/boost/process/windows/initializers/bind_stdin.hpp new file mode 100644 index 0000000000..54c942ab63 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/initializers/bind_stdin.hpp @@ -0,0 +1,39 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_INITIALIZERS_BIND_STDIN_HPP +#define BOOST_PROCESS_WINDOWS_INITIALIZERS_BIND_STDIN_HPP + +#include <boost/process/windows/initializers/initializer_base.hpp> +#include <boost/iostreams/device/file_descriptor.hpp> +#include <Windows.h> + +namespace boost { namespace process { namespace windows { namespace initializers { + +class bind_stdin : public initializer_base +{ +public: + explicit bind_stdin(const boost::iostreams::file_descriptor_source &source) : source_(source) {} + + template <class WindowsExecutor> + void on_CreateProcess_setup(WindowsExecutor &e) const + { + ::SetHandleInformation(source_.handle(), HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT); + e.startup_info.hStdInput = source_.handle(); + e.startup_info.dwFlags |= STARTF_USESTDHANDLES; + e.inherit_handles = true; + } + +private: + boost::iostreams::file_descriptor_source source_; +}; + +}}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/initializers/bind_stdout.hpp b/plugins/New_GPG/src/include/boost/process/windows/initializers/bind_stdout.hpp new file mode 100644 index 0000000000..c72c05f1bf --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/initializers/bind_stdout.hpp @@ -0,0 +1,39 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_INITIALIZERS_BIND_STDOUT_HPP +#define BOOST_PROCESS_WINDOWS_INITIALIZERS_BIND_STDOUT_HPP + +#include <boost/process/windows/initializers/initializer_base.hpp> +#include <boost/iostreams/device/file_descriptor.hpp> +#include <Windows.h> + +namespace boost { namespace process { namespace windows { namespace initializers { + +class bind_stdout : public initializer_base +{ +public: + explicit bind_stdout(const boost::iostreams::file_descriptor_sink &sink) : sink_(sink) {} + + template <class WindowsExecutor> + void on_CreateProcess_setup(WindowsExecutor &e) const + { + ::SetHandleInformation(sink_.handle(), HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT); + e.startup_info.hStdOutput = sink_.handle(); + e.startup_info.dwFlags |= STARTF_USESTDHANDLES; + e.inherit_handles = true; + } + +private: + boost::iostreams::file_descriptor_sink sink_; +}; + +}}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/initializers/close_stderr.hpp b/plugins/New_GPG/src/include/boost/process/windows/initializers/close_stderr.hpp new file mode 100644 index 0000000000..373c097f3a --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/initializers/close_stderr.hpp @@ -0,0 +1,31 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_INITIALIZERS_CLOSE_STDERR_HPP +#define BOOST_PROCESS_WINDOWS_INITIALIZERS_CLOSE_STDERR_HPP + +#include <boost/process/windows/initializers/initializer_base.hpp> +#include <Windows.h> + +namespace boost { namespace process { namespace windows { namespace initializers { + +class close_stderr : public initializer_base +{ +public: + template <class WindowsExecutor> + void on_CreateProcess_setup(WindowsExecutor &e) const + { + e.startup_info.hStdError = INVALID_HANDLE_VALUE; + e.startup_info.dwFlags |= STARTF_USESTDHANDLES; + } +}; + +}}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/initializers/close_stdin.hpp b/plugins/New_GPG/src/include/boost/process/windows/initializers/close_stdin.hpp new file mode 100644 index 0000000000..036b0bb4ce --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/initializers/close_stdin.hpp @@ -0,0 +1,31 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_INITIALIZERS_CLOSE_STDIN_HPP +#define BOOST_PROCESS_WINDOWS_INITIALIZERS_CLOSE_STDIN_HPP + +#include <boost/process/windows/initializers/initializer_base.hpp> +#include <Windows.h> + +namespace boost { namespace process { namespace windows { namespace initializers { + +class close_stdin : public initializer_base +{ +public: + template <class WindowsExecutor> + void on_CreateProcess_setup(WindowsExecutor &e) const + { + e.startup_info.hStdInput = INVALID_HANDLE_VALUE; + e.startup_info.dwFlags |= STARTF_USESTDHANDLES; + } +}; + +}}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/initializers/close_stdout.hpp b/plugins/New_GPG/src/include/boost/process/windows/initializers/close_stdout.hpp new file mode 100644 index 0000000000..b58a6000f9 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/initializers/close_stdout.hpp @@ -0,0 +1,31 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_INITIALIZERS_CLOSE_STDOUT_HPP +#define BOOST_PROCESS_WINDOWS_INITIALIZERS_CLOSE_STDOUT_HPP + +#include <boost/process/windows/initializers/initializer_base.hpp> +#include <Windows.h> + +namespace boost { namespace process { namespace windows { namespace initializers { + +class close_stdout : public initializer_base +{ +public: + template <class WindowsExecutor> + void on_CreateProcess_setup(WindowsExecutor &e) const + { + e.startup_info.hStdOutput = INVALID_HANDLE_VALUE; + e.startup_info.dwFlags |= STARTF_USESTDHANDLES; + } +}; + +}}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/initializers/hide_console.hpp b/plugins/New_GPG/src/include/boost/process/windows/initializers/hide_console.hpp new file mode 100644 index 0000000000..b01aa026f0 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/initializers/hide_console.hpp @@ -0,0 +1,31 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_INITIALIZERS_HIDE_CONSOLE_HPP +#define BOOST_PROCESS_WINDOWS_INITIALIZERS_HIDE_CONSOLE_HPP + +#include <boost/process/windows/initializers/initializer_base.hpp> +#include <Windows.h> + +namespace boost { namespace process { namespace windows { namespace initializers { + +class hide_console : public initializer_base +{ +public: + template <class WindowsExecutor> + void on_CreateProcess_setup(WindowsExecutor &e) const + { + e.startup_info.dwFlags |= STARTF_USESHOWWINDOW; + e.startup_info.wShowWindow |= SW_HIDE; + } +}; + +}}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/initializers/inherit_env.hpp b/plugins/New_GPG/src/include/boost/process/windows/initializers/inherit_env.hpp new file mode 100644 index 0000000000..a2b2eda00a --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/initializers/inherit_env.hpp @@ -0,0 +1,24 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_INITIALIZERS_INHERIT_ENV_HPP +#define BOOST_PROCESS_WINDOWS_INITIALIZERS_INHERIT_ENV_HPP + +#include <boost/process/windows/initializers/initializer_base.hpp> + +namespace boost { namespace process { namespace windows { namespace initializers { + +class inherit_env : public initializer_base +{ +public: +}; + +}}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/initializers/initializer_base.hpp b/plugins/New_GPG/src/include/boost/process/windows/initializers/initializer_base.hpp new file mode 100644 index 0000000000..b98da7b21b --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/initializers/initializer_base.hpp @@ -0,0 +1,29 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_INITIALIZERS_INITIALIZER_BASE_HPP +#define BOOST_PROCESS_WINDOWS_INITIALIZERS_INITIALIZER_BASE_HPP + +namespace boost { namespace process { namespace windows { namespace initializers { + +struct initializer_base +{ + template <class WindowsExecutor> + void on_CreateProcess_setup(WindowsExecutor&) const {} + + template <class WindowsExecutor> + void on_CreateProcess_error(WindowsExecutor&) const {} + + template <class WindowsExecutor> + void on_CreateProcess_success(WindowsExecutor&) const {} +}; + +}}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/initializers/on_CreateProcess_error.hpp b/plugins/New_GPG/src/include/boost/process/windows/initializers/on_CreateProcess_error.hpp new file mode 100644 index 0000000000..71eeada072 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/initializers/on_CreateProcess_error.hpp @@ -0,0 +1,42 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_INITIALIZERS_ON_CREATEPROCESS_ERROR_HPP +#define BOOST_PROCESS_WINDOWS_INITIALIZERS_ON_CREATEPROCESS_ERROR_HPP + +#include <boost/process/config.hpp> +#include <boost/process/windows/initializers/initializer_base.hpp> + +namespace boost { namespace process { namespace windows { namespace initializers { + +template <class Handler> +class on_CreateProcess_error_ : public initializer_base +{ +public: + explicit on_CreateProcess_error_(Handler handler) : handler_(handler) {} + + template <class WindowsExecutor> + void on_CreateProcess_error(WindowsExecutor &e) const + { + handler_(e); + } + +private: + Handler handler_; +}; + +template <class Handler> +on_CreateProcess_error_<Handler> on_CreateProcess_error(Handler handler) +{ + return on_CreateProcess_error_<Handler>(handler); +} + +}}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/initializers/on_CreateProcess_setup.hpp b/plugins/New_GPG/src/include/boost/process/windows/initializers/on_CreateProcess_setup.hpp new file mode 100644 index 0000000000..671fc9ac5c --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/initializers/on_CreateProcess_setup.hpp @@ -0,0 +1,42 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_INITIALIZERS_ON_CREATEPROCESS_SETUP_HPP +#define BOOST_PROCESS_WINDOWS_INITIALIZERS_ON_CREATEPROCESS_SETUP_HPP + +#include <boost/process/config.hpp> +#include <boost/process/windows/initializers/initializer_base.hpp> + +namespace boost { namespace process { namespace windows { namespace initializers { + +template <class Handler> +class on_CreateProcess_setup_ : public initializer_base +{ +public: + explicit on_CreateProcess_setup_(Handler handler) : handler_(handler) {} + + template <class WindowsExecutor> + void on_CreateProcess_setup(WindowsExecutor &e) const + { + handler_(e); + } + +private: + Handler handler_; +}; + +template <class Handler> +on_CreateProcess_setup_<Handler> on_CreateProcess_setup(Handler handler) +{ + return on_CreateProcess_setup_<Handler>(handler); +} + +}}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/initializers/on_CreateProcess_success.hpp b/plugins/New_GPG/src/include/boost/process/windows/initializers/on_CreateProcess_success.hpp new file mode 100644 index 0000000000..67b3b2bdcf --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/initializers/on_CreateProcess_success.hpp @@ -0,0 +1,42 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_INITIALIZERS_ON_CREATEPROCESS_SUCCESS_HPP +#define BOOST_PROCESS_WINDOWS_INITIALIZERS_ON_CREATEPROCESS_SUCCESS_HPP + +#include <boost/process/config.hpp> +#include <boost/process/windows/initializers/initializer_base.hpp> + +namespace boost { namespace process { namespace windows { namespace initializers { + +template <class Handler> +class on_CreateProcess_success_ : public initializer_base +{ +public: + explicit on_CreateProcess_success_(Handler handler) : handler_(handler) {} + + template <class WindowsExecutor> + void on_CreateProcess_sucess(WindowsExecutor &e) const + { + handler_(e); + } + +private: + Handler handler_; +}; + +template <class Handler> +on_CreateProcess_success_<Handler> on_CreateProcess_success(Handler handler) +{ + return on_CreateProcess_success_<Handler>(handler); +} + +}}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/initializers/run_exe.hpp b/plugins/New_GPG/src/include/boost/process/windows/initializers/run_exe.hpp new file mode 100644 index 0000000000..bfa2b790b1 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/initializers/run_exe.hpp @@ -0,0 +1,69 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_INITIALIZERS_RUN_EXE_HPP +#define BOOST_PROCESS_WINDOWS_INITIALIZERS_RUN_EXE_HPP + +#include <boost/process/windows/initializers/initializer_base.hpp> +#include <boost/filesystem.hpp> +#include <string> + +namespace boost { namespace process { namespace windows { namespace initializers { + +template <class String> +class run_exe_ : public initializer_base +{ +public: + explicit run_exe_(const String &s) : s_(s) {} + + template <class WindowsExecutor> + void on_CreateProcess_setup(WindowsExecutor &e) const + { + e.exe = s_.c_str(); + } + +private: + String s_; +}; + +#if defined(_UNICODE) || defined(UNICODE) +inline run_exe_<std::wstring> run_exe(const wchar_t *ws) +{ + return run_exe_<std::wstring>(ws); +} + +inline run_exe_<std::wstring> run_exe(const std::wstring &ws) +{ + return run_exe_<std::wstring>(ws); +} + +inline run_exe_<std::wstring> run_exe(const boost::filesystem::path &p) +{ + return run_exe_<std::wstring>(p.wstring()); +} +#else +inline run_exe_<std::string> run_exe(const char *s) +{ + return run_exe_<std::string>(s); +} + +inline run_exe_<std::string> run_exe(const std::string &s) +{ + return run_exe_<std::string>(s); +} + +inline run_exe_<std::string> run_exe(const boost::filesystem::path &p) +{ + return run_exe_<std::string>(p.string()); +} +#endif + +}}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/initializers/set_args.hpp b/plugins/New_GPG/src/include/boost/process/windows/initializers/set_args.hpp new file mode 100644 index 0000000000..4b3c5b6249 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/initializers/set_args.hpp @@ -0,0 +1,87 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_INITIALIZERS_SET_ARGS_HPP +#define BOOST_PROCESS_WINDOWS_INITIALIZERS_SET_ARGS_HPP + +#include <boost/process/windows/initializers/initializer_base.hpp> +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> +#include <boost/range/algorithm/copy.hpp> +#include <boost/algorithm/string/predicate.hpp> +#include <boost/shared_array.hpp> +#include <sstream> + +namespace boost { namespace process { namespace windows { namespace initializers { + +template <class Range> +class set_args_ : public initializer_base +{ +private: + typedef typename Range::const_iterator ConstIterator; + typedef typename Range::value_type String; + typedef typename String::value_type Char; + typedef std::basic_ostringstream<Char> OStringStream; + +public: + explicit set_args_(const Range &args) + { + ConstIterator it = boost::const_begin(args); + ConstIterator end = boost::const_end(args); + if (it != end) + { + exe_ = *it; + OStringStream os; + for (; it != end; ++it) + { + if (boost::algorithm::contains(*it, + String(1, static_cast<Char>(' ')))) + { + os << static_cast<Char>('"') << *it << + static_cast<Char>('"'); + } + else + { + os << *it; + } + os << static_cast<Char>(' '); + } + String s = os.str(); + cmd_line_.reset(new Char[s.size() + 1]); + boost::copy(s, cmd_line_.get()); + cmd_line_[s.size()] = 0; + } + else + { + cmd_line_.reset(new Char[1]()); + } + } + + template <class WindowsExecutor> + void on_CreateProcess_setup(WindowsExecutor &e) const + { + e.cmd_line = cmd_line_.get(); + if (!e.exe && !exe_.empty()) + e.exe = exe_.c_str(); + } + +private: + boost::shared_array<Char> cmd_line_; + String exe_; +}; + +template <class Range> +set_args_<Range> set_args(const Range &range) +{ + return set_args_<Range>(range); +} + +}}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/initializers/set_cmd_line.hpp b/plugins/New_GPG/src/include/boost/process/windows/initializers/set_cmd_line.hpp new file mode 100644 index 0000000000..a3d9f6f761 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/initializers/set_cmd_line.hpp @@ -0,0 +1,68 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_INITIALIZERS_SET_CMD_LINE_HPP +#define BOOST_PROCESS_WINDOWS_INITIALIZERS_SET_CMD_LINE_HPP + +#include <boost/process/windows/initializers/initializer_base.hpp> +#include <boost/range/algorithm/copy.hpp> +#include <boost/shared_array.hpp> +#include <memory> + +namespace boost { namespace process { namespace windows { namespace initializers { + +template <class String> +class set_cmd_line_ : public initializer_base +{ +private: + typedef typename String::value_type Char; + +public: + explicit set_cmd_line_(const String &s) + : cmd_line_(new Char[s.size() + 1]) + { + boost::copy(s, cmd_line_.get()); + cmd_line_[s.size()] = 0; + } + + template <class WindowsExecutor> + void on_CreateProcess_setup(WindowsExecutor &e) const + { + e.cmd_line = cmd_line_.get(); + } + +private: + boost::shared_array<Char> cmd_line_; +}; + +#if defined(_UNICODE) || defined(UNICODE) +inline set_cmd_line_<std::wstring> set_cmd_line(const wchar_t *ws) +{ + return set_cmd_line_<std::wstring>(ws); +} + +inline set_cmd_line_<std::wstring> set_cmd_line(const std::wstring &ws) +{ + return set_cmd_line_<std::wstring>(ws); +} +#else +inline set_cmd_line_<std::string> set_cmd_line(const char *s) +{ + return set_cmd_line_<std::string>(s); +} + +inline set_cmd_line_<std::string> set_cmd_line(const std::string &s) +{ + return set_cmd_line_<std::string>(s); +} +#endif + +}}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/initializers/set_env.hpp b/plugins/New_GPG/src/include/boost/process/windows/initializers/set_env.hpp new file mode 100644 index 0000000000..6dfdfc58a4 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/initializers/set_env.hpp @@ -0,0 +1,88 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_INITIALIZERS_SET_ENV_HPP +#define BOOST_PROCESS_WINDOWS_INITIALIZERS_SET_ENV_HPP + +#include <Windows.h> +#include <boost/process/windows/initializers/initializer_base.hpp> +#include <boost/range/numeric.hpp> +#include <boost/range/algorithm/copy.hpp> +#include <boost/range/algorithm/for_each.hpp> +#include <boost/shared_array.hpp> +#include <iterator> +#include <cstddef> + +namespace boost { namespace process { namespace windows { namespace initializers { + +template <class Range, bool Unicode> +class set_env_ : public initializer_base +{ +private: + typedef typename Range::value_type String; + typedef typename String::value_type Char; + + static std::size_t add_size(std::size_t size, const String &s) + { + return size + s.size() + 1u; + } + + struct copy + { + Char *it_; + + copy(Char *it) : it_(it) {} + + void operator()(const String &s) + { + it_ = boost::copy(s, it_); + *it_ = 0; + ++it_; + } + }; + +public: + set_env_(const Range &envs) + : size_(boost::accumulate(envs, 0, add_size) + 1), + env_(new Char[size_]) + { + boost::for_each(envs, copy(env_.get())); + env_[size_ - 1] = 0; + } + + template <class WindowsExecutor> + void on_CreateProcess_setup(WindowsExecutor &e) const + { + e.env = env_.get(); + if (Unicode) + e.creation_flags |= CREATE_UNICODE_ENVIRONMENT; + } + +private: + std::size_t size_; + boost::shared_array<Char> env_; +}; + +#if defined(_UNICODE) || defined(UNICODE) +template <class Range> +set_env_<Range, true> set_env(const Range &envs) +{ + return set_env_<Range, true>(envs); +} +#else +template <class Range> +set_env_<Range, false> set_env(const Range &envs) +{ + return set_env_<Range, false>(envs); +} +#endif + +}}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/initializers/set_on_error.hpp b/plugins/New_GPG/src/include/boost/process/windows/initializers/set_on_error.hpp new file mode 100644 index 0000000000..695ea5904d --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/initializers/set_on_error.hpp @@ -0,0 +1,36 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_INITIALIZERS_SET_ON_ERROR_HPP +#define BOOST_PROCESS_WINDOWS_INITIALIZERS_SET_ON_ERROR_HPP + +#include <boost/process/config.hpp> +#include <boost/process/windows/initializers/initializer_base.hpp> +#include <boost/system/error_code.hpp> + +namespace boost { namespace process { namespace windows { namespace initializers { + +class set_on_error : public initializer_base +{ +public: + explicit set_on_error(boost::system::error_code &ec) : ec_(ec) {} + + template <class WindowsExecutor> + void on_CreateProcess_error(WindowsExecutor&) const + { + BOOST_PROCESS_RETURN_LAST_SYSTEM_ERROR(ec_); + } + +private: + boost::system::error_code &ec_; +}; + +}}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/initializers/show_window.hpp b/plugins/New_GPG/src/include/boost/process/windows/initializers/show_window.hpp new file mode 100644 index 0000000000..3046179205 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/initializers/show_window.hpp @@ -0,0 +1,36 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_INITIALIZERS_SHOW_WINDOW_HPP +#define BOOST_PROCESS_WINDOWS_INITIALIZERS_SHOW_WINDOW_HPP + +#include <boost/process/windows/initializers/initializer_base.hpp> +#include <Windows.h> + +namespace boost { namespace process { namespace windows { namespace initializers { + +class show_window : public initializer_base +{ +public: + explicit show_window(WORD flags) : flags_(flags) {} + + template <class WindowsExecutor> + void on_CreateProcess_setup(WindowsExecutor &e) const + { + e.startup_info.dwFlags |= STARTF_USESHOWWINDOW; + e.startup_info.wShowWindow |= flags_; + } + +private: + WORD flags_; +}; + +}}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/initializers/start_in_dir.hpp b/plugins/New_GPG/src/include/boost/process/windows/initializers/start_in_dir.hpp new file mode 100644 index 0000000000..8dc952abcc --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/initializers/start_in_dir.hpp @@ -0,0 +1,69 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_INITIALIZERS_START_IN_DIR_HPP +#define BOOST_PROCESS_WINDOWS_INITIALIZERS_START_IN_DIR_HPP + +#include <boost/process/windows/initializers/initializer_base.hpp> +#include <boost/filesystem/path.hpp> +#include <string> + +namespace boost { namespace process { namespace windows { namespace initializers { + +template <class String> +class start_in_dir_ : public initializer_base +{ +public: + explicit start_in_dir_(const String &s) : s_(s) {} + + template <class WindowsExecutor> + void on_CreateProcess_setup(WindowsExecutor &e) const + { + e.work_dir = s_.c_str(); + } + +private: + String s_; +}; + +#if defined(_UNICODE) || defined(UNICODE) +inline start_in_dir_<std::wstring> start_in_dir(const wchar_t *ws) +{ + return start_in_dir_<std::wstring>(ws); +} + +inline start_in_dir_<std::wstring> start_in_dir(const std::wstring &ws) +{ + return start_in_dir_<std::wstring>(ws); +} + +inline start_in_dir_<std::wstring> start_in_dir(const boost::filesystem::path &p) +{ + return start_in_dir_<std::wstring>(p.wstring()); +} +#else +inline start_in_dir_<std::string> start_in_dir(const char *s) +{ + return start_in_dir_<std::string>(s); +} + +inline start_in_dir_<std::string> start_in_dir(const std::string &s) +{ + return start_in_dir_<std::string>(s); +} + +inline start_in_dir_<std::string> start_in_dir(const boost::filesystem::path &p) +{ + return start_in_dir_<std::string>(p.string()); +} +#endif + +}}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/initializers/throw_on_error.hpp b/plugins/New_GPG/src/include/boost/process/windows/initializers/throw_on_error.hpp new file mode 100644 index 0000000000..044fa00417 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/initializers/throw_on_error.hpp @@ -0,0 +1,30 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_INITIALIZERS_THROW_ON_ERROR_HPP +#define BOOST_PROCESS_WINDOWS_INITIALIZERS_THROW_ON_ERROR_HPP + +#include <boost/process/config.hpp> +#include <boost/process/windows/initializers/initializer_base.hpp> + +namespace boost { namespace process { namespace windows { namespace initializers { + +class throw_on_error : public initializer_base +{ +public: + template <class WindowsExecutor> + void on_CreateProcess_error(WindowsExecutor&) const + { + BOOST_PROCESS_THROW_LAST_SYSTEM_ERROR("CreateProcess() failed"); + } +}; + +}}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/pipe.hpp b/plugins/New_GPG/src/include/boost/process/windows/pipe.hpp new file mode 100644 index 0000000000..fd912afcc9 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/pipe.hpp @@ -0,0 +1,32 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_PIPE_HPP +#define BOOST_PROCESS_WINDOWS_PIPE_HPP + +#include <Windows.h> + +namespace boost { namespace process { namespace windows { + +struct pipe +{ + HANDLE source; + HANDLE sink; + + pipe(HANDLE source, HANDLE sink) : source(source), sink(sink) {} +}; + +inline pipe make_pipe(HANDLE source, HANDLE sink) +{ + return pipe(source, sink); +} + +}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/search_path.hpp b/plugins/New_GPG/src/include/boost/process/windows/search_path.hpp new file mode 100644 index 0000000000..ceb9c6f7c2 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/search_path.hpp @@ -0,0 +1,104 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_SEARCH_PATH_HPP +#define BOOST_PROCESS_WINDOWS_SEARCH_PATH_HPP + +#include <boost/process/config.hpp> +#include <boost/filesystem.hpp> +#include <boost/tokenizer.hpp> +#include <boost/array.hpp> +#include <boost/system/error_code.hpp> +#include <string> +#include <stdexcept> +#include <stdlib.h> +#include <Shellapi.h> + +namespace boost { namespace process { namespace windows { + +#if defined(_UNICODE) || defined(UNICODE) +inline std::wstring search_path(const std::wstring &filename, + std::wstring path = L"") +{ + if (path.empty()) + { + path = ::_wgetenv(L"PATH"); + if (path.empty()) + BOOST_PROCESS_THROW(std::runtime_error( + "Environment variable PATH not found")); + } + + typedef boost::tokenizer<boost::char_separator<wchar_t>, + std::wstring::const_iterator, std::wstring> tokenizer; + boost::char_separator<wchar_t> sep(L";"); + tokenizer tok(path, sep); + for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it) + { + boost::filesystem::path p = *it; + p /= filename; + boost::array<std::string, 4> extensions = + { "", ".exe", ".com", ".bat" }; + for (boost::array<std::string, 4>::iterator it2 = extensions.begin(); + it2 != extensions.end(); ++it2) + { + boost::filesystem::path p2 = p; + p2 /= (std::string)*it2; + boost::system::error_code ec; + bool file = boost::filesystem::is_regular_file(p2, ec); + if (!ec && file && + SHGetFileInfoW(p2.c_str(), 0, 0, 0, SHGFI_EXETYPE)) + { + return p2.wstring(); + } + } + } + return L""; +} +#else +inline std::string search_path(const std::string &filename, + std::string path = "") +{ + if (path.empty()) + { + path = ::getenv("PATH"); + if (path.empty()) + BOOST_PROCESS_THROW(std::runtime_error( + "Environment variable PATH not found")); + } + + typedef boost::tokenizer<boost::char_separator<char> > tokenizer; + boost::char_separator<char> sep(";"); + tokenizer tok(path, sep); + for (tokenizer::iterator it = tok.begin(); it != tok.end(); ++it) + { + boost::filesystem::path p = *it; + p /= filename; + boost::array<std::string, 4> extensions = + { "", ".exe", ".com", ".bat" }; + for (boost::array<std::string, 4>::iterator it2 = extensions.begin(); + it2 != extensions.end(); ++it2) + { + boost::filesystem::path p2 = p; + p2 += *it2; + boost::system::error_code ec; + bool file = boost::filesystem::is_regular_file(p2, ec); + if (!ec && file && + SHGetFileInfoA(p2.string().c_str(), 0, 0, 0, SHGFI_EXETYPE)) + { + return p2.string(); + } + } + } + return ""; +} +#endif + +}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/shell_path.hpp b/plugins/New_GPG/src/include/boost/process/windows/shell_path.hpp new file mode 100644 index 0000000000..ace15b96e1 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/shell_path.hpp @@ -0,0 +1,50 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_SHELL_PATH_HPP +#define BOOST_PROCESS_WINDOWS_SHELL_PATH_HPP + +#include <boost/process/config.hpp> +#include <boost/system/error_code.hpp> +#include <boost/filesystem/path.hpp> +#include <Windows.h> + +namespace boost { namespace process { namespace windows { + +inline boost::filesystem::path shell_path() +{ + TCHAR sysdir[MAX_PATH]; + UINT size = ::GetSystemDirectory(sysdir, sizeof(sysdir)); + if (!size) + BOOST_PROCESS_THROW_LAST_SYSTEM_ERROR("GetSystemDirectory() failed"); + boost::filesystem::path p = sysdir; + return p / "cmd.exe"; +} + +inline boost::filesystem::path shell_path(boost::system::error_code &ec) +{ + TCHAR sysdir[MAX_PATH]; + UINT size = ::GetSystemDirectory(sysdir, sizeof(sysdir)); + boost::filesystem::path p; + if (!size) + { + BOOST_PROCESS_RETURN_LAST_SYSTEM_ERROR(ec); + } + else + { + ec.clear(); + p = sysdir; + p /= "cmd.exe"; + } + return p; +} + +}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/terminate.hpp b/plugins/New_GPG/src/include/boost/process/windows/terminate.hpp new file mode 100644 index 0000000000..43afe250a6 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/terminate.hpp @@ -0,0 +1,38 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_TERMINATE_HPP +#define BOOST_PROCESS_WINDOWS_TERMINATE_HPP + +#include <boost/process/config.hpp> +#include <boost/system/error_code.hpp> +#include <cstdlib> +#include <Windows.h> + +namespace boost { namespace process { namespace windows { + +template <class Process> +void terminate(const Process &p) +{ + if (!::TerminateProcess(p.process_handle(), EXIT_FAILURE)) + BOOST_PROCESS_THROW_LAST_SYSTEM_ERROR("TerminateProcess() failed"); +} + +template <class Process> +void terminate(const Process &p, boost::system::error_code &ec) +{ + if (!::TerminateProcess(p.process_handle(), EXIT_FAILURE)) + BOOST_PROCESS_RETURN_LAST_SYSTEM_ERROR(ec); + else + ec.clear(); +} + +}}} + +#endif diff --git a/plugins/New_GPG/src/include/boost/process/windows/wait_for_exit.hpp b/plugins/New_GPG/src/include/boost/process/windows/wait_for_exit.hpp new file mode 100644 index 0000000000..23a8b9a9f1 --- /dev/null +++ b/plugins/New_GPG/src/include/boost/process/windows/wait_for_exit.hpp @@ -0,0 +1,49 @@ +// Copyright (c) 2006, 2007 Julio M. Merino Vidal +// Copyright (c) 2008 Ilya Sokolov, Boris Schaeling +// Copyright (c) 2009 Boris Schaeling +// Copyright (c) 2010 Felipe Tanus, Boris Schaeling +// Copyright (c) 2011, 2012 Jeff Flinn, 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_WINDOWS_WAIT_FOR_EXIT_HPP +#define BOOST_PROCESS_WINDOWS_WAIT_FOR_EXIT_HPP + +#include <boost/process/config.hpp> +#include <boost/system/error_code.hpp> +#include <Windows.h> + +namespace boost { namespace process { namespace windows { + +template <class Process> +inline DWORD wait_for_exit(const Process &p) +{ + if (::WaitForSingleObject(p.process_handle(), INFINITE) == WAIT_FAILED) + BOOST_PROCESS_THROW_LAST_SYSTEM_ERROR("WaitForSingleObject() failed"); + + DWORD exit_code; + if (!::GetExitCodeProcess(p.process_handle(), &exit_code)) + BOOST_PROCESS_THROW_LAST_SYSTEM_ERROR("GetExitCodeProcess() failed"); + + return exit_code; +} + +template <class Process> +inline DWORD wait_for_exit(const Process &p, boost::system::error_code &ec) +{ + DWORD exit_code = 1; + + if (::WaitForSingleObject(p.process_handle(), INFINITE) == WAIT_FAILED) + BOOST_PROCESS_RETURN_LAST_SYSTEM_ERROR(ec); + else if (!::GetExitCodeProcess(p.process_handle(), &exit_code)) + BOOST_PROCESS_RETURN_LAST_SYSTEM_ERROR(ec); + else + ec.clear(); + + return exit_code; +} + +}}} + +#endif diff --git a/plugins/New_GPG/src/include/utf8.h b/plugins/New_GPG/src/include/utf8.h new file mode 100644 index 0000000000..4e4451403f --- /dev/null +++ b/plugins/New_GPG/src/include/utf8.h @@ -0,0 +1,34 @@ +// Copyright 2006 Nemanja Trifunovic
+
+/*
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+
+#ifndef UTF8_FOR_CPP_2675DCD0_9480_4c0c_B92A_CC14C027B731
+#define UTF8_FOR_CPP_2675DCD0_9480_4c0c_B92A_CC14C027B731
+
+#include "utf8/checked.h"
+#include "utf8/unchecked.h"
+
+#endif // header guard
diff --git a/plugins/New_GPG/src/include/utf8/checked.h b/plugins/New_GPG/src/include/utf8/checked.h new file mode 100644 index 0000000000..3b00644444 --- /dev/null +++ b/plugins/New_GPG/src/include/utf8/checked.h @@ -0,0 +1,327 @@ +// Copyright 2006 Nemanja Trifunovic + +/* +Permission is hereby granted, free of charge, to any person or organization +obtaining a copy of the software and accompanying documentation covered by +this license (the "Software") to use, reproduce, display, distribute, +execute, and transmit the Software, and to prepare derivative works of the +Software, and to permit third-parties to whom the Software is furnished to +do so, all subject to the following: + +The copyright notices in the Software and this entire statement, including +the above license grant, this restriction and the following disclaimer, +must be included in all copies of the Software, in whole or in part, and +all derivative works of the Software, unless such copies or derivative +works are solely in the form of machine-executable object code generated by +a source language processor. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT +SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE +FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. +*/ + + +#ifndef UTF8_FOR_CPP_CHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731 +#define UTF8_FOR_CPP_CHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731 + +#include "core.h" +#include <stdexcept> + +namespace utf8 +{ + // Base for the exceptions that may be thrown from the library + class exception : public ::std::exception { + }; + + // Exceptions that may be thrown from the library functions. + class invalid_code_point : public exception { + uint32_t cp; + public: + invalid_code_point(uint32_t cp) : cp(cp) {} + virtual const char* what() const throw() { return "Invalid code point"; } + uint32_t code_point() const {return cp;} + }; + + class invalid_utf8 : public exception { + uint8_t u8; + public: + invalid_utf8 (uint8_t u) : u8(u) {} + virtual const char* what() const throw() { return "Invalid UTF-8"; } + uint8_t utf8_octet() const {return u8;} + }; + + class invalid_utf16 : public exception { + uint16_t u16; + public: + invalid_utf16 (uint16_t u) : u16(u) {} + virtual const char* what() const throw() { return "Invalid UTF-16"; } + uint16_t utf16_word() const {return u16;} + }; + + class not_enough_room : public exception { + public: + virtual const char* what() const throw() { return "Not enough space"; } + }; + + /// The library API - functions intended to be called by the users + + template <typename octet_iterator> + octet_iterator append(uint32_t cp, octet_iterator result) + { + if (!utf8::internal::is_code_point_valid(cp)) + throw invalid_code_point(cp); + + if (cp < 0x80) // one octet + *(result++) = static_cast<uint8_t>(cp); + else if (cp < 0x800) { // two octets + *(result++) = static_cast<uint8_t>((cp >> 6) | 0xc0); + *(result++) = static_cast<uint8_t>((cp & 0x3f) | 0x80); + } + else if (cp < 0x10000) { // three octets + *(result++) = static_cast<uint8_t>((cp >> 12) | 0xe0); + *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f) | 0x80); + *(result++) = static_cast<uint8_t>((cp & 0x3f) | 0x80); + } + else { // four octets + *(result++) = static_cast<uint8_t>((cp >> 18) | 0xf0); + *(result++) = static_cast<uint8_t>(((cp >> 12) & 0x3f) | 0x80); + *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f) | 0x80); + *(result++) = static_cast<uint8_t>((cp & 0x3f) | 0x80); + } + return result; + } + + template <typename octet_iterator, typename output_iterator> + output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out, uint32_t replacement) + { + while (start != end) { + octet_iterator sequence_start = start; + internal::utf_error err_code = utf8::internal::validate_next(start, end); + switch (err_code) { + case internal::UTF8_OK : + for (octet_iterator it = sequence_start; it != start; ++it) + *out++ = *it; + break; + case internal::NOT_ENOUGH_ROOM: + throw not_enough_room(); + case internal::INVALID_LEAD: + utf8::append (replacement, out); + ++start; + break; + case internal::INCOMPLETE_SEQUENCE: + case internal::OVERLONG_SEQUENCE: + case internal::INVALID_CODE_POINT: + utf8::append (replacement, out); + ++start; + // just one replacement mark for the sequence + while (start != end && utf8::internal::is_trail(*start)) + ++start; + break; + } + } + return out; + } + + template <typename octet_iterator, typename output_iterator> + inline output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out) + { + static const uint32_t replacement_marker = utf8::internal::mask16(0xfffd); + return utf8::replace_invalid(start, end, out, replacement_marker); + } + + template <typename octet_iterator> + uint32_t next(octet_iterator& it, octet_iterator end) + { + uint32_t cp = 0; + internal::utf_error err_code = utf8::internal::validate_next(it, end, cp); + switch (err_code) { + case internal::UTF8_OK : + break; + case internal::NOT_ENOUGH_ROOM : + throw not_enough_room(); + case internal::INVALID_LEAD : + case internal::INCOMPLETE_SEQUENCE : + case internal::OVERLONG_SEQUENCE : + throw invalid_utf8(*it); + case internal::INVALID_CODE_POINT : + throw invalid_code_point(cp); + } + return cp; + } + + template <typename octet_iterator> + uint32_t peek_next(octet_iterator it, octet_iterator end) + { + return utf8::next(it, end); + } + + template <typename octet_iterator> + uint32_t prior(octet_iterator& it, octet_iterator start) + { + // can't do much if it == start + if (it == start) + throw not_enough_room(); + + octet_iterator end = it; + // Go back until we hit either a lead octet or start + while (utf8::internal::is_trail(*(--it))) + if (it == start) + throw invalid_utf8(*it); // error - no lead byte in the sequence + return utf8::peek_next(it, end); + } + + /// Deprecated in versions that include "prior" + template <typename octet_iterator> + uint32_t previous(octet_iterator& it, octet_iterator pass_start) + { + octet_iterator end = it; + while (utf8::internal::is_trail(*(--it))) + if (it == pass_start) + throw invalid_utf8(*it); // error - no lead byte in the sequence + octet_iterator temp = it; + return utf8::next(temp, end); + } + + template <typename octet_iterator, typename distance_type> + void advance (octet_iterator& it, distance_type n, octet_iterator end) + { + for (distance_type i = 0; i < n; ++i) + utf8::next(it, end); + } + + template <typename octet_iterator> + typename std::iterator_traits<octet_iterator>::difference_type + distance (octet_iterator first, octet_iterator last) + { + typename std::iterator_traits<octet_iterator>::difference_type dist; + for (dist = 0; first < last; ++dist) + utf8::next(first, last); + return dist; + } + + template <typename u16bit_iterator, typename octet_iterator> + octet_iterator utf16to8 (u16bit_iterator start, u16bit_iterator end, octet_iterator result) + { + while (start != end) { + uint32_t cp = utf8::internal::mask16(*start++); + // Take care of surrogate pairs first + if (utf8::internal::is_lead_surrogate(cp)) { + if (start != end) { + uint32_t trail_surrogate = utf8::internal::mask16(*start++); + if (utf8::internal::is_trail_surrogate(trail_surrogate)) + cp = (cp << 10) + trail_surrogate + internal::SURROGATE_OFFSET; + else + throw invalid_utf16(static_cast<uint16_t>(trail_surrogate)); + } + else + throw invalid_utf16(static_cast<uint16_t>(cp)); + + } + // Lone trail surrogate + else if (utf8::internal::is_trail_surrogate(cp)) + throw invalid_utf16(static_cast<uint16_t>(cp)); + + result = utf8::append(cp, result); + } + return result; + } + + template <typename u16bit_iterator, typename octet_iterator> + u16bit_iterator utf8to16 (octet_iterator start, octet_iterator end, u16bit_iterator result) + { + while (start != end) { + uint32_t cp = utf8::next(start, end); + if (cp > 0xffff) { //make a surrogate pair + *result++ = static_cast<uint16_t>((cp >> 10) + internal::LEAD_OFFSET); + *result++ = static_cast<uint16_t>((cp & 0x3ff) + internal::TRAIL_SURROGATE_MIN); + } + else + *result++ = static_cast<uint16_t>(cp); + } + return result; + } + + template <typename octet_iterator, typename u32bit_iterator> + octet_iterator utf32to8 (u32bit_iterator start, u32bit_iterator end, octet_iterator result) + { + while (start != end) + result = utf8::append(*(start++), result); + + return result; + } + + template <typename octet_iterator, typename u32bit_iterator> + u32bit_iterator utf8to32 (octet_iterator start, octet_iterator end, u32bit_iterator result) + { + while (start != end) + (*result++) = utf8::next(start, end); + + return result; + } + + // The iterator class + template <typename octet_iterator> + class iterator : public std::iterator <std::bidirectional_iterator_tag, uint32_t> { + octet_iterator it; + octet_iterator range_start; + octet_iterator range_end; + public: + iterator () {}; + explicit iterator (const octet_iterator& octet_it, + const octet_iterator& range_start, + const octet_iterator& range_end) : + it(octet_it), range_start(range_start), range_end(range_end) + { + if (it < range_start || it > range_end) + throw std::out_of_range("Invalid utf-8 iterator position"); + } + // the default "big three" are OK + octet_iterator base () const { return it; } + uint32_t operator * () const + { + octet_iterator temp = it; + return utf8::next(temp, range_end); + } + bool operator == (const iterator& rhs) const + { + if (range_start != rhs.range_start || range_end != rhs.range_end) + throw std::logic_error("Comparing utf-8 iterators defined with different ranges"); + return (it == rhs.it); + } + bool operator != (const iterator& rhs) const + { + return !(operator == (rhs)); + } + iterator& operator ++ () + { + utf8::next(it, range_end); + return *this; + } + iterator operator ++ (int) + { + iterator temp = *this; + utf8::next(it, range_end); + return temp; + } + iterator& operator -- () + { + utf8::prior(it, range_start); + return *this; + } + iterator operator -- (int) + { + iterator temp = *this; + utf8::prior(it, range_start); + return temp; + } + }; // class iterator + +} // namespace utf8 + +#endif //header guard + + diff --git a/plugins/New_GPG/src/include/utf8/core.h b/plugins/New_GPG/src/include/utf8/core.h new file mode 100644 index 0000000000..693d388c07 --- /dev/null +++ b/plugins/New_GPG/src/include/utf8/core.h @@ -0,0 +1,329 @@ +// Copyright 2006 Nemanja Trifunovic + +/* +Permission is hereby granted, free of charge, to any person or organization +obtaining a copy of the software and accompanying documentation covered by +this license (the "Software") to use, reproduce, display, distribute, +execute, and transmit the Software, and to prepare derivative works of the +Software, and to permit third-parties to whom the Software is furnished to +do so, all subject to the following: + +The copyright notices in the Software and this entire statement, including +the above license grant, this restriction and the following disclaimer, +must be included in all copies of the Software, in whole or in part, and +all derivative works of the Software, unless such copies or derivative +works are solely in the form of machine-executable object code generated by +a source language processor. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT +SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE +FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. +*/ + + +#ifndef UTF8_FOR_CPP_CORE_H_2675DCD0_9480_4c0c_B92A_CC14C027B731 +#define UTF8_FOR_CPP_CORE_H_2675DCD0_9480_4c0c_B92A_CC14C027B731 + +#include <iterator> + +namespace utf8 +{ + // The typedefs for 8-bit, 16-bit and 32-bit unsigned integers + // You may need to change them to match your system. + // These typedefs have the same names as ones from cstdint, or boost/cstdint + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; + +// Helper code - not intended to be directly called by the library users. May be changed at any time +namespace internal +{ + // Unicode constants + // Leading (high) surrogates: 0xd800 - 0xdbff + // Trailing (low) surrogates: 0xdc00 - 0xdfff + const uint16_t LEAD_SURROGATE_MIN = 0xd800u; + const uint16_t LEAD_SURROGATE_MAX = 0xdbffu; + const uint16_t TRAIL_SURROGATE_MIN = 0xdc00u; + const uint16_t TRAIL_SURROGATE_MAX = 0xdfffu; + const uint16_t LEAD_OFFSET = LEAD_SURROGATE_MIN - (0x10000 >> 10); + const uint32_t SURROGATE_OFFSET = 0x10000u - (LEAD_SURROGATE_MIN << 10) - TRAIL_SURROGATE_MIN; + + // Maximum valid value for a Unicode code point + const uint32_t CODE_POINT_MAX = 0x0010ffffu; + + template<typename octet_type> + inline uint8_t mask8(octet_type oc) + { + return static_cast<uint8_t>(0xff & oc); + } + template<typename u16_type> + inline uint16_t mask16(u16_type oc) + { + return static_cast<uint16_t>(0xffff & oc); + } + template<typename octet_type> + inline bool is_trail(octet_type oc) + { + return ((utf8::internal::mask8(oc) >> 6) == 0x2); + } + + template <typename u16> + inline bool is_lead_surrogate(u16 cp) + { + return (cp >= LEAD_SURROGATE_MIN && cp <= LEAD_SURROGATE_MAX); + } + + template <typename u16> + inline bool is_trail_surrogate(u16 cp) + { + return (cp >= TRAIL_SURROGATE_MIN && cp <= TRAIL_SURROGATE_MAX); + } + + template <typename u16> + inline bool is_surrogate(u16 cp) + { + return (cp >= LEAD_SURROGATE_MIN && cp <= TRAIL_SURROGATE_MAX); + } + + template <typename u32> + inline bool is_code_point_valid(u32 cp) + { + return (cp <= CODE_POINT_MAX && !utf8::internal::is_surrogate(cp)); + } + + template <typename octet_iterator> + inline typename std::iterator_traits<octet_iterator>::difference_type + sequence_length(octet_iterator lead_it) + { + uint8_t lead = utf8::internal::mask8(*lead_it); + if (lead < 0x80) + return 1; + else if ((lead >> 5) == 0x6) + return 2; + else if ((lead >> 4) == 0xe) + return 3; + else if ((lead >> 3) == 0x1e) + return 4; + else + return 0; + } + + template <typename octet_difference_type> + inline bool is_overlong_sequence(uint32_t cp, octet_difference_type length) + { + if (cp < 0x80) { + if (length != 1) + return true; + } + else if (cp < 0x800) { + if (length != 2) + return true; + } + else if (cp < 0x10000) { + if (length != 3) + return true; + } + + return false; + } + + enum utf_error {UTF8_OK, NOT_ENOUGH_ROOM, INVALID_LEAD, INCOMPLETE_SEQUENCE, OVERLONG_SEQUENCE, INVALID_CODE_POINT}; + + /// Helper for get_sequence_x + template <typename octet_iterator> + utf_error increase_safely(octet_iterator& it, octet_iterator end) + { + if (++it == end) + return NOT_ENOUGH_ROOM; + + if (!utf8::internal::is_trail(*it)) + return INCOMPLETE_SEQUENCE; + + return UTF8_OK; + } + + #define UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(IT, END) {utf_error ret = increase_safely(IT, END); if (ret != UTF8_OK) return ret;} + + /// get_sequence_x functions decode utf-8 sequences of the length x + template <typename octet_iterator> + utf_error get_sequence_1(octet_iterator& it, octet_iterator end, uint32_t& code_point) + { + if (it == end) + return NOT_ENOUGH_ROOM; + + code_point = utf8::internal::mask8(*it); + + return UTF8_OK; + } + + template <typename octet_iterator> + utf_error get_sequence_2(octet_iterator& it, octet_iterator end, uint32_t& code_point) + { + if (it == end) + return NOT_ENOUGH_ROOM; + + code_point = utf8::internal::mask8(*it); + + UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end) + + code_point = ((code_point << 6) & 0x7ff) + ((*it) & 0x3f); + + return UTF8_OK; + } + + template <typename octet_iterator> + utf_error get_sequence_3(octet_iterator& it, octet_iterator end, uint32_t& code_point) + { + if (it == end) + return NOT_ENOUGH_ROOM; + + code_point = utf8::internal::mask8(*it); + + UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end) + + code_point = ((code_point << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff); + + UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end) + + code_point += (*it) & 0x3f; + + return UTF8_OK; + } + + template <typename octet_iterator> + utf_error get_sequence_4(octet_iterator& it, octet_iterator end, uint32_t& code_point) + { + if (it == end) + return NOT_ENOUGH_ROOM; + + code_point = utf8::internal::mask8(*it); + + UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end) + + code_point = ((code_point << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff); + + UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end) + + code_point += (utf8::internal::mask8(*it) << 6) & 0xfff; + + UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end) + + code_point += (*it) & 0x3f; + + return UTF8_OK; + } + + #undef UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR + + template <typename octet_iterator> + utf_error validate_next(octet_iterator& it, octet_iterator end, uint32_t& code_point) + { + // Save the original value of it so we can go back in case of failure + // Of course, it does not make much sense with i.e. stream iterators + octet_iterator original_it = it; + + uint32_t cp = 0; + // Determine the sequence length based on the lead octet + typedef typename std::iterator_traits<octet_iterator>::difference_type octet_difference_type; + const octet_difference_type length = utf8::internal::sequence_length(it); + + // Get trail octets and calculate the code point + utf_error err = UTF8_OK; + switch (length) { + case 0: + return INVALID_LEAD; + case 1: + err = utf8::internal::get_sequence_1(it, end, cp); + break; + case 2: + err = utf8::internal::get_sequence_2(it, end, cp); + break; + case 3: + err = utf8::internal::get_sequence_3(it, end, cp); + break; + case 4: + err = utf8::internal::get_sequence_4(it, end, cp); + break; + } + + if (err == UTF8_OK) { + // Decoding succeeded. Now, security checks... + if (utf8::internal::is_code_point_valid(cp)) { + if (!utf8::internal::is_overlong_sequence(cp, length)){ + // Passed! Return here. + code_point = cp; + ++it; + return UTF8_OK; + } + else + err = OVERLONG_SEQUENCE; + } + else + err = INVALID_CODE_POINT; + } + + // Failure branch - restore the original value of the iterator + it = original_it; + return err; + } + + template <typename octet_iterator> + inline utf_error validate_next(octet_iterator& it, octet_iterator end) { + uint32_t ignored; + return utf8::internal::validate_next(it, end, ignored); + } + +} // namespace internal + + /// The library API - functions intended to be called by the users + + // Byte order mark + const uint8_t bom[] = {0xef, 0xbb, 0xbf}; + + template <typename octet_iterator> + octet_iterator find_invalid(octet_iterator start, octet_iterator end) + { + octet_iterator result = start; + while (result != end) { + utf8::internal::utf_error err_code = utf8::internal::validate_next(result, end); + if (err_code != internal::UTF8_OK) + return result; + } + return result; + } + + template <typename octet_iterator> + inline bool is_valid(octet_iterator start, octet_iterator end) + { + return (utf8::find_invalid(start, end) == end); + } + + template <typename octet_iterator> + inline bool starts_with_bom (octet_iterator it, octet_iterator end) + { + return ( + ((it != end) && (utf8::internal::mask8(*it++)) == bom[0]) && + ((it != end) && (utf8::internal::mask8(*it++)) == bom[1]) && + ((it != end) && (utf8::internal::mask8(*it)) == bom[2]) + ); + } + + //Deprecated in release 2.3 + template <typename octet_iterator> + inline bool is_bom (octet_iterator it) + { + return ( + (utf8::internal::mask8(*it++)) == bom[0] && + (utf8::internal::mask8(*it++)) == bom[1] && + (utf8::internal::mask8(*it)) == bom[2] + ); + } +} // namespace utf8 + +#endif // header guard + + diff --git a/plugins/New_GPG/src/include/utf8/unchecked.h b/plugins/New_GPG/src/include/utf8/unchecked.h new file mode 100644 index 0000000000..b4547fad94 --- /dev/null +++ b/plugins/New_GPG/src/include/utf8/unchecked.h @@ -0,0 +1,228 @@ +// Copyright 2006 Nemanja Trifunovic + +/* +Permission is hereby granted, free of charge, to any person or organization +obtaining a copy of the software and accompanying documentation covered by +this license (the "Software") to use, reproduce, display, distribute, +execute, and transmit the Software, and to prepare derivative works of the +Software, and to permit third-parties to whom the Software is furnished to +do so, all subject to the following: + +The copyright notices in the Software and this entire statement, including +the above license grant, this restriction and the following disclaimer, +must be included in all copies of the Software, in whole or in part, and +all derivative works of the Software, unless such copies or derivative +works are solely in the form of machine-executable object code generated by +a source language processor. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT +SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE +FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. +*/ + + +#ifndef UTF8_FOR_CPP_UNCHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731 +#define UTF8_FOR_CPP_UNCHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731 + +#include "core.h" + +namespace utf8 +{ + namespace unchecked + { + template <typename octet_iterator> + octet_iterator append(uint32_t cp, octet_iterator result) + { + if (cp < 0x80) // one octet + *(result++) = static_cast<uint8_t>(cp); + else if (cp < 0x800) { // two octets + *(result++) = static_cast<uint8_t>((cp >> 6) | 0xc0); + *(result++) = static_cast<uint8_t>((cp & 0x3f) | 0x80); + } + else if (cp < 0x10000) { // three octets + *(result++) = static_cast<uint8_t>((cp >> 12) | 0xe0); + *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f) | 0x80); + *(result++) = static_cast<uint8_t>((cp & 0x3f) | 0x80); + } + else { // four octets + *(result++) = static_cast<uint8_t>((cp >> 18) | 0xf0); + *(result++) = static_cast<uint8_t>(((cp >> 12) & 0x3f)| 0x80); + *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f) | 0x80); + *(result++) = static_cast<uint8_t>((cp & 0x3f) | 0x80); + } + return result; + } + + template <typename octet_iterator> + uint32_t next(octet_iterator& it) + { + uint32_t cp = utf8::internal::mask8(*it); + typename std::iterator_traits<octet_iterator>::difference_type length = utf8::internal::sequence_length(it); + switch (length) { + case 1: + break; + case 2: + it++; + cp = ((cp << 6) & 0x7ff) + ((*it) & 0x3f); + break; + case 3: + ++it; + cp = ((cp << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff); + ++it; + cp += (*it) & 0x3f; + break; + case 4: + ++it; + cp = ((cp << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff); + ++it; + cp += (utf8::internal::mask8(*it) << 6) & 0xfff; + ++it; + cp += (*it) & 0x3f; + break; + } + ++it; + return cp; + } + + template <typename octet_iterator> + uint32_t peek_next(octet_iterator it) + { + return utf8::unchecked::next(it); + } + + template <typename octet_iterator> + uint32_t prior(octet_iterator& it) + { + while (utf8::internal::is_trail(*(--it))) ; + octet_iterator temp = it; + return utf8::unchecked::next(temp); + } + + // Deprecated in versions that include prior, but only for the sake of consistency (see utf8::previous) + template <typename octet_iterator> + inline uint32_t previous(octet_iterator& it) + { + return utf8::unchecked::prior(it); + } + + template <typename octet_iterator, typename distance_type> + void advance (octet_iterator& it, distance_type n) + { + for (distance_type i = 0; i < n; ++i) + utf8::unchecked::next(it); + } + + template <typename octet_iterator> + typename std::iterator_traits<octet_iterator>::difference_type + distance (octet_iterator first, octet_iterator last) + { + typename std::iterator_traits<octet_iterator>::difference_type dist; + for (dist = 0; first < last; ++dist) + utf8::unchecked::next(first); + return dist; + } + + template <typename u16bit_iterator, typename octet_iterator> + octet_iterator utf16to8 (u16bit_iterator start, u16bit_iterator end, octet_iterator result) + { + while (start != end) { + uint32_t cp = utf8::internal::mask16(*start++); + // Take care of surrogate pairs first + if (utf8::internal::is_lead_surrogate(cp)) { + uint32_t trail_surrogate = utf8::internal::mask16(*start++); + cp = (cp << 10) + trail_surrogate + internal::SURROGATE_OFFSET; + } + result = utf8::unchecked::append(cp, result); + } + return result; + } + + template <typename u16bit_iterator, typename octet_iterator> + u16bit_iterator utf8to16 (octet_iterator start, octet_iterator end, u16bit_iterator result) + { + while (start < end) { + uint32_t cp = utf8::unchecked::next(start); + if (cp > 0xffff) { //make a surrogate pair + *result++ = static_cast<uint16_t>((cp >> 10) + internal::LEAD_OFFSET); + *result++ = static_cast<uint16_t>((cp & 0x3ff) + internal::TRAIL_SURROGATE_MIN); + } + else + *result++ = static_cast<uint16_t>(cp); + } + return result; + } + + template <typename octet_iterator, typename u32bit_iterator> + octet_iterator utf32to8 (u32bit_iterator start, u32bit_iterator end, octet_iterator result) + { + while (start != end) + result = utf8::unchecked::append(*(start++), result); + + return result; + } + + template <typename octet_iterator, typename u32bit_iterator> + u32bit_iterator utf8to32 (octet_iterator start, octet_iterator end, u32bit_iterator result) + { + while (start < end) + (*result++) = utf8::unchecked::next(start); + + return result; + } + + // The iterator class + template <typename octet_iterator> + class iterator : public std::iterator <std::bidirectional_iterator_tag, uint32_t> { + octet_iterator it; + public: + iterator () {}; + explicit iterator (const octet_iterator& octet_it): it(octet_it) {} + // the default "big three" are OK + octet_iterator base () const { return it; } + uint32_t operator * () const + { + octet_iterator temp = it; + return utf8::unchecked::next(temp); + } + bool operator == (const iterator& rhs) const + { + return (it == rhs.it); + } + bool operator != (const iterator& rhs) const + { + return !(operator == (rhs)); + } + iterator& operator ++ () + { + ::std::advance(it, utf8::internal::sequence_length(it)); + return *this; + } + iterator operator ++ (int) + { + iterator temp = *this; + ::std::advance(it, utf8::internal::sequence_length(it)); + return temp; + } + iterator& operator -- () + { + utf8::unchecked::prior(it); + return *this; + } + iterator operator -- (int) + { + iterator temp = *this; + utf8::unchecked::prior(it); + return temp; + } + }; // class iterator + + } // namespace utf8::unchecked +} // namespace utf8 + + +#endif // header guard + |