passenger 6.0.2 → 6.0.3

data/src/cxx_supportlib/vendor-modified/boost/asio/read_until.hpp

@@ -68,9 +68,10 @@ struct is_match_condition
 /**
  * @defgroup read_until boost::asio::read_until
  *
- * @brief Read data into a dynamic buffer sequence, or into a streambuf, until
- * it contains a delimiter, matches a regular expression, or a function object
- * indicates a match.
+ * @brief The @c read_until function is a composed operation that reads data
+ * into a dynamic buffer sequence, or into a streambuf, until it contains a
+ * delimiter, matches a regular expression, or a function object indicates a
+ * match.
  */
 /*@{*/
 
@@ -986,9 +987,10 @@ std::size_t read_until(SyncReadStream& s,
 /**
  * @defgroup async_read_until boost::asio::async_read_until
  *
- * @brief Start an asynchronous operation to read data into a dynamic buffer
- * sequence, or into a streambuf, until it contains a delimiter, matches a
- * regular expression, or a function object indicates a match.
+ * @brief The @c async_read_until function is a composed asynchronous operation
+ * that reads data into a dynamic buffer sequence, or into a streambuf, until
+ * it contains a delimiter, matches a regular expression, or a function object
+ * indicates a match.
  */
 /*@{*/
 

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

@@ -86,6 +86,15 @@ public:
     /// TLS version 1.2 server.
     tlsv12_server,
 
+    /// Generic TLS version 1.3.
+    tlsv13,
+
+    /// TLS version 1.3 client.
+    tlsv13_client,
+
+    /// TLS version 1.3 server.
+    tlsv13_server,
+
     /// Generic TLS.
     tls,
 
@@ -121,6 +130,9 @@ public:
   /// Disable TLS v1.2.
   static const long no_tlsv1_2 = implementation_defined;
 
+  /// Disable TLS v1.3.
+  static const long no_tlsv1_3 = implementation_defined;
+
   /// Disable compression. Compression is disabled by default.
   static const long no_compression = implementation_defined;
 #else
@@ -139,6 +151,11 @@ public:
 # else // defined(SSL_OP_NO_TLSv1_2)
   BOOST_ASIO_STATIC_CONSTANT(long, no_tlsv1_2 = 0x08000000L);
 # endif // defined(SSL_OP_NO_TLSv1_2)
+# if defined(SSL_OP_NO_TLSv1_3)
+  BOOST_ASIO_STATIC_CONSTANT(long, no_tlsv1_3 = SSL_OP_NO_TLSv1_3);
+# else // defined(SSL_OP_NO_TLSv1_3)
+  BOOST_ASIO_STATIC_CONSTANT(long, no_tlsv1_3 = 0x20000000L);
+# endif // defined(SSL_OP_NO_TLSv1_3)
 # if defined(SSL_OP_NO_COMPRESSION)
   BOOST_ASIO_STATIC_CONSTANT(long, no_compression = SSL_OP_NO_COMPRESSION);
 # else // defined(SSL_OP_NO_COMPRESSION)

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

@@ -158,7 +158,7 @@ context::context(context::method m)
       SSL_CTX_set_max_proto_version(handle_, TLS1_VERSION);
     }
     break;
-#else // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
+#elif defined(SSL_TXT_TLSV1)
   case context::tlsv1:
     handle_ = ::SSL_CTX_new(::TLSv1_method());
     break;
@@ -168,7 +168,14 @@ context::context(context::method m)
   case context::tlsv1_server:
     handle_ = ::SSL_CTX_new(::TLSv1_server_method());
     break;
-#endif // (OPENSSL_VERSION_NUMBER >= 0x10100000L)
+#else // defined(SSL_TXT_TLSV1)
+  case context::tlsv1:
+  case context::tlsv1_client:
+  case context::tlsv1_server:
+    boost::asio::detail::throw_error(
+        boost::asio::error::invalid_argument, "context");
+    break;
+#endif // defined(SSL_TXT_TLSV1)
 
     // TLS v1.1.
 #if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)
@@ -241,7 +248,7 @@ context::context(context::method m)
       SSL_CTX_set_max_proto_version(handle_, TLS1_2_VERSION);
     }
     break;
-#elif defined(SSL_TXT_TLSV1_1)
+#elif defined(SSL_TXT_TLSV1_2)
   case context::tlsv12:
     handle_ = ::SSL_CTX_new(::TLSv1_2_method());
     break;
