passenger 5.1.12 → 5.2.0

data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/impl/error.ipp

@@ -0,0 +1,102 @@
+//
+// ssl/impl/error.ipp
+// ~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// 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_ASIO_SSL_IMPL_ERROR_IPP
+#define BOOST_ASIO_SSL_IMPL_ERROR_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/ssl/error.hpp>
+#include <boost/asio/ssl/detail/openssl_init.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace error {
+namespace detail {
+
+class ssl_category : public boost::system::error_category
+{
+public:
+  const char* name() const BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT
+  {
+    return "asio.ssl";
+  }
+
+  std::string message(int value) const
+  {
+    const char* s = ::ERR_reason_error_string(value);
+    return s ? s : "asio.ssl error";
+  }
+};
+
+} // namespace detail
+
+const boost::system::error_category& get_ssl_category()
+{
+  static detail::ssl_category instance;
+  return instance;
+}
+
+} // namespace error
+namespace ssl {
+namespace error {
+
+#if (OPENSSL_VERSION_NUMBER < 0x10100000L) && !defined(OPENSSL_IS_BORINGSSL)
+
+const boost::system::error_category& get_stream_category()
+{
+  return boost::asio::error::get_ssl_category();
+}
+
+#else
+
+namespace detail {
+
+class stream_category : public boost::system::error_category
+{
+public:
+  const char* name() const BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT
+  {
+    return "asio.ssl.stream";
+  }
+
+  std::string message(int value) const
+  {
+    switch (value)
+    {
+    case stream_truncated: return "stream truncated";
+    default: return "asio.ssl.stream error";
+    }
+  }
+};
+
+} // namespace detail
+
+const boost::system::error_category& get_stream_category()
+{
+  static detail::stream_category instance;
+  return instance;
+}
+
+#endif
+
+} // namespace error
+} // namespace ssl
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_SSL_IMPL_ERROR_IPP

data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/impl/rfc2818_verification.ipp

