- New_GPG: reinstated

git-svn-id: http://svn.miranda-ng.org/main/trunk@4716 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c

44 files changed, 2858 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