@@ -251,14 +258,52 @@ context::context(context::method m)
   case context::tlsv12_server:
     handle_ = ::SSL_CTX_new(::TLSv1_2_server_method());
     break;
-#else // defined(SSL_TXT_TLSV1_1)
+#else // defined(SSL_TXT_TLSV1_2)
   case context::tlsv12:
   case context::tlsv12_client:
   case context::tlsv12_server:
     boost::asio::detail::throw_error(
         boost::asio::error::invalid_argument, "context");
     break;
-#endif // defined(SSL_TXT_TLSV1_1)
+#endif // defined(SSL_TXT_TLSV1_2)
+
+    // TLS v1.3.
+#if (OPENSSL_VERSION_NUMBER >= 0x10101000L) \
+    && !defined(LIBRESSL_VERSION_NUMBER)
+  case context::tlsv13:
+    handle_ = ::SSL_CTX_new(::TLS_method());
+    if (handle_)
+    {
+      SSL_CTX_set_min_proto_version(handle_, TLS1_3_VERSION);
+      SSL_CTX_set_max_proto_version(handle_, TLS1_3_VERSION);
+    }
+    break;
+  case context::tlsv13_client:
+    handle_ = ::SSL_CTX_new(::TLS_client_method());
+    if (handle_)
+    {
+      SSL_CTX_set_min_proto_version(handle_, TLS1_3_VERSION);
+      SSL_CTX_set_max_proto_version(handle_, TLS1_3_VERSION);
+    }
+    break;
+  case context::tlsv13_server:
+    handle_ = ::SSL_CTX_new(::TLS_server_method());
+    if (handle_)
+    {
+      SSL_CTX_set_min_proto_version(handle_, TLS1_3_VERSION);
+      SSL_CTX_set_max_proto_version(handle_, TLS1_3_VERSION);
+    }
+    break;
+#else // (OPENSSL_VERSION_NUMBER >= 0x10101000L)
+      //   && !defined(LIBRESSL_VERSION_NUMBER)
+  case context::tlsv13:
+  case context::tlsv13_client:
+  case context::tlsv13_server:
+    boost::asio::detail::throw_error(
+        boost::asio::error::invalid_argument, "context");
+    break;
+#endif // (OPENSSL_VERSION_NUMBER >= 0x10101000L)
+       //   && !defined(LIBRESSL_VERSION_NUMBER)
 
     // Any supported SSL/TLS version.
   case context::sslv23:

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

@@ -635,7 +635,8 @@ public:
    *
    * @note The async_write_some operation may not transmit all of the data to
    * the peer. Consider using the @ref async_write function if you need to
-   * ensure that all data is written before the blocking operation completes.
+   * ensure that all data is written before the asynchronous operation
+   * completes.
    */
   template <typename ConstBufferSequence, typename WriteHandler>
   BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler,

data/src/cxx_supportlib/vendor-modified/boost/asio/thread_pool.hpp