@@ -0,0 +1,168 @@
+//
+// ssl/impl/rfc2818_verification.ipp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// 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_ASIO_SSL_IMPL_RFC2818_VERIFICATION_IPP
+#define BOOST_ASIO_SSL_IMPL_RFC2818_VERIFICATION_IPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+
+#if !defined(BOOST_ASIO_ENABLE_OLD_SSL)
+# include <cctype>
+# include <cstring>
+# include <boost/asio/ip/address.hpp>
+# include <boost/asio/ssl/rfc2818_verification.hpp>
+# include <boost/asio/ssl/detail/openssl_types.hpp>
+#endif // !defined(BOOST_ASIO_ENABLE_OLD_SSL)
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ssl {
+
+#if !defined(BOOST_ASIO_ENABLE_OLD_SSL)
+
+bool rfc2818_verification::operator()(
+    bool preverified, verify_context& ctx) const
+{
+  using namespace std; // For memcmp.
+
+  // Don't bother looking at certificates that have failed pre-verification.
+  if (!preverified)
+    return false;
+
+  // We're only interested in checking the certificate at the end of the chain.
+  int depth = X509_STORE_CTX_get_error_depth(ctx.native_handle());
+  if (depth > 0)
+    return true;
+
+  // Try converting the host name to an address. If it is an address then we
+  // need to look for an IP address in the certificate rather than a host name.
+  boost::system::error_code ec;
+  ip::address address = ip::address::from_string(host_, ec);
+  bool is_address = !ec;
+
+  X509* cert = X509_STORE_CTX_get_current_cert(ctx.native_handle());
+
+  // Go through the alternate names in the certificate looking for matching DNS
+  // or IP address entries.
+  GENERAL_NAMES* gens = static_cast<GENERAL_NAMES*>(
+      X509_get_ext_d2i(cert, NID_subject_alt_name, 0, 0));
+  for (int i = 0; i < sk_GENERAL_NAME_num(gens); ++i)
+  {
+    GENERAL_NAME* gen = sk_GENERAL_NAME_value(gens, i);
+    if (gen->type == GEN_DNS && !is_address)
+    {
+      ASN1_IA5STRING* domain = gen->d.dNSName;
+      if (domain->type == V_ASN1_IA5STRING && domain->data && domain->length)
+      {
+        const char* pattern = reinterpret_cast<const char*>(domain->data);
+        std::size_t pattern_length = domain->length;
+        if (match_pattern(pattern, pattern_length, host_.c_str()))
+        {
+          GENERAL_NAMES_free(gens);
+          return true;
+        }
+      }
+    }
+    else if (gen->type == GEN_IPADD && is_address)
+    {
+      ASN1_OCTET_STRING* ip_address = gen->d.iPAddress;
+      if (ip_address->type == V_ASN1_OCTET_STRING && ip_address->data)
+      {
+        if (address.is_v4() && ip_address->length == 4)
+        {
+          ip::address_v4::bytes_type bytes = address.to_v4().to_bytes();
+          if (memcmp(bytes.data(), ip_address->data, 4) == 0)
+          {
+            GENERAL_NAMES_free(gens);
+            return true;
+          }
+        }
+        else if (address.is_v6() && ip_address->length == 16)
+        {
+          ip::address_v6::bytes_type bytes = address.to_v6().to_bytes();
+          if (memcmp(bytes.data(), ip_address->data, 16) == 0)
+          {
+            GENERAL_NAMES_free(gens);
+            return true;
+          }
+        }
+      }
+    }
+  }
+  GENERAL_NAMES_free(gens);
+
+  // No match in the alternate names, so try the common names. We should only
+  // use the "most specific" common name, which is the last one in the list.
+  X509_NAME* name = X509_get_subject_name(cert);
+  int i = -1;
+  ASN1_STRING* common_name = 0;
+  while ((i = X509_NAME_get_index_by_NID(name, NID_commonName, i)) >= 0)
+  {
+    X509_NAME_ENTRY* name_entry = X509_NAME_get_entry(name, i);
+    common_name = X509_NAME_ENTRY_get_data(name_entry);
+  }
+  if (common_name && common_name->data && common_name->length)
+  {
+    const char* pattern = reinterpret_cast<const char*>(common_name->data);
+    std::size_t pattern_length = common_name->length;
+    if (match_pattern(pattern, pattern_length, host_.c_str()))
+      return true;
+  }
+
+  return false;
+}
+
+bool rfc2818_verification::match_pattern(const char* pattern,
+    std::size_t pattern_length, const char* host)
+{
+  using namespace std; // For tolower.
+
+  const char* p = pattern;
+  const char* p_end = p + pattern_length;
+  const char* h = host;
+
+  while (p != p_end && *h)
+  {
+    if (*p == '*')
+    {
+      ++p;
+      while (*h && *h != '.')
+        if (match_pattern(p, p_end - p, h++))
+          return true;
+    }
+    else if (tolower(*p) == tolower(*h))
+    {
+      ++p;
+      ++h;
+    }
+    else
+    {
+      return false;
+    }
+  }
+
+  return p == p_end && !*h;
+}
+
+#endif // !defined(BOOST_ASIO_ENABLE_OLD_SSL)
+
+} // namespace ssl
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_SSL_IMPL_RFC2818_VERIFICATION_IPP

data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/impl/src.hpp

@@ -0,0 +1,28 @@
+//
+// impl/ssl/src.hpp
+// ~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// 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_ASIO_SSL_IMPL_SRC_HPP
+#define BOOST_ASIO_SSL_IMPL_SRC_HPP
+
+#define BOOST_ASIO_SOURCE
+
+#include <boost/asio/detail/config.hpp>
+
+#if defined(BOOST_ASIO_HEADER_ONLY)
+# error Do not compile Asio library source with BOOST_ASIO_HEADER_ONLY defined
+#endif
+
+#include <boost/asio/ssl/impl/context.ipp>
+#include <boost/asio/ssl/impl/error.ipp>
+#include <boost/asio/ssl/detail/impl/engine.ipp>
+#include <boost/asio/ssl/detail/impl/openssl_init.ipp>
+#include <boost/asio/ssl/impl/rfc2818_verification.ipp>
+
+#endif // BOOST_ASIO_SSL_IMPL_SRC_HPP