@@ -33,7 +33,7 @@ namespace asio {
  *
  * @par Submitting tasks to the pool
  *
- * To submit functions to the io_context, use the @ref boost::asio::dispatch,
+ * To submit functions to the thread_pool, use the @ref boost::asio::dispatch,
  * @ref boost::asio::post or @ref boost::asio::defer free functions.
  *
  * For example:

data/src/cxx_supportlib/vendor-modified/boost/asio/use_future.hpp

@@ -16,8 +16,9 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include <boost/asio/detail/config.hpp>
+#include <boost/asio/detail/future.hpp>
 
-#if defined(BOOST_ASIO_HAS_STD_FUTURE) \
+#if defined(BOOST_ASIO_HAS_STD_FUTURE_CLASS) \
   || defined(GENERATING_DOCUMENTATION)
 
 #include <memory>
@@ -155,7 +156,7 @@ __declspec(selectany) use_future_t<> use_future;
 
 #include <boost/asio/impl/use_future.hpp>
 
-#endif // defined(BOOST_ASIO_HAS_STD_FUTURE)
+#endif // defined(BOOST_ASIO_HAS_STD_FUTURE_CLASS)
        //   || defined(GENERATING_DOCUMENTATION)
 
 #endif // BOOST_ASIO_USE_FUTURE_HPP

data/src/cxx_supportlib/vendor-modified/boost/asio/version.hpp

@@ -18,6 +18,6 @@
 // BOOST_ASIO_VERSION % 100 is the sub-minor version
 // BOOST_ASIO_VERSION / 100 % 1000 is the minor version
 // BOOST_ASIO_VERSION / 100000 is the major version
-#define BOOST_ASIO_VERSION 101201 // 1.12.1
+#define BOOST_ASIO_VERSION 101202 // 1.12.2
 
 #endif // BOOST_ASIO_VERSION_HPP

data/src/cxx_supportlib/vendor-modified/boost/asio/write.hpp

@@ -33,7 +33,8 @@ namespace asio {
 /**
  * @defgroup write boost::asio::write
  *
- * @brief Write a certain amount of data to a stream before returning.
+ * @brief The @c write function is a composed operation that writes a certain
+ * amount of data to a stream before returning.
  */
 /*@{*/
 
@@ -533,8 +534,8 @@ std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b,
 /**
  * @defgroup async_write boost::asio::async_write
  *
- * @brief Start an asynchronous operation to write a certain amount of data to a
- * stream.
+ * @brief The @c async_write function is a composed asynchronous operation that
+ * writes a certain amount of data to a stream before completion.
  */
 /*@{*/
 

data/src/cxx_supportlib/vendor-modified/boost/asio/write_at.hpp

@@ -33,7 +33,8 @@ namespace asio {
 /**
  * @defgroup write_at boost::asio::write_at
  *
- * @brief Write a certain amount of data at a specified offset before returning.
+ * @brief The @c write_at function is a composed operation that writes a
+ * certain amount of data at a specified offset before returning.
  */
 /*@{*/
 
@@ -393,8 +394,9 @@ std::size_t write_at(SyncRandomAccessWriteDevice& d, uint64_t offset,
 /**
  * @defgroup async_write_at boost::asio::async_write_at
  *
- * @brief Start an asynchronous operation to write a certain amount of data at
- * the specified offset.
+ * @brief The @c async_write_at function is a composed asynchronous operation
+ * that writes a certain amount of data at the specified offset before
+ * completion.
  */
 /*@{*/
 

data/src/cxx_supportlib/vendor-modified/boost/atomic/detail/ops_gcc_x86_dcas.hpp

@@ -158,11 +158,13 @@ struct gcc_dcas_x86
         }
         else
         {
-#if defined(__clang__)
-            // Clang cannot allocate eax:edx register pairs but it has sync intrinsics
-            value = __sync_val_compare_and_swap(&storage, (storage_type)0, (storage_type)0);
-#elif defined(BOOST_ATOMIC_DETAIL_X86_NO_ASM_AX_DX_PAIRS)
+            // Note that despite const qualification cmpxchg8b below may issue a store to the storage. The storage value
+            // will not change, but this prevents the storage to reside in read-only memory.
+
+#if defined(BOOST_ATOMIC_DETAIL_X86_NO_ASM_AX_DX_PAIRS)
+
             uint32_t value_bits[2];
+
             // We don't care for comparison result here; the previous value will be stored into value anyway.
             // Also we don't care for ebx and ecx values, they just have to be equal to eax and edx before cmpxchg8b.
             __asm__ __volatile__
@@ -175,7 +177,9 @@ struct gcc_dcas_x86
                 : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory"
             );
             BOOST_ATOMIC_DETAIL_MEMCPY(&value, value_bits, sizeof(value));
+
 #else // defined(BOOST_ATOMIC_DETAIL_X86_NO_ASM_AX_DX_PAIRS)
+
             // We don't care for comparison result here; the previous value will be stored into value anyway.
             // Also we don't care for ebx and ecx values, they just have to be equal to eax and edx before cmpxchg8b.
             __asm__ __volatile__
@@ -187,6 +191,7 @@ struct gcc_dcas_x86
                 : [storage] "m" (storage)
                 : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory"
             );
+
 #endif // defined(BOOST_ATOMIC_DETAIL_X86_NO_ASM_AX_DX_PAIRS)
         }
 
@@ -266,7 +271,7 @@ struct gcc_dcas_x86
         return compare_exchange_strong(storage, expected, desired, success_order, failure_order);
     }
 
-    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
     {
 #if defined(BOOST_ATOMIC_DETAIL_X86_ASM_PRESERVE_EBX)
 #if defined(BOOST_ATOMIC_DETAIL_X86_NO_ASM_AX_DX_PAIRS)
@@ -401,15 +406,11 @@ struct gcc_dcas_x86_64
 
     static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order) BOOST_NOEXCEPT
     {
-#if defined(__clang__)
+        // Note that despite const qualification cmpxchg16b below may issue a store to the storage. The storage value
+        // will not change, but this prevents the storage to reside in read-only memory.
 
-        // Clang cannot allocate rax:rdx register pairs but it has sync intrinsics
-        storage_type value = storage_type();
-        return __sync_val_compare_and_swap(&storage, value, value);
-
-#elif defined(BOOST_ATOMIC_DETAIL_X86_NO_ASM_AX_DX_PAIRS)
+#if defined(BOOST_ATOMIC_DETAIL_X86_NO_ASM_AX_DX_PAIRS)
 
-        // Some compilers can't allocate rax:rdx register pair either and also don't support 128-bit __sync_val_compare_and_swap
         uint64_t value_bits[2];
 
         // We don't care for comparison result here; the previous value will be stored into value anyway.

data/src/cxx_supportlib/vendor-modified/boost/chrono/detail/inlined/mac/chrono.hpp

@@ -40,7 +40,7 @@ system_clock::now(system::error_code & ec)
 {
     timeval tv;
     gettimeofday(&tv, 0);
-    if (!BOOST_CHRONO_IS_THROWS(ec))
+    if (!::boost::chrono::is_throws(ec))
     {
         ec.clear();
     }
@@ -89,7 +89,7 @@ BOOST_CHRONO_STATIC
 steady_clock::rep
 steady_simplified_ec(system::error_code & ec)
 {
-    if (!BOOST_CHRONO_IS_THROWS(ec))
+    if (!::boost::chrono::is_throws(ec))
     {
         ec.clear();
     }
@@ -131,21 +131,21 @@ steady_full_ec(system::error_code & ec)
     const double factor = chrono_detail::compute_steady_factor(err);
     if (err != 0)
     {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
             boost::throw_exception(
                     system::system_error(
                             err,
-                            BOOST_CHRONO_SYSTEM_CATEGORY,
+                            ::boost::system::system_category(),
                             "chrono::steady_clock" ));
         }
         else
         {
-            ec.assign( errno, BOOST_CHRONO_SYSTEM_CATEGORY );
+            ec.assign( errno, ::boost::system::system_category() );
             return steady_clock::rep();
         }
     }
-    if (!BOOST_CHRONO_IS_THROWS(ec))
+    if (!::boost::chrono::is_throws(ec))
     {
         ec.clear();
     }
@@ -217,21 +217,21 @@ steady_clock::now(system::error_code & ec)
     chrono_detail::FP_ec fp = chrono_detail::init_steady_clock_ec(err);
     if ( err != 0  )
     {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
             boost::throw_exception(
                     system::system_error(
                             err,
-                            BOOST_CHRONO_SYSTEM_CATEGORY,
+                            ::boost::system::system_category(),
                             "chrono::steady_clock" ));
         }
         else
         {
-            ec.assign( err, BOOST_CHRONO_SYSTEM_CATEGORY );
+            ec.assign( err, ::boost::system::system_category() );
             return time_point();
         }
     }
-    if (!BOOST_CHRONO_IS_THROWS(ec))
+    if (!::boost::chrono::is_throws(ec))
     {
         ec.clear();
     }

data/src/cxx_supportlib/vendor-modified/boost/chrono/detail/inlined/mac/process_cpu_clocks.hpp

@@ -95,12 +95,12 @@ namespace boost
       clock_t c = ::times(&tm);
       if (c == clock_t(-1)) // error
       {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
-          boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_real_cpu_clock"));
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_real_cpu_clock"));
         } else
         {
-          ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+          ec.assign(errno, ::boost::system::system_category());
           return time_point();
         }
       } else
@@ -108,19 +108,19 @@ namespace boost
         long factor = chrono_detail::tick_factor();
         if (factor != -1)
         {
-          if (!BOOST_CHRONO_IS_THROWS(ec))
+          if (!::boost::chrono::is_throws(ec))
           {
             ec.clear();
           }
           return time_point(nanoseconds(c * factor));
         } else
         {
-          if (BOOST_CHRONO_IS_THROWS(ec))
+          if (::boost::chrono::is_throws(ec))
           {
-            boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_real_cpu_clock"));
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_real_cpu_clock"));
           } else
           {
-            ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+            ec.assign(errno, ::boost::system::system_category());
             return time_point();
           }
         }