data/src/cxx_supportlib/vendor-modified/boost/asio/ssl/old/basic_context.hpp

@@ -0,0 +1,436 @@
+//
+// ssl/old/basic_context.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
+// Copyright (c) 2005-2017 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+//
+// 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_ASIO_SSL_OLD_BASIC_CONTEXT_HPP
+#define BOOST_ASIO_SSL_OLD_BASIC_CONTEXT_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include <boost/asio/detail/config.hpp>
+#include <string>
+#include <boost/noncopyable.hpp>
+#include <boost/asio/detail/throw_error.hpp>
+#include <boost/asio/error.hpp>
+#include <boost/asio/io_service.hpp>
+#include <boost/asio/ssl/context_base.hpp>
+
+#include <boost/asio/detail/push_options.hpp>
+
+namespace boost {
+namespace asio {
+namespace ssl {
+namespace old {
+
+/// SSL context.
+template <typename Service>
+class basic_context
+  : public context_base,
+    private boost::noncopyable
+{
+public:
+  /// The type of the service that will be used to provide context operations.
+  typedef Service service_type;
+
+  /// The native implementation type of the SSL context.
+  typedef typename service_type::impl_type impl_type;
+
+  /// Constructor.
+  basic_context(boost::asio::io_service& io_service, method m)
+    : service_(boost::asio::use_service<Service>(io_service)),
+      impl_(service_.null())
+  {
+    service_.create(impl_, m);
+  }
+
+  /// Destructor.
+  ~basic_context()
+  {
+    service_.destroy(impl_);
+  }
+
+  /// Get the underlying implementation in the native type.
+  /**
+   * This function may be used to obtain the underlying implementation of the
+   * context. This is intended to allow access to context functionality that is
+   * not otherwise provided.
+   */
+  impl_type impl()
+  {
+    return impl_;
+  }
+
+  /// Set options on the context.
+  /**
+   * This function may be used to configure the SSL options used by the context.
+   *
+   * @param o A bitmask of options. The available option values are defined in
+   * the context_base class. The options are bitwise-ored with any existing
+   * value for the options.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void set_options(options o)
+  {
+    boost::system::error_code ec;
+    service_.set_options(impl_, o, ec);
+    boost::asio::detail::throw_error(ec);
+  }
+
+  /// Set options on the context.
+  /**
+   * This function may be used to configure the SSL options used by the context.
+   *
+   * @param o A bitmask of options. The available option values are defined in
+   * the context_base class. The options are bitwise-ored with any existing
+   * value for the options.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  boost::system::error_code set_options(options o,
+      boost::system::error_code& ec)
+  {
+    return service_.set_options(impl_, o, ec);
+  }
+
+  /// Set the peer verification mode.
+  /**
+   * This function may be used to configure the peer verification mode used by
+   * the context.
+   *
+   * @param v A bitmask of peer verification modes. The available verify_mode
+   * values are defined in the context_base class.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void set_verify_mode(verify_mode v)
+  {
+    boost::system::error_code ec;
+    service_.set_verify_mode(impl_, v, ec);
+    boost::asio::detail::throw_error(ec);
+  }
+
+  /// Set the peer verification mode.
+  /**
+   * This function may be used to configure the peer verification mode used by
+   * the context.
+   *
+   * @param v A bitmask of peer verification modes. The available verify_mode
+   * values are defined in the context_base class.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  boost::system::error_code set_verify_mode(verify_mode v,
+      boost::system::error_code& ec)
+  {
+    return service_.set_verify_mode(impl_, v, ec);
+  }
+
+  /// Load a certification authority file for performing verification.
+  /**
+   * This function is used to load one or more trusted certification authorities
+   * from a file.
+   *
+   * @param filename The name of a file containing certification authority
+   * certificates in PEM format.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void load_verify_file(const std::string& filename)
+  {
+    boost::system::error_code ec;
+    service_.load_verify_file(impl_, filename, ec);
+    boost::asio::detail::throw_error(ec);
+  }
+
+  /// Load a certification authority file for performing verification.
+  /**
+   * This function is used to load the certificates for one or more trusted
+   * certification authorities from a file.
+   *
+   * @param filename The name of a file containing certification authority
+   * certificates in PEM format.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  boost::system::error_code load_verify_file(const std::string& filename,
+      boost::system::error_code& ec)
+  {
+    return service_.load_verify_file(impl_, filename, ec);
+  }
+
+  /// Add a directory containing certificate authority files to be used for
+  /// performing verification.
+  /**
+   * This function is used to specify the name of a directory containing
+   * certification authority certificates. Each file in the directory must
+   * contain a single certificate. The files must be named using the subject
+   * name's hash and an extension of ".0".
+   *
+   * @param path The name of a directory containing the certificates.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void add_verify_path(const std::string& path)
+  {
+    boost::system::error_code ec;
+    service_.add_verify_path(impl_, path, ec);
+    boost::asio::detail::throw_error(ec);
+  }
+
+  /// Add a directory containing certificate authority files to be used for
+  /// performing verification.
+  /**
+   * This function is used to specify the name of a directory containing
+   * certification authority certificates. Each file in the directory must
+   * contain a single certificate. The files must be named using the subject
+   * name's hash and an extension of ".0".
+   *
+   * @param path The name of a directory containing the certificates.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  boost::system::error_code add_verify_path(const std::string& path,
+      boost::system::error_code& ec)
+  {
+    return service_.add_verify_path(impl_, path, ec);
+  }
+
+  /// Use a certificate from a file.
+  /**
+   * This function is used to load a certificate into the context from a file.
+   *
+   * @param filename The name of the file containing the certificate.
+   *
+   * @param format The file format (ASN.1 or PEM).
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void use_certificate_file(const std::string& filename, file_format format)
+  {
+    boost::system::error_code ec;
+    service_.use_certificate_file(impl_, filename, format, ec);
+    boost::asio::detail::throw_error(ec);
+  }
+
+  /// Use a certificate from a file.
+  /**
+   * This function is used to load a certificate into the context from a file.
+   *
+   * @param filename The name of the file containing the certificate.
+   *
+   * @param format The file format (ASN.1 or PEM).
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  boost::system::error_code use_certificate_file(const std::string& filename,
+      file_format format, boost::system::error_code& ec)
+  {
+    return service_.use_certificate_file(impl_, filename, format, ec);
+  }
+
+  /// Use a certificate chain from a file.
+  /**
+   * This function is used to load a certificate chain into the context from a
+   * file.
+   *
+   * @param filename The name of the file containing the certificate. The file
+   * must use the PEM format.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void use_certificate_chain_file(const std::string& filename)
+  {
+    boost::system::error_code ec;
+    service_.use_certificate_chain_file(impl_, filename, ec);
+    boost::asio::detail::throw_error(ec);
+  }
+
+  /// Use a certificate chain from a file.
+  /**
+   * This function is used to load a certificate chain into the context from a
+   * file.
+   *
+   * @param filename The name of the file containing the certificate. The file
+   * must use the PEM format.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  boost::system::error_code use_certificate_chain_file(
+      const std::string& filename, boost::system::error_code& ec)
+  {
+    return service_.use_certificate_chain_file(impl_, filename, ec);
+  }
+
+  /// Use a private key from a file.
+  /**
+   * This function is used to load a private key into the context from a file.
+   *
+   * @param filename The name of the file containing the private key.
+   *
+   * @param format The file format (ASN.1 or PEM).
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void use_private_key_file(const std::string& filename, file_format format)
+  {
+    boost::system::error_code ec;
+    service_.use_private_key_file(impl_, filename, format, ec);
+    boost::asio::detail::throw_error(ec);
+  }
+
+  /// Use a private key from a file.
+  /**
+   * This function is used to load a private key into the context from a file.
+   *
+   * @param filename The name of the file containing the private key.
+   *
+   * @param format The file format (ASN.1 or PEM).
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  boost::system::error_code use_private_key_file(const std::string& filename,
+      file_format format, boost::system::error_code& ec)
+  {
+    return service_.use_private_key_file(impl_, filename, format, ec);
+  }
+
+  /// Use an RSA private key from a file.
+  /**
+   * This function is used to load an RSA private key into the context from a
+   * file.
+   *
+   * @param filename The name of the file containing the RSA private key.
+   *
+   * @param format The file format (ASN.1 or PEM).
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void use_rsa_private_key_file(const std::string& filename, file_format format)
+  {
+    boost::system::error_code ec;
+    service_.use_rsa_private_key_file(impl_, filename, format, ec);
+    boost::asio::detail::throw_error(ec);
+  }
+
+  /// Use an RSA private key from a file.
+  /**
+   * This function is used to load an RSA private key into the context from a
+   * file.
+   *
+   * @param filename The name of the file containing the RSA private key.
+   *
+   * @param format The file format (ASN.1 or PEM).
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  boost::system::error_code use_rsa_private_key_file(
+      const std::string& filename, file_format format,
+      boost::system::error_code& ec)
+  {
+    return service_.use_rsa_private_key_file(impl_, filename, format, ec);
+  }
+
+  /// Use the specified file to obtain the temporary Diffie-Hellman parameters.
+  /**
+   * This function is used to load Diffie-Hellman parameters into the context
+   * from a file.
+   *
+   * @param filename The name of the file containing the Diffie-Hellman
+   * parameters. The file must use the PEM format.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  void use_tmp_dh_file(const std::string& filename)
+  {
+    boost::system::error_code ec;
+    service_.use_tmp_dh_file(impl_, filename, ec);
+    boost::asio::detail::throw_error(ec);
+  }
+
+  /// Use the specified file to obtain the temporary Diffie-Hellman parameters.
+  /**
+   * This function is used to load Diffie-Hellman parameters into the context
+   * from a file.
+   *
+   * @param filename The name of the file containing the Diffie-Hellman
+   * parameters. The file must use the PEM format.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  boost::system::error_code use_tmp_dh_file(const std::string& filename,
+      boost::system::error_code& ec)
+  {
+    return service_.use_tmp_dh_file(impl_, filename, ec);
+  }
+
+  /// Set the password callback.
+  /**
+   * This function is used to specify a callback function to obtain password
+   * information about an encrypted key in PEM format.
+   *
+   * @param callback The function object to be used for obtaining the password.
+   * The function signature of the handler must be:
+   * @code std::string password_callback(
+   *   std::size_t max_length,  // The maximum size for a password.
+   *   password_purpose purpose // Whether password is for reading or writing.
+   * ); @endcode
+   * The return value of the callback is a string containing the password.
+   *
+   * @throws boost::system::system_error Thrown on failure.
+   */
+  template <typename PasswordCallback>
+  void set_password_callback(PasswordCallback callback)
+  {
+    boost::system::error_code ec;
+    service_.set_password_callback(impl_, callback, ec);
+    boost::asio::detail::throw_error(ec);
+  }
+
+  /// Set the password callback.
+  /**
+   * This function is used to specify a callback function to obtain password
+   * information about an encrypted key in PEM format.
+   *
+   * @param callback The function object to be used for obtaining the password.
+   * The function signature of the handler must be:
+   * @code std::string password_callback(
+   *   std::size_t max_length,  // The maximum size for a password.
+   *   password_purpose purpose // Whether password is for reading or writing.
+   * ); @endcode
+   * The return value of the callback is a string containing the password.
+   *
+   * @param ec Set to indicate what error occurred, if any.
+   */
+  template <typename PasswordCallback>
+  boost::system::error_code set_password_callback(PasswordCallback callback,
+      boost::system::error_code& ec)
+  {
+    return service_.set_password_callback(impl_, callback, ec);
+  }
+
+private:
+  /// The backend service implementation.
+  service_type& service_;
+
+  /// The underlying native implementation.
+  impl_type impl_;
+};
+
+} // namespace old
+} // namespace ssl
+} // namespace asio
+} // namespace boost
+
+#include <boost/asio/detail/pop_options.hpp>
+
+#endif // BOOST_ASIO_SSL_OLD_BASIC_CONTEXT_HPP