@@ -129,12 +129,12 @@ namespace boost
       clock_t c = ::clock();
       if (c == clock_t(-1)) // error
       {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
-          boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_real_cpu_clock"));
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_real_cpu_clock"));
         } else
         {
-          ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+          ec.assign(errno, ::boost::system::system_category());
           return time_point();
         }
       } else
@@ -142,19 +142,19 @@ namespace boost
         long factor = chrono_detail::tick_factor();
         if (factor != -1)
         {
-          if (!BOOST_CHRONO_IS_THROWS(ec))
+          if (!::boost::chrono::is_throws(ec))
           {
             ec.clear();
           }
           return time_point(nanoseconds(c * factor));
         } else
         {
-          if (BOOST_CHRONO_IS_THROWS(ec))
+          if (::boost::chrono::is_throws(ec))
           {
-            boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_real_cpu_clock"));
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_real_cpu_clock"));
           } else
           {
-            ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+            ec.assign(errno, ::boost::system::system_category());
             return time_point();
           }
         }
@@ -171,12 +171,12 @@ namespace boost
       clock_t c = ::times(&tm);
       if (c == clock_t(-1)) // error
       {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
-          boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_user_cpu_clock"));
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_user_cpu_clock"));
         } else
         {
-          ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+          ec.assign(errno, ::boost::system::system_category());
           return time_point();
         }
       } else
@@ -184,19 +184,19 @@ namespace boost
         long factor = chrono_detail::tick_factor();
         if (factor != -1)
         {
-          if (!BOOST_CHRONO_IS_THROWS(ec))
+          if (!::boost::chrono::is_throws(ec))
           {
             ec.clear();
           }
           return time_point(nanoseconds((tm.tms_utime + tm.tms_cutime) * factor));
         } else
         {
-          if (BOOST_CHRONO_IS_THROWS(ec))
+          if (::boost::chrono::is_throws(ec))
           {
-            boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_user_cpu_clock"));
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_user_cpu_clock"));
           } else
           {
-            ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+            ec.assign(errno, ::boost::system::system_category());
             return time_point();
           }
         }
@@ -254,12 +254,12 @@ namespace boost
       clock_t c = ::times(&tm);
       if (c == clock_t(-1)) // error
       {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
-          boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_system_cpu_clock"));
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_system_cpu_clock"));
         } else
         {
-          ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+          ec.assign(errno, ::boost::system::system_category());
           return time_point();
         }
       } else
@@ -267,19 +267,19 @@ namespace boost
         long factor = chrono_detail::tick_factor();
         if (factor != -1)
         {
-          if (!BOOST_CHRONO_IS_THROWS(ec))
+          if (!::boost::chrono::is_throws(ec))
           {
             ec.clear();
           }
           return time_point(nanoseconds((tm.tms_stime + tm.tms_cstime) * factor));
         } else
         {
-          if (BOOST_CHRONO_IS_THROWS(ec))
+          if (::boost::chrono::is_throws(ec))
           {
-            boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_system_cpu_clock"));
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_system_cpu_clock"));
           } else
           {
-            ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+            ec.assign(errno, ::boost::system::system_category());
             return time_point();
           }
         }
@@ -319,12 +319,12 @@ namespace boost
       clock_t c = ::times(&tm);
       if (c == clock_t(-1)) // error
       {
-        if (BOOST_CHRONO_IS_THROWS(ec))
+        if (::boost::chrono::is_throws(ec))
         {
-          boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_clock"));
+          boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_clock"));
         } else
         {
-          ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+          ec.assign(errno, ::boost::system::system_category());
           return time_point();
         }
       } else
@@ -338,12 +338,12 @@ namespace boost
           return time_point(duration(r));
         } else
         {
-          if (BOOST_CHRONO_IS_THROWS(ec))
+          if (::boost::chrono::is_throws(ec))
           {
-            boost::throw_exception(system::system_error(errno, BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::process_clock"));
+            boost::throw_exception(system::system_error(errno, ::boost::system::system_category(), "chrono::process_clock"));
           } else
           {
-            ec.assign(errno, BOOST_CHRONO_SYSTEM_CATEGORY);
+            ec.assign(errno, ::boost::system::system_category());
             return time_point();
           }
         }