?????????? ?????????

?????????? ????????? - ??????????????? - /home/agenciai/public_html/cd38d8/detail.zip

???????
PK��]�[!;V��atomic_count.hppnu��[��// // detail/atomic_count.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_ATOMIC_COUNT_HPP #define BOOST_ASIO_DETAIL_ATOMIC_COUNT_HPP #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_HAS_THREADS) // Nothing to include. #elif defined(BOOST_ASIO_HAS_STD_ATOMIC) # include <atomic> #else // defined(BOOST_ASIO_HAS_STD_ATOMIC) # include <boost/detail/atomic_count.hpp> #endif // defined(BOOST_ASIO_HAS_STD_ATOMIC) namespace boost { namespace asio { namespace detail { #if !defined(BOOST_ASIO_HAS_THREADS) typedef long atomic_count; inline void increment(atomic_count& a, long b) { a += b; } inline void ref_count_up(atomic_count& a) { ++a; } inline bool ref_count_down(atomic_count& a) { return --a == 0; } #elif defined(BOOST_ASIO_HAS_STD_ATOMIC) typedef std::atomic<long> atomic_count; inline void increment(atomic_count& a, long b) { a += b; } inline void ref_count_up(atomic_count& a) { a.fetch_add(1, std::memory_order_relaxed); } inline bool ref_count_down(atomic_count& a) { if (a.fetch_sub(1, std::memory_order_release) == 1) { std::atomic_thread_fence(std::memory_order_acquire); return true; } return false; } #else // defined(BOOST_ASIO_HAS_STD_ATOMIC) typedef boost::detail::atomic_count atomic_count; inline void increment(atomic_count& a, long b) { while (b > 0) ++a, --b; } inline void ref_count_up(atomic_count& a) { ++a; } inline bool ref_count_down(atomic_count& a) { return --a == 0; } #endif // defined(BOOST_ASIO_HAS_STD_ATOMIC) } // namespace detail } // namespace asio } // namespace boost #endif // BOOST_ASIO_DETAIL_ATOMIC_COUNT_HPP PK��]�[a��X%��X%��utf8_codecvt_facet.ippnu��[��/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // utf8_codecvt_facet.ipp // Copyright (c) 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu) // Andrew Lumsdaine, Indiana University (lums@osl.iu.edu). // Use, modification and distribution is subject to 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) // Please see the comments in <boost/detail/utf8_codecvt_facet.hpp> to // learn how this file should be used. #include <boost/detail/utf8_codecvt_facet.hpp> #include <cstdlib> // for multi-byte converson routines #include <cassert> #include <boost/limits.hpp> #include <boost/config.hpp> // If we don't have wstring, then Unicode support // is not available anyway, so we don't need to even // compiler this file. This also fixes the problem // with mingw, which can compile this file, but will // generate link error when building DLL. #ifndef BOOST_NO_STD_WSTRING BOOST_UTF8_BEGIN_NAMESPACE /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // implementation for wchar_t utf8_codecvt_facet::utf8_codecvt_facet( std::size_t no_locale_manage ) : std::codecvt<wchar_t, char, std::mbstate_t>(no_locale_manage) {} utf8_codecvt_facet::~utf8_codecvt_facet() {} // Translate incoming UTF-8 into UCS-4 std::codecvt_base::result utf8_codecvt_facet::do_in( std::mbstate_t& /state/, const char * from, const char * from_end, const char * & from_next, wchar_t * to, wchar_t * to_end, wchar_t * & to_next ) const { // Basic algorithm: The first octet determines how many // octets total make up the UCS-4 character. The remaining // "continuing octets" all begin with "10". To convert, subtract // the amount that specifies the number of octets from the first // octet. Subtract 0x80 (1000 0000) from each continuing octet, // then mash the whole lot together. Note that each continuing // octet only uses 6 bits as unique values, so only shift by // multiples of 6 to combine. while (from != from_end && to != to_end) { // Error checking on the first octet if (invalid_leading_octet(from)){ from_next = from; to_next = to; return std::codecvt_base::error; } // The first octet is adjusted by a value dependent upon // the number of "continuing octets" encoding the character const int cont_octet_count = get_cont_octet_count(from); const wchar_t octet1_modifier_table[] = { 0x00, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc }; // The unsigned char conversion is necessary in case char is // signed (I learned this the hard way) wchar_t ucs_result = (unsigned char)(from++) - octet1_modifier_table[cont_octet_count]; // Invariants : // 1) At the start of the loop, 'i' continuing characters have been // processed // 2) from points to the next continuing character to be processed. int i = 0; while(i != cont_octet_count && from != from_end) { // Error checking on continuing characters if (invalid_continuing_octet(from)) { from_next = from; to_next = to; return std::codecvt_base::error; } ucs_result = (1 << 6); // each continuing character has an extra (10xxxxxx)b attached to // it that must be removed. ucs_result += (unsigned char)(from++) - 0x80; ++i; } // If the buffer ends with an incomplete unicode character... if (from == from_end && i != cont_octet_count) { // rewind "from" to before the current character translation from_next = from - (i+1); to_next = to; return std::codecvt_base::partial; } to++ = ucs_result; } from_next = from; to_next = to; // Were we done converting or did we run out of destination space? if(from == from_end) return std::codecvt_base::ok; else return std::codecvt_base::partial; } std::codecvt_base::result utf8_codecvt_facet::do_out( std::mbstate_t& /state/, const wchar_t * from, const wchar_t * from_end, const wchar_t * & from_next, char * to, char * to_end, char * & to_next ) const { // RG - consider merging this table with the other one const wchar_t octet1_modifier_table[] = { 0x00, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc }; wchar_t max_wchar = (std::numeric_limits<wchar_t>::max)(); while (from != from_end && to != to_end) { // Check for invalid UCS-4 character if (from > max_wchar) { from_next = from; to_next = to; return std::codecvt_base::error; } int cont_octet_count = get_cont_octet_out_count(from); // RG - comment this formula better int shift_exponent = (cont_octet_count) * 6; // Process the first character to++ = static_cast<char>(octet1_modifier_table[cont_octet_count] + (unsigned char)(from / (1 << shift_exponent))); // Process the continuation characters // Invariants: At the start of the loop: // 1) 'i' continuing octets have been generated // 2) 'to' points to the next location to place an octet // 3) shift_exponent is 6 more than needed for the next octet int i = 0; while (i != cont_octet_count && to != to_end) { shift_exponent -= 6; to++ = static_cast<char>(0x80 + ((from / (1 << shift_exponent)) % (1 << 6))); ++i; } // If we filled up the out buffer before encoding the character if(to == to_end && i != cont_octet_count) { from_next = from; to_next = to - (i+1); return std::codecvt_base::partial; } ++from; } from_next = from; to_next = to; // Were we done or did we run out of destination space if(from == from_end) return std::codecvt_base::ok; else return std::codecvt_base::partial; } // How many char objects can I process to get <= max_limit // wchar_t objects? int utf8_codecvt_facet::do_length( std::mbstate_t &, const char from, const char * from_end, std::size_t max_limit ) const #if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) throw() #endif { // RG - this code is confusing! I need a better way to express it. // and test cases. // Invariants: // 1) last_octet_count has the size of the last measured character // 2) char_count holds the number of characters shown to fit // within the bounds so far (no greater than max_limit) // 3) from_next points to the octet 'last_octet_count' before the // last measured character. int last_octet_count=0; std::size_t char_count = 0; const char* from_next = from; // Use "<" because the buffer may represent incomplete characters while (from_next+last_octet_count <= from_end && char_count <= max_limit) { from_next += last_octet_count; last_octet_count = (get_octet_count(from_next)); ++char_count; } return static_cast<int>(from_next-from); } unsigned int utf8_codecvt_facet::get_octet_count( unsigned char lead_octet ){ // if the 0-bit (MSB) is 0, then 1 character if (lead_octet <= 0x7f) return 1; // Otherwise the count number of consecutive 1 bits starting at MSB // assert(0xc0 <= lead_octet && lead_octet <= 0xfd); if (0xc0 <= lead_octet && lead_octet <= 0xdf) return 2; else if (0xe0 <= lead_octet && lead_octet <= 0xef) return 3; else if (0xf0 <= lead_octet && lead_octet <= 0xf7) return 4; else if (0xf8 <= lead_octet && lead_octet <= 0xfb) return 5; else return 6; } namespace detail { template<std::size_t s> int get_cont_octet_out_count_impl(wchar_t word){ if (word < 0x80) { return 0; } if (word < 0x800) { return 1; } return 2; } template<> int get_cont_octet_out_count_impl<4>(wchar_t word){ if (word < 0x80) { return 0; } if (word < 0x800) { return 1; } // Note that the following code will generate warnings on some platforms // where wchar_t is defined as UCS2. The warnings are superfluous as the // specialization is never instantitiated with such compilers, but this // can cause problems if warnings are being treated as errors, so we guard // against that. Including <boost/detail/utf8_codecvt_facet.hpp> as we do // should be enough to get WCHAR_MAX defined. #if !defined(WCHAR_MAX) # error WCHAR_MAX not defined! #endif // cope with VC++ 7.1 or earlier having invalid WCHAR_MAX #if defined(_MSC_VER) && _MSC_VER <= 1310 // 7.1 or earlier return 2; #elif WCHAR_MAX > 0x10000 if (word < 0x10000) { return 2; } if (word < 0x200000) { return 3; } if (word < 0x4000000) { return 4; } return 5; #else return 2; #endif } } // namespace detail // How many "continuing octets" will be needed for this word // == total octets - 1. int utf8_codecvt_facet::get_cont_octet_out_count( wchar_t word ) const { return detail::get_cont_octet_out_count_impl<sizeof(wchar_t)>(word); } BOOST_UTF8_END_NAMESPACE #endif PK��]�[#�ʔ��call_traits.hppnu��[��// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to 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). // // See http://www.boost.org/libs/utility for most recent version including documentation. // call_traits: defines typedefs for function usage // (see libs/utility/call_traits.htm) / Release notes: 23rd July 2000: Fixed array specialization. (JM) Added Borland specific fixes for reference types (issue raised by Steve Cleary). / #ifndef BOOST_DETAIL_CALL_TRAITS_HPP #define BOOST_DETAIL_CALL_TRAITS_HPP #ifndef BOOST_CONFIG_HPP #include <boost/config.hpp> #endif #include <cstddef> #include <boost/type_traits/is_arithmetic.hpp> #include <boost/type_traits/is_enum.hpp> #include <boost/type_traits/is_pointer.hpp> #include <boost/detail/workaround.hpp> namespace boost{ namespace detail{ template <typename T, bool small_> struct ct_imp2 { typedef const T& param_type; }; template <typename T> struct ct_imp2<T, true> { typedef const T param_type; }; template <typename T, bool isp, bool b1, bool b2> struct ct_imp { typedef const T& param_type; }; template <typename T, bool isp, bool b2> struct ct_imp<T, isp, true, b2> { typedef typename ct_imp2<T, sizeof(T) <= sizeof(void)>::param_type param_type; }; template <typename T, bool isp, bool b1> struct ct_imp<T, isp, b1, true> { typedef typename ct_imp2<T, sizeof(T) <= sizeof(void)>::param_type param_type; }; template <typename T, bool b1, bool b2> struct ct_imp<T, true, b1, b2> { typedef const T param_type; }; } template <typename T> struct call_traits { public: typedef T value_type; typedef T& reference; typedef const T& const_reference; // // C++ Builder workaround: we should be able to define a compile time // constant and pass that as a single template parameter to ct_imp<T,bool>, // however compiler bugs prevent this - instead pass three bool's to // ct_imp<T,bool,bool,bool> and add an extra partial specialisation // of ct_imp to handle the logic. (JM) typedef typename boost::detail::ct_imp< T, ::boost::is_pointer<T>::value, ::boost::is_arithmetic<T>::value, ::boost::is_enum<T>::value >::param_type param_type; }; template <typename T> struct call_traits<T&> { typedef T& value_type; typedef T& reference; typedef const T& const_reference; typedef T& param_type; // hh removed const }; #if BOOST_WORKAROUND( BOOST_BORLANDC, < 0x5A0 ) // these are illegal specialisations; cv-qualifies applied to // references have no effect according to [8.3.2p1], // C++ Builder requires them though as it treats cv-qualified // references as distinct types... template <typename T> struct call_traits<T&const> { typedef T& value_type; typedef T& reference; typedef const T& const_reference; typedef T& param_type; // hh removed const }; template <typename T> struct call_traits<T&volatile> { typedef T& value_type; typedef T& reference; typedef const T& const_reference; typedef T& param_type; // hh removed const }; template <typename T> struct call_traits<T&const volatile> { typedef T& value_type; typedef T& reference; typedef const T& const_reference; typedef T& param_type; // hh removed const }; template <typename T> struct call_traits< T > { typedef T * value_type; typedef T * & reference; typedef T * const & const_reference; typedef T * const param_type; // hh removed const }; #endif #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS) template <typename T, std::size_t N> struct call_traits<T [N]> { private: typedef T array_type[N]; public: // degrades array to pointer: typedef const T* value_type; typedef array_type& reference; typedef const array_type& const_reference; typedef const T* const param_type; }; template <typename T, std::size_t N> struct call_traits<const T [N]> { private: typedef const T array_type[N]; public: // degrades array to pointer: typedef const T* value_type; typedef array_type& reference; typedef const array_type& const_reference; typedef const T* const param_type; }; #endif } #endif // BOOST_DETAIL_CALL_TRAITS_HPP PK��]�[�~{.�� is_xxx.hppnu��[��// Copyright David Abrahams 2005. 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_DETAIL_IS_XXX_DWA20051011_HPP # define BOOST_DETAIL_IS_XXX_DWA20051011_HPP # include <boost/config.hpp> # include <boost/type_traits/integral_constant.hpp> # include <boost/preprocessor/enum_params.hpp> # define BOOST_DETAIL_IS_XXX_DEF(name, qualified_name, nargs) \ template <class T> \ struct is_##name : boost::false_type \ { \ }; \ \ template < BOOST_PP_ENUM_PARAMS_Z(1, nargs, class T) > \ struct is_##name< \ qualified_name< BOOST_PP_ENUM_PARAMS_Z(1, nargs, T) > \ > \ : boost::true_type \ { \ }; #endif // BOOST_DETAIL_IS_XXX_DWA20051011_HPP PK��]�[0�7��!��winapi/get_current_process_id.hppnu��[��/* * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/get_current_process_id.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_GET_CURRENT_PROCESS_ID_HPP #define BOOST_DETAIL_WINAPI_GET_CURRENT_PROCESS_ID_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/get_current_process_id.hpp>") #include <boost/winapi/get_current_process_id.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_GET_CURRENT_PROCESS_ID_HPP PK��]�[�w�F��F��winapi/time.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/time.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_TIME_HPP_ #define BOOST_DETAIL_WINAPI_TIME_HPP_ #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/time.hpp>") #include <boost/winapi/time.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_TIME_HPP_ PK��]�[ΙE[��winapi/priority_class.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/priority_class.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_PRIORITY_CLASS_HPP_ #define BOOST_DETAIL_WINAPI_PRIORITY_CLASS_HPP_ #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/priority_class.hpp>") #include <boost/winapi/priority_class.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_PRIORITY_CLASS_HPP_ PK��]�[��U��U��winapi/dbghelp.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/dbghelp.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_DBGHELP_HPP #define BOOST_DETAIL_WINAPI_DBGHELP_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/dbghelp.hpp>") #include <boost/winapi/dbghelp.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_DBGHELP_HPP PK��]�[y��winapi/get_current_process.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/get_current_process.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_GET_CURRENT_PROCESS_HPP #define BOOST_DETAIL_WINAPI_GET_CURRENT_PROCESS_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/get_current_process.hpp>") #include <boost/winapi/get_current_process.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_GET_CURRENT_PROCESS_HPP PK��]�[��[��[��winapi/security.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/security.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_SECURITY_HPP #define BOOST_DETAIL_WINAPI_SECURITY_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/security.hpp>") #include <boost/winapi/security.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_SECURITY_HPP PK��]�[�p��p��winapi/error_codes.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/error_codes.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_ERROR_CODES_HPP_ #define BOOST_DETAIL_WINAPI_ERROR_CODES_HPP_ #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/error_codes.hpp>") #include <boost/winapi/error_codes.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_ERROR_CODES_HPP_ PK��]�[g��p��p��winapi/heap_memory.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/heap_memory.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_HEAP_MEMORY_HPP_ #define BOOST_DETAIL_WINAPI_HEAP_MEMORY_HPP_ #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/heap_memory.hpp>") #include <boost/winapi/heap_memory.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_HEAP_MEMORY_HPP_ PK��]�[�OL��L��winapi/pipes.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/pipes.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_PIPES_HPP_ #define BOOST_DETAIL_WINAPI_PIPES_HPP_ #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/pipes.hpp>") #include <boost/winapi/pipes.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_PIPES_HPP_ PK��]�[Ah��winapi/srw_lock.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/srw_lock.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_SRW_LOCK_HPP #define BOOST_DETAIL_WINAPI_SRW_LOCK_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/srw_lock.hpp>") #include <boost/winapi/srw_lock.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif // Deprecated #define BOOST_DETAIL_WINAPI_SRWLOCK_INIT BOOST_WINAPI_SRWLOCK_INIT #endif // BOOST_DETAIL_WINAPI_SRW_LOCK_HPP PK��]�[RʹG��winapi/get_current_thread.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/get_current_thread.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_GET_CURRENT_THREAD_HPP #define BOOST_DETAIL_WINAPI_GET_CURRENT_THREAD_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/get_current_thread.hpp>") #include <boost/winapi/get_current_thread.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_GET_CURRENT_THREAD_HPP PK��]�[�iy��winapi/directory_management.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/directory_management.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_DIRECTORY_MANAGEMENT_HPP #define BOOST_DETAIL_WINAPI_DIRECTORY_MANAGEMENT_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/directory_management.hpp>") #include <boost/winapi/directory_management.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_DIRECTORY_MANAGEMENT_HPP PK��]�[i^�[��[��winapi/handle_info.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/handle_info.hpp instead. / #ifndef BOOST_DETAIL_HANDLE_INFO_HPP_ #define BOOST_DETAIL_HANDLE_INFO_HPP_ #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/handle_info.hpp>") #include <boost/winapi/handle_info.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_HANDLE_INFO_HPP_ PK��]�[��sF��F��winapi/jobs.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/jobs.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_JOBS_HPP_ #define BOOST_DETAIL_WINAPI_JOBS_HPP_ #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/jobs.hpp>") #include <boost/winapi/jobs.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_JOBS_HPP_ PK��]�[_�;L��L��winapi/mutex.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/mutex.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_MUTEX_HPP_ #define BOOST_DETAIL_WINAPI_MUTEX_HPP_ #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/mutex.hpp>") #include <boost/winapi/mutex.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_MUTEX_HPP_ PK��]�[�sEoO��O��winapi/system.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/system.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_SYSTEM_HPP #define BOOST_DETAIL_WINAPI_SYSTEM_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/system.hpp>") #include <boost/winapi/system.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_SYSTEM_HPP PK��]�[K�ɩ�� winapi/get_current_thread_id.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/get_current_thread_id.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_GET_CURRENT_THREAD_ID_HPP #define BOOST_DETAIL_WINAPI_GET_CURRENT_THREAD_ID_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/get_current_thread_id.hpp>") #include <boost/winapi/get_current_thread_id.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_GET_CURRENT_THREAD_ID_HPP PK��]�[�51"I��I��winapi/crypt.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/crypt.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_CRYPT_HPP #define BOOST_DETAIL_WINAPI_CRYPT_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/crypt.hpp>") #include <boost/winapi/crypt.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_CRYPT_HPP PK��]�[��#[��[��winapi/debugapi.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/debugapi.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_DEBUGAPI_HPP #define BOOST_DETAIL_WINAPI_DEBUGAPI_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/debugapi.hpp>") #include <boost/winapi/debugapi.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_DEBUGAPI_HPP PK��]�[+��L��L��winapi/shell.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/shell.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_SHELL_HPP_ #define BOOST_DETAIL_WINAPI_SHELL_HPP_ #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/shell.hpp>") #include <boost/winapi/shell.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_SHELL_HPP_ PK��]�[�=k�=��=��winapi/apc.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/apc.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_APC_HPP #define BOOST_DETAIL_WINAPI_APC_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/apc.hpp>") #include <boost/winapi/apc.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_APC_HPP PK��]�[�C��.��.��winapi/config.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/config.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_CONFIG_HPP_INCLUDED_ #define BOOST_DETAIL_WINAPI_CONFIG_HPP_INCLUDED_ #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/config.hpp>") #include <boost/winapi/config.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_CONFIG_HPP_INCLUDED_ PK��]�['3��p��p��winapi/environment.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/environment.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_ENVIRONMENT_HPP_ #define BOOST_DETAIL_WINAPI_ENVIRONMENT_HPP_ #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/environment.hpp>") #include <boost/winapi/environment.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_ENVIRONMENT_HPP_ PK��]�[~#{@=��=��winapi/dll.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/dll.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_DLL_HPP #define BOOST_DETAIL_WINAPI_DLL_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/dll.hpp>") #include <boost/winapi/dll.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_DLL_HPP PK��]�[�:;O��O��winapi/timers.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/timers.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_TIMERS_HPP #define BOOST_DETAIL_WINAPI_TIMERS_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/timers.hpp>") #include <boost/winapi/timers.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_TIMERS_HPP PK��]�[F�R�m��m��winapi/thread_pool.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/thread_pool.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_THREAD_POOL_HPP #define BOOST_DETAIL_WINAPI_THREAD_POOL_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/thread_pool.hpp>") #include <boost/winapi/thread_pool.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_THREAD_POOL_HPP PK��]�[� "m��m��winapi/basic_types.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/basic_types.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_BASIC_TYPES_HPP #define BOOST_DETAIL_WINAPI_BASIC_TYPES_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/basic_types.hpp>") #include <boost/winapi/basic_types.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_BASIC_TYPES_HPP PK��]�[t��L��L��winapi/event.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/event.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_EVENT_HPP_ #define BOOST_DETAIL_WINAPI_EVENT_HPP_ #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/event.hpp>") #include <boost/winapi/event.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_EVENT_HPP_ PK��]�[�'��winapi/init_once.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/init_once.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_INIT_ONCE_HPP #define BOOST_DETAIL_WINAPI_INIT_ONCE_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/init_once.hpp>") #include <boost/winapi/init_once.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #define BOOST_DETAIL_WINAPI_INIT_ONCE_STATIC_INIT BOOST_WINAPI_INIT_ONCE_STATIC_INIT #endif // BOOST_DETAIL_WINAPI_INIT_ONCE_HPP PK��]�[��qs��s��winapi/file_mapping.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/file_mapping.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_FILE_MAPPING_HPP #define BOOST_DETAIL_WINAPI_FILE_MAPPING_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/file_mapping.hpp>") #include <boost/winapi/file_mapping.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_FILE_MAPPING_HPP PK��]�[!�9�=��=��winapi/tls.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/tls.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_TLS_HPP #define BOOST_DETAIL_WINAPI_TLS_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/tls.hpp>") #include <boost/winapi/tls.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_TLS_HPP PK��]�[)��,X��X��winapi/process.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/process.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_PROCESS_HPP_ #define BOOST_DETAIL_WINAPI_PROCESS_HPP_ #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/process.hpp>") #include <boost/winapi/process.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_PROCESS_HPP_ PK��]�[�M�R��R��winapi/bcrypt.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/bcrypt.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_BCRYPT_HPP_ #define BOOST_DETAIL_WINAPI_BCRYPT_HPP_ #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/bcrypt.hpp>") #include <boost/winapi/bcrypt.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_BCRYPT_HPP_ PK��]�[�'E��winapi/waitable_timer.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/waitable_timer.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_WAITABLE_TIMER_HPP #define BOOST_DETAIL_WINAPI_WAITABLE_TIMER_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/waitable_timer.hpp>") #include <boost/winapi/waitable_timer.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_WAITABLE_TIMER_HPP PK��]�[�iR��winapi/error_handling.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/error_handling.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_ERROR_HANDLING_HPP #define BOOST_DETAIL_WINAPI_ERROR_HANDLING_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/error_handling.hpp>") #include <boost/winapi/error_handling.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_ERROR_HANDLING_HPP PK��]�[�Z��winapi/critical_section.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/critical_section.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_CRITICAL_SECTION_HPP #define BOOST_DETAIL_WINAPI_CRITICAL_SECTION_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/critical_section.hpp>") #include <boost/winapi/critical_section.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_CRITICAL_SECTION_HPP PK��]�[%��winapi/get_last_error.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/get_last_error.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_GET_LAST_ERROR_HPP #define BOOST_DETAIL_WINAPI_GET_LAST_ERROR_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/get_last_error.hpp>") #include <boost/winapi/get_last_error.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_GET_LAST_ERROR_HPP PK��]�[�qB��winapi/stack_backtrace.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/stack_backtrace.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_STACK_BACKTRACE_HPP_INCLUDED_ #define BOOST_DETAIL_WINAPI_STACK_BACKTRACE_HPP_INCLUDED_ #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/stack_backtrace.hpp>") #include <boost/winapi/stack_backtrace.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_STACK_BACKTRACE_HPP_INCLUDED_ PK��]�[��?��&��winapi/detail/deprecated_namespace.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, it provides the deprecated namespace for backward compatibility. / #ifndef BOOST_DETAIL_WINAPI_DETAIL_DEPRECATED_NAMESPACE_HPP_INCLUDED_ #define BOOST_DETAIL_WINAPI_DETAIL_DEPRECATED_NAMESPACE_HPP_INCLUDED_ #include <boost/config.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif namespace boost { namespace winapi {} namespace detail { namespace winapi { using namespace boost::winapi; } // namespace winapi } // namespace detail } // namespace boost #endif // BOOST_DETAIL_WINAPI_DETAIL_DEPRECATED_NAMESPACE_HPP_INCLUDED_ PK��]�[��O��$��winapi/character_code_conversion.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/character_code_conversion.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_CHARACTER_CODE_CONVERSION_HPP #define BOOST_DETAIL_WINAPI_CHARACTER_CODE_CONVERSION_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/character_code_conversion.hpp>") #include <boost/winapi/character_code_conversion.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_CHARACTER_CODE_CONVERSION_HPP PK��]�[�=�d��d��winapi/semaphore.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/semaphore.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_SEMAPHORE_HPP_ #define BOOST_DETAIL_WINAPI_SEMAPHORE_HPP_ #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/semaphore.hpp>") #include <boost/winapi/semaphore.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_SEMAPHORE_HPP_ PK��]�[C��V��winapi/synchronization.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/synchronization.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_SYNCHRONIZATION_HPP #define BOOST_DETAIL_WINAPI_SYNCHRONIZATION_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/synchronization.hpp>") #include <boost/winapi/synchronization.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_SYNCHRONIZATION_HPP PK��]�[\|�S�� winapi/page_protection_flags.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/page_protection_flags.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_PAGE_PROTECTION_FLAGS_HPP #define BOOST_DETAIL_WINAPI_PAGE_PROTECTION_FLAGS_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/page_protection_flags.hpp>") #include <boost/winapi/page_protection_flags.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_PAGE_PROTECTION_FLAGS_HPP PK��]�[�9�U��U��winapi/handles.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/handles.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_HANDLES_HPP #define BOOST_DETAIL_WINAPI_HANDLES_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/handles.hpp>") #include <boost/winapi/handles.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_HANDLES_HPP PK��]�[%��;p��p��winapi/show_window.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/show_window.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_SHOW_WINDOW_HPP_ #define BOOST_DETAIL_WINAPI_SHOW_WINDOW_HPP_ #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/show_window.hpp>") #include <boost/winapi/show_window.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_SHOW_WINDOW_HPP_ PK��]�[�89��winapi/get_thread_times.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/get_thread_times.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_GET_THREAD_TIMES_HPP #define BOOST_DETAIL_WINAPI_GET_THREAD_TIMES_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/get_thread_times.hpp>") #include <boost/winapi/get_thread_times.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_GET_THREAD_TIMES_HPP PK��]�[D�ٮs��s��winapi/local_memory.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/local_memory.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_LOCAL_MEMORY_HPP #define BOOST_DETAIL_WINAPI_LOCAL_MEMORY_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/local_memory.hpp>") #include <boost/winapi/local_memory.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_LOCAL_MEMORY_HPP PK��]�[XI��winapi/get_system_directory.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/get_system_directory.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_GET_SYSTEM_DIRECTORY_HPP_ #define BOOST_DETAIL_WINAPI_GET_SYSTEM_DIRECTORY_HPP_ #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/get_system_directory.hpp>") #include <boost/winapi/get_system_directory.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_GET_SYSTEM_DIRECTORY_HPP_ PK��]�[�bltR��R��winapi/limits.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/limits.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_LIMITS_HPP_ #define BOOST_DETAIL_WINAPI_LIMITS_HPP_ #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/limits.hpp>") #include <boost/winapi/limits.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_LIMITS_HPP_ PK��]�[#XC��C��winapi/wait.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/wait.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_WAIT_HPP #define BOOST_DETAIL_WINAPI_WAIT_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/wait.hpp>") #include <boost/winapi/wait.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_WAIT_HPP PK��]�[w�G��winapi/condition_variable.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/condition_variable.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_CONDITION_VARIABLE_HPP #define BOOST_DETAIL_WINAPI_CONDITION_VARIABLE_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/condition_variable.hpp>") #include <boost/winapi/condition_variable.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif // Deprecated #define BOOST_DETAIL_WINAPI_CONDITION_VARIABLE_INIT BOOST_WINAPI_CONDITION_VARIABLE_INIT #endif // BOOST_DETAIL_WINAPI_CONDITION_VARIABLE_HPP PK��]�[��i�O��O��winapi/memory.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/memory.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_MEMORY_HPP #define BOOST_DETAIL_WINAPI_MEMORY_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/memory.hpp>") #include <boost/winapi/memory.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_MEMORY_HPP PK��]�[h17�y��y��winapi/access_rights.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/access_rights.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_ACCESS_RIGHTS_HPP #define BOOST_DETAIL_WINAPI_ACCESS_RIGHTS_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/access_rights.hpp>") #include <boost/winapi/access_rights.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_ACCESS_RIGHTS_HPP PK��]�[ê��winapi/get_process_times.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/get_process_times.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_GET_PROCESS_TIMES_HPP #define BOOST_DETAIL_WINAPI_GET_PROCESS_TIMES_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/get_process_times.hpp>") #include <boost/winapi/get_process_times.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_GET_PROCESS_TIMES_HPP PK��]�[�X��winapi/file_management.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/file_management.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_FILE_MANAGEMENT_HPP #define BOOST_DETAIL_WINAPI_FILE_MANAGEMENT_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/file_management.hpp>") #include <boost/winapi/file_management.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_FILE_MANAGEMENT_HPP PK��]�[��huj��j��winapi/overlapped.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/overlapped.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_OVERLAPPED_HPP_ #define BOOST_DETAIL_WINAPI_OVERLAPPED_HPP_ #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/overlapped.hpp>") #include <boost/winapi/overlapped.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_OVERLAPPED_HPP_ PK��]�[�J�O��O��winapi/thread.hppnu��[��/ * Copyright 2017 Andrey Semashev * * Distributed under the Boost Software License, Version 1.0. * See http://www.boost.org/LICENSE_1_0.txt * * This header is deprecated, use boost/winapi/thread.hpp instead. / #ifndef BOOST_DETAIL_WINAPI_THREAD_HPP #define BOOST_DETAIL_WINAPI_THREAD_HPP #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/winapi/thread.hpp>") #include <boost/winapi/thread.hpp> #include <boost/detail/winapi/detail/deprecated_namespace.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif #endif // BOOST_DETAIL_WINAPI_THREAD_HPP PK��]�[%�"�_��_��binary_search.hppnu��[��// Copyright (c) 2000 David Abrahams. // 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) // // Copyright (c) 1994 // Hewlett-Packard Company // // Permission to use, copy, modify, distribute and sell this software // and its documentation for any purpose is hereby granted without fee, // provided that the above copyright notice appear in all copies and // that both that copyright notice and this permission notice appear // in supporting documentation. Hewlett-Packard Company makes no // representations about the suitability of this software for any // purpose. It is provided "as is" without express or implied warranty. // // Copyright (c) 1996 // Silicon Graphics Computer Systems, Inc. // // Permission to use, copy, modify, distribute and sell this software // and its documentation for any purpose is hereby granted without fee, // provided that the above copyright notice appear in all copies and // that both that copyright notice and this permission notice appear // in supporting documentation. Silicon Graphics makes no // representations about the suitability of this software for any // purpose. It is provided "as is" without express or implied warranty. // #ifndef BINARY_SEARCH_DWA_122600_H_ # define BINARY_SEARCH_DWA_122600_H_ # include <utility> # include <iterator> namespace boost { namespace detail { template <class ForwardIter, class Tp> ForwardIter lower_bound(ForwardIter first, ForwardIter last, const Tp& val) { typedef std::iterator_traits<ForwardIter> traits; typename traits::difference_type len = std::distance(first, last); typename traits::difference_type half; ForwardIter middle; while (len > 0) { half = len >> 1; middle = first; std::advance(middle, half); if (middle < val) { first = middle; ++first; len = len - half - 1; } else len = half; } return first; } template <class ForwardIter, class Tp, class Compare> ForwardIter lower_bound(ForwardIter first, ForwardIter last, const Tp& val, Compare comp) { typedef std::iterator_traits<ForwardIter> traits; typename traits::difference_type len = std::distance(first, last); typename traits::difference_type half; ForwardIter middle; while (len > 0) { half = len >> 1; middle = first; std::advance(middle, half); if (comp(middle, val)) { first = middle; ++first; len = len - half - 1; } else len = half; } return first; } template <class ForwardIter, class Tp> ForwardIter upper_bound(ForwardIter first, ForwardIter last, const Tp& val) { typedef std::iterator_traits<ForwardIter> traits; typename traits::difference_type len = std::distance(first, last); typename traits::difference_type half; ForwardIter middle; while (len > 0) { half = len >> 1; middle = first; std::advance(middle, half); if (val < middle) len = half; else { first = middle; ++first; len = len - half - 1; } } return first; } template <class ForwardIter, class Tp, class Compare> ForwardIter upper_bound(ForwardIter first, ForwardIter last, const Tp& val, Compare comp) { typedef std::iterator_traits<ForwardIter> traits; typename traits::difference_type len = std::distance(first, last); typename traits::difference_type half; ForwardIter middle; while (len > 0) { half = len >> 1; middle = first; std::advance(middle, half); if (comp(val, middle)) len = half; else { first = middle; ++first; len = len - half - 1; } } return first; } template <class ForwardIter, class Tp> std::pair<ForwardIter, ForwardIter> equal_range(ForwardIter first, ForwardIter last, const Tp& val) { typedef std::iterator_traits<ForwardIter> traits; typename traits::difference_type len = std::distance(first, last); typename traits::difference_type half; ForwardIter middle, left, right; while (len > 0) { half = len >> 1; middle = first; std::advance(middle, half); if (middle < val) { first = middle; ++first; len = len - half - 1; } else if (val < middle) len = half; else { left = boost::detail::lower_bound(first, middle, val); std::advance(first, len); right = boost::detail::upper_bound(++middle, first, val); return std::pair<ForwardIter, ForwardIter>(left, right); } } return std::pair<ForwardIter, ForwardIter>(first, first); } template <class ForwardIter, class Tp, class Compare> std::pair<ForwardIter, ForwardIter> equal_range(ForwardIter first, ForwardIter last, const Tp& val, Compare comp) { typedef std::iterator_traits<ForwardIter> traits; typename traits::difference_type len = std::distance(first, last); typename traits::difference_type half; ForwardIter middle, left, right; while (len > 0) { half = len >> 1; middle = first; std::advance(middle, half); if (comp(middle, val)) { first = middle; ++first; len = len - half - 1; } else if (comp(val, middle)) len = half; else { left = boost::detail::lower_bound(first, middle, val, comp); std::advance(first, len); right = boost::detail::upper_bound(++middle, first, val, comp); return std::pair<ForwardIter, ForwardIter>(left, right); } } return std::pair<ForwardIter, ForwardIter>(first, first); } template <class ForwardIter, class Tp> bool binary_search(ForwardIter first, ForwardIter last, const Tp& val) { ForwardIter i = boost::detail::lower_bound(first, last, val); return i != last && !(val < i); } template <class ForwardIter, class Tp, class Compare> bool binary_search(ForwardIter first, ForwardIter last, const Tp& val, Compare comp) { ForwardIter i = boost::detail::lower_bound(first, last, val, comp); return i != last && !comp(val, i); } }} // namespace boost::detail #endif // BINARY_SEARCH_DWA_122600_H_ PK��]�[�m�^��^��quick_allocator.hppnu��[��#ifndef BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED #define BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif // // detail/quick_allocator.hpp // // Copyright (c) 2003 David Abrahams // Copyright (c) 2003 Peter Dimov // // 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 // #include <boost/smart_ptr/detail/quick_allocator.hpp> #endif // #ifndef BOOST_DETAIL_QUICK_ALLOCATOR_HPP_INCLUDED PK��]�[�^�G��G��indirect_traits.hppnu��[��// Copyright David Abrahams 2002. // 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 INDIRECT_TRAITS_DWA2002131_HPP # define INDIRECT_TRAITS_DWA2002131_HPP # include <boost/type_traits/integral_constant.hpp> # include <boost/type_traits/is_function.hpp> # include <boost/type_traits/is_reference.hpp> # include <boost/type_traits/is_pointer.hpp> # include <boost/type_traits/is_class.hpp> # include <boost/type_traits/is_const.hpp> # include <boost/type_traits/is_volatile.hpp> # include <boost/type_traits/is_member_function_pointer.hpp> # include <boost/type_traits/is_member_pointer.hpp> # include <boost/type_traits/remove_cv.hpp> # include <boost/type_traits/remove_reference.hpp> # include <boost/type_traits/remove_pointer.hpp> # include <boost/detail/workaround.hpp> # include <boost/detail/select_type.hpp> namespace boost { namespace detail { namespace indirect_traits { template <class T> struct is_reference_to_const : boost::false_type { }; template <class T> struct is_reference_to_const<T const&> : boost::true_type { }; # if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround template<class T> struct is_reference_to_const<T const volatile&> : boost::true_type { }; # endif template <class T> struct is_reference_to_function : boost::false_type { }; template <class T> struct is_reference_to_function<T&> : is_function<T> { }; template <class T> struct is_pointer_to_function : boost::false_type { }; // There's no such thing as a pointer-to-cv-function, so we don't need // specializations for those template <class T> struct is_pointer_to_function<T> : is_function<T> { }; template <class T> struct is_reference_to_member_function_pointer_impl : boost::false_type { }; template <class T> struct is_reference_to_member_function_pointer_impl<T&> : is_member_function_pointer<typename remove_cv<T>::type> { }; template <class T> struct is_reference_to_member_function_pointer : is_reference_to_member_function_pointer_impl<T> { }; template <class T> struct is_reference_to_function_pointer_aux : boost::integral_constant<bool, is_reference<T>::value && is_pointer_to_function< typename remove_cv< typename remove_reference<T>::type >::type >::value > { // There's no such thing as a pointer-to-cv-function, so we don't need specializations for those }; template <class T> struct is_reference_to_function_pointer : boost::detail::if_true< is_reference_to_function<T>::value >::template then< boost::false_type , is_reference_to_function_pointer_aux<T> >::type { }; template <class T> struct is_reference_to_non_const : boost::integral_constant<bool, is_reference<T>::value && !is_reference_to_const<T>::value > { }; template <class T> struct is_reference_to_volatile : boost::false_type { }; template <class T> struct is_reference_to_volatile<T volatile&> : boost::true_type { }; # if defined(BOOST_MSVC) && _MSC_FULL_VER <= 13102140 // vc7.01 alpha workaround template <class T> struct is_reference_to_volatile<T const volatile&> : boost::true_type { }; # endif template <class T> struct is_reference_to_pointer : boost::false_type { }; template <class T> struct is_reference_to_pointer<T&> : boost::true_type { }; template <class T> struct is_reference_to_pointer<T const&> : boost::true_type { }; template <class T> struct is_reference_to_pointer<T* volatile&> : boost::true_type { }; template <class T> struct is_reference_to_pointer<T* const volatile&> : boost::true_type { }; template <class T> struct is_reference_to_class : boost::integral_constant<bool, is_reference<T>::value && is_class< typename remove_cv< typename remove_reference<T>::type >::type >::value > { }; template <class T> struct is_pointer_to_class : boost::integral_constant<bool, is_pointer<T>::value && is_class< typename remove_cv< typename remove_pointer<T>::type >::type >::value > { }; } using namespace indirect_traits; }} // namespace boost::python::detail #endif // INDIRECT_TRAITS_DWA2002131_HPP PK��]�[�Soqj��j��identifier.hppnu��[��// boost/identifier.hpp ----------------------------------------------------// // Copyright Beman Dawes 2006 // 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) // See documentation at http://www.boost.org/libs/utility #ifndef BOOST_IDENTIFIER_HPP #define BOOST_IDENTIFIER_HPP #include <boost/utility/enable_if.hpp> #include <boost/type_traits/is_base_of.hpp> #include <iosfwd> namespace boost { namespace detail { // class template identifier ---------------------------------------------// // Always used as a base class so that different instantiations result in // different class types even if instantiated with the same value type T. // Expected usage is that T is often an integer type, best passed by // value. There is no reason why T can't be a possibly larger class such as // std::string, best passed by const reference. // This implementation uses pass by value, based on expected common uses. template <typename T, typename D> class identifier { public: typedef T value_type; const value_type value() const { return m_value; } void assign( value_type v ) { m_value = v; } bool operator==( const D & rhs ) const { return m_value == rhs.m_value; } bool operator!=( const D & rhs ) const { return m_value != rhs.m_value; } bool operator< ( const D & rhs ) const { return m_value < rhs.m_value; } bool operator<=( const D & rhs ) const { return m_value <= rhs.m_value; } bool operator> ( const D & rhs ) const { return m_value > rhs.m_value; } bool operator>=( const D & rhs ) const { return m_value >= rhs.m_value; } typedef void (unspecified_bool_type)(D); // without the D, unspecified_bool_type static void unspecified_bool_true(D){} // conversion allows relational operators // between different identifier types operator unspecified_bool_type() const { return m_value == value_type() ? 0 : unspecified_bool_true; } bool operator!() const { return m_value == value_type(); } // constructors are protected so that class can only be used as a base class protected: identifier() {} explicit identifier( value_type v ) : m_value(v) {} private: T m_value; }; //#ifndef BOOST_NO_SFINAE // template <class Ostream, class Id> // typename enable_if< is_base_of< identifier< typename Id::value_type, Id >, Id >, // Ostream & >::type operator<<( Ostream & os, const Id & id ) // { // return os << id.value(); // } // template <class Istream, class Id> // typename enable_if< is_base_of< identifier< typename Id::value_type, Id >, Id >, // Istream & >::type operator>>( Istream & is, Id & id ) // { // typename Id::value_type v; // is >> v; // id.value( v ); // return is; // } //#endif } // namespace detail } // namespace boost #endif // BOOST_IDENTIFIER_HPP PK��]�[��-��-��catch_exceptions.hppnu��[��// boost/catch_exceptions.hpp -----------------------------------------------// // Copyright Beman Dawes 1995-2001. 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) // See http://www.boost.org/libs/test for documentation. // Revision History // 13 Jun 01 report_exception() made inline. (John Maddock, Jesse Jones) // 26 Feb 01 Numerous changes suggested during formal review. (Beman) // 25 Jan 01 catch_exceptions.hpp code factored out of cpp_main.cpp. // 22 Jan 01 Remove test_tools dependencies to reduce coupling. // 5 Nov 00 Initial boost version (Beman Dawes) #ifndef BOOST_CATCH_EXCEPTIONS_HPP #define BOOST_CATCH_EXCEPTIONS_HPP // header dependencies are deliberately restricted to the standard library // to reduce coupling to other boost libraries. #include <string> // for string #include <new> // for bad_alloc #include <ostream> // for ostream #include <typeinfo> // for bad_cast, bad_typeid #include <exception> // for exception, bad_exception #include <stdexcept> // for std exception hierarchy #include <boost/config.hpp> #include <boost/cstdlib.hpp> // for exit codes # if defined(BOOST_BORLANDC) && (__BORLANDC__ <= 0x0551) # define BOOST_BUILT_IN_EXCEPTIONS_MISSING_WHAT # endif #if defined(MPW_CPLUS) && (MPW_CPLUS <= 0x890) # define BOOST_BUILT_IN_EXCEPTIONS_MISSING_WHAT namespace std { class bad_typeid { }; } # endif namespace boost { namespace detail { // A separate reporting function was requested during formal review. inline void report_exception( std::ostream & os, const char name, const char * info ) { os << "\n** uncaught exception: " << name << " " << info << std::endl; } } // catch_exceptions ------------------------------------------------------// template< class Generator > // Generator is function object returning int int catch_exceptions( Generator function_object, std::ostream & out, std::ostream & err ) { int result = 0; // quiet compiler warnings bool exception_thrown = true; // avoid setting result for each excptn type #ifndef BOOST_NO_EXCEPTIONS try { #endif result = function_object(); exception_thrown = false; #ifndef BOOST_NO_EXCEPTIONS } // As a result of hard experience with strangely interleaved output // under some compilers, there is a lot of use of endl in the code below // where a simple '\n' might appear to do. // The rules for catch & arguments are a bit different from function // arguments (ISO 15.3 paragraphs 18 & 19). Apparently const isn't // required, but it doesn't hurt and some programmers ask for it. catch ( const char * ex ) { detail::report_exception( out, "", ex ); } catch ( const std::string & ex ) { detail::report_exception( out, "", ex.c_str() ); } // std:: exceptions catch ( const std::bad_alloc & ex ) { detail::report_exception( out, "std::bad_alloc:", ex.what() ); } # ifndef BOOST_BUILT_IN_EXCEPTIONS_MISSING_WHAT catch ( const std::bad_cast & ex ) { detail::report_exception( out, "std::bad_cast:", ex.what() ); } catch ( const std::bad_typeid & ex ) { detail::report_exception( out, "std::bad_typeid:", ex.what() ); } # else catch ( const std::bad_cast & ) { detail::report_exception( out, "std::bad_cast", "" ); } catch ( const std::bad_typeid & ) { detail::report_exception( out, "std::bad_typeid", "" ); } # endif catch ( const std::bad_exception & ex ) { detail::report_exception( out, "std::bad_exception:", ex.what() ); } catch ( const std::domain_error & ex ) { detail::report_exception( out, "std::domain_error:", ex.what() ); } catch ( const std::invalid_argument & ex ) { detail::report_exception( out, "std::invalid_argument:", ex.what() ); } catch ( const std::length_error & ex ) { detail::report_exception( out, "std::length_error:", ex.what() ); } catch ( const std::out_of_range & ex ) { detail::report_exception( out, "std::out_of_range:", ex.what() ); } catch ( const std::range_error & ex ) { detail::report_exception( out, "std::range_error:", ex.what() ); } catch ( const std::overflow_error & ex ) { detail::report_exception( out, "std::overflow_error:", ex.what() ); } catch ( const std::underflow_error & ex ) { detail::report_exception( out, "std::underflow_error:", ex.what() ); } catch ( const std::logic_error & ex ) { detail::report_exception( out, "std::logic_error:", ex.what() ); } catch ( const std::runtime_error & ex ) { detail::report_exception( out, "std::runtime_error:", ex.what() ); } catch ( const std::exception & ex ) { detail::report_exception( out, "std::exception:", ex.what() ); } catch ( ... ) { detail::report_exception( out, "unknown exception", "" ); } #endif // BOOST_NO_EXCEPTIONS if ( exception_thrown ) result = boost::exit_exception_failure; if ( result != 0 && result != exit_success ) { out << std::endl << "** returning with error code " << result << std::endl; err << "****** errors detected; see stdout for details ********" << std::endl; } #if !defined(BOOST_NO_CPP_MAIN_SUCCESS_MESSAGE) else { out << std::flush << "no errors detected" << std::endl; } #endif return result; } // catch_exceptions } // boost #endif // BOOST_CATCH_EXCEPTIONS_HPP PK��]�[�yߺ��is_incrementable.hppnu��[��// Copyright David Abrahams 2004. Use, modification and distribution is // subject to 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 IS_INCREMENTABLE_DWA200415_HPP # define IS_INCREMENTABLE_DWA200415_HPP # include <boost/type_traits/integral_constant.hpp> # include <boost/type_traits/remove_cv.hpp> # include <boost/detail/workaround.hpp> namespace boost { namespace detail { // is_incrementable<T> metafunction // // Requires: Given x of type T&, if the expression ++x is well-formed // it must have complete type; otherwise, it must neither be ambiguous // nor violate access. // This namespace ensures that ADL doesn't mess things up. namespace is_incrementable_ { // a type returned from operator++ when no increment is found in the // type's own namespace struct tag {}; // any soaks up implicit conversions and makes the following // operator++ less-preferred than any other such operator that // might be found via ADL. struct any { template <class T> any(T const&); }; // This is a last-resort operator++ for when none other is found # if BOOST_WORKAROUND(__GNUC__, == 4) && __GNUC_MINOR__ == 0 && __GNUC_PATCHLEVEL__ == 2 } namespace is_incrementable_2 { is_incrementable_::tag operator++(is_incrementable_::any const&); is_incrementable_::tag operator++(is_incrementable_::any const&,int); } using namespace is_incrementable_2; namespace is_incrementable_ { # else tag operator++(any const&); tag operator++(any const&,int); # endif # if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) # define BOOST_comma(a,b) (a) # else // In case an operator++ is found that returns void, we'll use ++x,0 tag operator,(tag,int); # define BOOST_comma(a,b) (a,b) # endif # if defined(BOOST_MSVC) # pragma warning(push) # pragma warning(disable:4913) // Warning about operator, # endif // two check overloads help us identify which operator++ was picked char (& check_(tag) )[2]; template <class T> char check_(T const&); template <class T> struct impl { static typename boost::remove_cv<T>::type& x; BOOST_STATIC_CONSTANT( bool , value = sizeof(is_incrementable_::check_(BOOST_comma(++x,0))) == 1 ); }; template <class T> struct postfix_impl { static typename boost::remove_cv<T>::type& x; BOOST_STATIC_CONSTANT( bool , value = sizeof(is_incrementable_::check_(BOOST_comma(x++,0))) == 1 ); }; # if defined(BOOST_MSVC) # pragma warning(pop) # endif } # undef BOOST_comma template<typename T> struct is_incrementable : public boost::integral_constant<bool, boost::detail::is_incrementable_::impl<T>::value> { }; template<typename T> struct is_postfix_incrementable : public boost::integral_constant<bool, boost::detail::is_incrementable_::postfix_impl<T>::value> { }; } // namespace detail } // namespace boost # include <boost/type_traits/detail/bool_trait_undef.hpp> #endif // IS_INCREMENTABLE_DWA200415_HPP PK��]�[5 �v��v��lightweight_mutex.hppnu��[��#ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED #define BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif // // boost/detail/lightweight_mutex.hpp - lightweight mutex // // Copyright (c) 2002, 2003 Peter Dimov and Multi Media Ltd. // // 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 // #include <boost/smart_ptr/detail/lightweight_mutex.hpp> #endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_MUTEX_HPP_INCLUDED PK��]�[�YO��O��workaround.hppnu��[��// Copyright David Abrahams 2002. // 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 WORKAROUND_DWA2002126_HPP #define WORKAROUND_DWA2002126_HPP #include <boost/config/workaround.hpp> #endif // WORKAROUND_DWA2002126_HPP PK��]�[ċچ��fenv.hppnu��[��/============================================================================= Copyright (c) 2010 Bryce Lelbach 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) =============================================================================/ #include <boost/config.hpp> #if defined(BOOST_NO_FENV_H) #error This platform does not have a floating point environment #endif #if !defined(BOOST_DETAIL_FENV_HPP) #define BOOST_DETAIL_FENV_HPP /* If we're using clang + glibc, we have to get hacky. * See http://llvm.org/bugs/show_bug.cgi?id=6907 / #if defined(__clang__) && (__clang_major__ < 3) && \ defined(__GNU_LIBRARY__) && / up to version 5 / \ defined(__GLIBC__) && / version 6 + / \ !defined(_FENV_H) #define _FENV_H #include <features.h> #include <bits/fenv.h> extern "C" { extern int fegetexceptflag (fexcept_t, int) __THROW; extern int fesetexceptflag (__const fexcept_t, int) __THROW; extern int feclearexcept (int) __THROW; extern int feraiseexcept (int) __THROW; extern int fetestexcept (int) __THROW; extern int fegetround (void) __THROW; extern int fesetround (int) __THROW; extern int fegetenv (fenv_t) __THROW; extern int fesetenv (__const fenv_t) __THROW; extern int feupdateenv (__const fenv_t) __THROW; extern int feholdexcept (fenv_t) __THROW; #ifdef __USE_GNU extern int feenableexcept (int) __THROW; extern int fedisableexcept (int) __THROW; extern int fegetexcept (void) __THROW; #endif } namespace std { namespace tr1 { using ::fenv_t; using ::fexcept_t; using ::fegetexceptflag; using ::fesetexceptflag; using ::feclearexcept; using ::feraiseexcept; using ::fetestexcept; using ::fegetround; using ::fesetround; using ::fegetenv; using ::fesetenv; using ::feupdateenv; using ::feholdexcept; } } #elif defined(__MINGW32__) && defined(__GNUC__) && (__GNUC__ 100 + __GNUC_MINOR__) >= 408 // MinGW (32-bit) has a bug in mingw32/bits/c++config.h, it does not define _GLIBCXX_HAVE_FENV_H, // which prevents the C fenv.h header contents to be included in the C++ wrapper header fenv.h. This is at least // the case with gcc 4.8.1 packages tested so far, up to 4.8.1-4. Note that there is no issue with // MinGW-w64. // To work around the bug we avoid including the C++ wrapper header and include the C header directly // and import all relevant symbols into std:: ourselves. #include <../include/fenv.h> namespace std { using ::fenv_t; using ::fexcept_t; using ::fegetexceptflag; using ::fesetexceptflag; using ::feclearexcept; using ::feraiseexcept; using ::fetestexcept; using ::fegetround; using ::fesetround; using ::fegetenv; using ::fesetenv; using ::feupdateenv; using ::feholdexcept; } #else /* if we're not using GNU's C stdlib, fenv.h should work with clang / #if defined(__SUNPRO_CC) / lol suncc / #include <stdio.h> #endif #include <fenv.h> #endif #endif / BOOST_DETAIL_FENV_HPP / PK��]�[D� ��lightweight_test_report.hppnu��[��// boost/detail/lightweight_test_reporter.hpp ----------------------------------------// // Copyright Beman Dawes 2014 // Distributed under the Boost Software License, Version 1.0. // See http://www.boost.org/LICENSE_1_0.txt //--------------------------------------------------------------------------------------// // // // Configuration reporting cpp_main() // // // // Displays configuration information, then returns test_main(argc, argv), which // // must be supplied by the user. // // // // Note: cpp_main(argc, argv) is called from a try block in main(), which is // // supplied by <boost/detail/lightweight_main.hpp> as is a catch block that reports // // std::exception what(). // // // //--------------------------------------------------------------------------------------// #include <boost/config.hpp> #include <boost/version.hpp> #include <boost/detail/lightweight_test.hpp> #include <boost/detail/lightweight_main.hpp> #include <iostream> int test_main(int argc, char argv[]); int cpp_main(int argc, char* argv[]) { std::cout << BOOST_COMPILER #ifdef __GNUC__ << ", __GXX_EXPERIMENTAL_CXX0X__ " # ifdef __GXX_EXPERIMENTAL_CXX0X__ "defined" # else "not defined" # endif #endif << "\n" << BOOST_STDLIB << "\n" << BOOST_PLATFORM << "\n" << "Boost version " << BOOST_VERSION / 100000 << '.' << BOOST_VERSION / 100 % 1000 << '.' << BOOST_VERSION % 100 << "\n"; std::cout << "Command line: "; for (int a = 0; a < argc; ++a) { std::cout << argv[a]; if (a != argc - 1) std::cout << ' '; } std::cout << std::endl; return test_main(argc, argv); }PK��]�[��@��@��ob_compressed_pair.hppnu��[��// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to 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). // // See http://www.boost.org/libs/utility for most recent version including documentation. // see libs/utility/compressed_pair.hpp // /* Release notes: 20 Jan 2001: Fixed obvious bugs (David Abrahams) 07 Oct 2000: Added better single argument constructor support. 03 Oct 2000: Added VC6 support (JM). 23rd July 2000: Additional comments added. (JM) Jan 2000: Original version: this version crippled for use with crippled compilers - John Maddock Jan 2000. / #ifndef BOOST_OB_COMPRESSED_PAIR_HPP #define BOOST_OB_COMPRESSED_PAIR_HPP #include <algorithm> #ifndef BOOST_OBJECT_TYPE_TRAITS_HPP #include <boost/type_traits/object_traits.hpp> #endif #ifndef BOOST_SAME_TRAITS_HPP #include <boost/type_traits/same_traits.hpp> #endif #ifndef BOOST_CALL_TRAITS_HPP #include <boost/call_traits.hpp> #endif namespace boost { #ifdef BOOST_MSVC6_MEMBER_TEMPLATES // // use member templates to emulate // partial specialisation. Note that due to // problems with overload resolution with VC6 // each of the compressed_pair versions that follow // have one template single-argument constructor // in place of two specific constructors: // template <class T1, class T2> class compressed_pair; namespace detail{ template <class A, class T1, class T2> struct best_conversion_traits { typedef char one; typedef char (&two)[2]; static A a; static one test(T1); static two test(T2); enum { value = sizeof(test(a)) }; }; template <int> struct init_one; template <> struct init_one<1> { template <class A, class T1, class T2> static void init(const A& a, T1 p1, T2) { p1 = a; } }; template <> struct init_one<2> { template <class A, class T1, class T2> static void init(const A& a, T1, T2 p2) { p2 = a; } }; // T1 != T2, both non-empty template <class T1, class T2> class compressed_pair_0 { private: T1 _first; T2 _second; public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits<first_type>::param_type first_param_type; typedef typename call_traits<second_type>::param_type second_param_type; typedef typename call_traits<first_type>::reference first_reference; typedef typename call_traits<second_type>::reference second_reference; typedef typename call_traits<first_type>::const_reference first_const_reference; typedef typename call_traits<second_type>::const_reference second_const_reference; compressed_pair_0() : _first(), _second() {} compressed_pair_0(first_param_type x, second_param_type y) : _first(x), _second(y) {} template <class A> explicit compressed_pair_0(const A& val) { init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, &_second); } compressed_pair_0(const ::boost::compressed_pair<T1,T2>& x) : _first(x.first()), _second(x.second()) {} #if 0 compressed_pair_0& operator=(const compressed_pair_0& x) { cout << "assigning compressed pair 0" << endl; _first = x._first; _second = x._second; cout << "finished assigning compressed pair 0" << endl; return this; } #endif first_reference first() { return _first; } first_const_reference first() const { return _first; } second_reference second() { return _second; } second_const_reference second() const { return _second; } void swap(compressed_pair_0& y) { using std::swap; swap(_first, y._first); swap(_second, y._second); } }; // T1 != T2, T2 empty template <class T1, class T2> class compressed_pair_1 : T2 { private: T1 _first; public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits<first_type>::param_type first_param_type; typedef typename call_traits<second_type>::param_type second_param_type; typedef typename call_traits<first_type>::reference first_reference; typedef typename call_traits<second_type>::reference second_reference; typedef typename call_traits<first_type>::const_reference first_const_reference; typedef typename call_traits<second_type>::const_reference second_const_reference; compressed_pair_1() : T2(), _first() {} compressed_pair_1(first_param_type x, second_param_type y) : T2(y), _first(x) {} template <class A> explicit compressed_pair_1(const A& val) { init_one<best_conversion_traits<A, T1, T2>::value>::init(val, &_first, static_cast<T2>(this)); } compressed_pair_1(const ::boost::compressed_pair<T1,T2>& x) : T2(x.second()), _first(x.first()) {} first_reference first() { return _first; } first_const_reference first() const { return _first; } second_reference second() { return this; } second_const_reference second() const { return this; } void swap(compressed_pair_1& y) { // no need to swap empty base class: using std::swap; swap(_first, y._first); } }; // T1 != T2, T1 empty template <class T1, class T2> class compressed_pair_2 : T1 { private: T2 _second; public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits<first_type>::param_type first_param_type; typedef typename call_traits<second_type>::param_type second_param_type; typedef typename call_traits<first_type>::reference first_reference; typedef typename call_traits<second_type>::reference second_reference; typedef typename call_traits<first_type>::const_reference first_const_reference; typedef typename call_traits<second_type>::const_reference second_const_reference; compressed_pair_2() : T1(), _second() {} compressed_pair_2(first_param_type x, second_param_type y) : T1(x), _second(y) {} template <class A> explicit compressed_pair_2(const A& val) { init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1>(this), &_second); } compressed_pair_2(const ::boost::compressed_pair<T1,T2>& x) : T1(x.first()), _second(x.second()) {} #if 0 compressed_pair_2& operator=(const compressed_pair_2& x) { cout << "assigning compressed pair 2" << endl; T1::operator=(x); _second = x._second; cout << "finished assigning compressed pair 2" << endl; return this; } #endif first_reference first() { return this; } first_const_reference first() const { return this; } second_reference second() { return _second; } second_const_reference second() const { return _second; } void swap(compressed_pair_2& y) { // no need to swap empty base class: using std::swap; swap(_second, y._second); } }; // T1 != T2, both empty template <class T1, class T2> class compressed_pair_3 : T1, T2 { public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits<first_type>::param_type first_param_type; typedef typename call_traits<second_type>::param_type second_param_type; typedef typename call_traits<first_type>::reference first_reference; typedef typename call_traits<second_type>::reference second_reference; typedef typename call_traits<first_type>::const_reference first_const_reference; typedef typename call_traits<second_type>::const_reference second_const_reference; compressed_pair_3() : T1(), T2() {} compressed_pair_3(first_param_type x, second_param_type y) : T1(x), T2(y) {} template <class A> explicit compressed_pair_3(const A& val) { init_one<best_conversion_traits<A, T1, T2>::value>::init(val, static_cast<T1>(this), static_cast<T2>(this)); } compressed_pair_3(const ::boost::compressed_pair<T1,T2>& x) : T1(x.first()), T2(x.second()) {} first_reference first() { return this; } first_const_reference first() const { return this; } second_reference second() { return this; } second_const_reference second() const { return this; } void swap(compressed_pair_3& y) { // no need to swap empty base classes: } }; // T1 == T2, and empty template <class T1, class T2> class compressed_pair_4 : T1 { public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits<first_type>::param_type first_param_type; typedef typename call_traits<second_type>::param_type second_param_type; typedef typename call_traits<first_type>::reference first_reference; typedef typename call_traits<second_type>::reference second_reference; typedef typename call_traits<first_type>::const_reference first_const_reference; typedef typename call_traits<second_type>::const_reference second_const_reference; compressed_pair_4() : T1() {} compressed_pair_4(first_param_type x, second_param_type y) : T1(x), m_second(y) {} // only one single argument constructor since T1 == T2 explicit compressed_pair_4(first_param_type x) : T1(x), m_second(x) {} compressed_pair_4(const ::boost::compressed_pair<T1,T2>& x) : T1(x.first()), m_second(x.second()) {} first_reference first() { return this; } first_const_reference first() const { return this; } second_reference second() { return m_second; } second_const_reference second() const { return m_second; } void swap(compressed_pair_4& y) { // no need to swap empty base classes: } private: T2 m_second; }; // T1 == T2, not empty template <class T1, class T2> class compressed_pair_5 { private: T1 _first; T2 _second; public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits<first_type>::param_type first_param_type; typedef typename call_traits<second_type>::param_type second_param_type; typedef typename call_traits<first_type>::reference first_reference; typedef typename call_traits<second_type>::reference second_reference; typedef typename call_traits<first_type>::const_reference first_const_reference; typedef typename call_traits<second_type>::const_reference second_const_reference; compressed_pair_5() : _first(), _second() {} compressed_pair_5(first_param_type x, second_param_type y) : _first(x), _second(y) {} // only one single argument constructor since T1 == T2 explicit compressed_pair_5(first_param_type x) : _first(x), _second(x) {} compressed_pair_5(const ::boost::compressed_pair<T1,T2>& c) : _first(c.first()), _second(c.second()) {} first_reference first() { return _first; } first_const_reference first() const { return _first; } second_reference second() { return _second; } second_const_reference second() const { return _second; } void swap(compressed_pair_5& y) { using std::swap; swap(_first, y._first); swap(_second, y._second); } }; template <bool e1, bool e2, bool same> struct compressed_pair_chooser { template <class T1, class T2> struct rebind { typedef compressed_pair_0<T1, T2> type; }; }; template <> struct compressed_pair_chooser<false, true, false> { template <class T1, class T2> struct rebind { typedef compressed_pair_1<T1, T2> type; }; }; template <> struct compressed_pair_chooser<true, false, false> { template <class T1, class T2> struct rebind { typedef compressed_pair_2<T1, T2> type; }; }; template <> struct compressed_pair_chooser<true, true, false> { template <class T1, class T2> struct rebind { typedef compressed_pair_3<T1, T2> type; }; }; template <> struct compressed_pair_chooser<true, true, true> { template <class T1, class T2> struct rebind { typedef compressed_pair_4<T1, T2> type; }; }; template <> struct compressed_pair_chooser<false, false, true> { template <class T1, class T2> struct rebind { typedef compressed_pair_5<T1, T2> type; }; }; template <class T1, class T2> struct compressed_pair_traits { private: typedef compressed_pair_chooser<is_empty<T1>::value, is_empty<T2>::value, is_same<T1,T2>::value> chooser; typedef typename chooser::template rebind<T1, T2> bound_type; public: typedef typename bound_type::type type; }; } // namespace detail template <class T1, class T2> class compressed_pair : public detail::compressed_pair_traits<T1, T2>::type { private: typedef typename detail::compressed_pair_traits<T1, T2>::type base_type; public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits<first_type>::param_type first_param_type; typedef typename call_traits<second_type>::param_type second_param_type; typedef typename call_traits<first_type>::reference first_reference; typedef typename call_traits<second_type>::reference second_reference; typedef typename call_traits<first_type>::const_reference first_const_reference; typedef typename call_traits<second_type>::const_reference second_const_reference; compressed_pair() : base_type() {} compressed_pair(first_param_type x, second_param_type y) : base_type(x, y) {} template <class A> explicit compressed_pair(const A& x) : base_type(x){} first_reference first() { return base_type::first(); } first_const_reference first() const { return base_type::first(); } second_reference second() { return base_type::second(); } second_const_reference second() const { return base_type::second(); } }; template <class T1, class T2> inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y) { x.swap(y); } #else // no partial specialisation, no member templates: template <class T1, class T2> class compressed_pair { private: T1 _first; T2 _second; public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits<first_type>::param_type first_param_type; typedef typename call_traits<second_type>::param_type second_param_type; typedef typename call_traits<first_type>::reference first_reference; typedef typename call_traits<second_type>::reference second_reference; typedef typename call_traits<first_type>::const_reference first_const_reference; typedef typename call_traits<second_type>::const_reference second_const_reference; compressed_pair() : _first(), _second() {} compressed_pair(first_param_type x, second_param_type y) : _first(x), _second(y) {} explicit compressed_pair(first_param_type x) : _first(x), _second() {} // can't define this in case T1 == T2: // explicit compressed_pair(second_param_type y) : _first(), _second(y) {} first_reference first() { return _first; } first_const_reference first() const { return _first; } second_reference second() { return _second; } second_const_reference second() const { return _second; } void swap(compressed_pair& y) { using std::swap; swap(_first, y._first); swap(_second, y._second); } }; template <class T1, class T2> inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y) { x.swap(y); } #endif } // boost #endif // BOOST_OB_COMPRESSED_PAIR_HPP PK��]�[^2�N��lcast_precision.hppnu��[��// Copyright Alexander Nasonov & Paul A. Bristow 2006. // Use, modification and distribution are subject to 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_DETAIL_LCAST_PRECISION_HPP_INCLUDED #define BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED #include <climits> #include <ios> #include <limits> #include <boost/config.hpp> #include <boost/integer_traits.hpp> #ifndef BOOST_NO_IS_ABSTRACT // Fix for SF:1358600 - lexical_cast & pure virtual functions & VC 8 STL #include <boost/type_traits/conditional.hpp> #include <boost/type_traits/is_abstract.hpp> #endif #if defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS) \|\| \ (defined(BOOST_MSVC) && (BOOST_MSVC<1310)) #define BOOST_LCAST_NO_COMPILE_TIME_PRECISION #endif #ifdef BOOST_LCAST_NO_COMPILE_TIME_PRECISION #include <boost/assert.hpp> #else #include <boost/static_assert.hpp> #endif namespace boost { namespace detail { class lcast_abstract_stub {}; #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION // Calculate an argument to pass to std::ios_base::precision from // lexical_cast. See alternative implementation for broken standard // libraries in lcast_get_precision below. Keep them in sync, please. template<class T> struct lcast_precision { #ifdef BOOST_NO_IS_ABSTRACT typedef std::numeric_limits<T> limits; // No fix for SF:1358600. #else typedef BOOST_DEDUCED_TYPENAME boost::conditional< boost::is_abstract<T>::value , std::numeric_limits<lcast_abstract_stub> , std::numeric_limits<T> >::type limits; #endif BOOST_STATIC_CONSTANT(bool, use_default_precision = !limits::is_specialized \|\| limits::is_exact ); BOOST_STATIC_CONSTANT(bool, is_specialized_bin = !use_default_precision && limits::radix == 2 && limits::digits > 0 ); BOOST_STATIC_CONSTANT(bool, is_specialized_dec = !use_default_precision && limits::radix == 10 && limits::digits10 > 0 ); BOOST_STATIC_CONSTANT(std::streamsize, streamsize_max = boost::integer_traits<std::streamsize>::const_max ); BOOST_STATIC_CONSTANT(unsigned int, precision_dec = limits::digits10 + 1U); BOOST_STATIC_ASSERT(!is_specialized_dec \|\| precision_dec <= streamsize_max + 0UL ); BOOST_STATIC_CONSTANT(unsigned long, precision_bin = 2UL + limits::digits 30103UL / 100000UL ); BOOST_STATIC_ASSERT(!is_specialized_bin \|\| (limits::digits + 0UL < ULONG_MAX / 30103UL && precision_bin > limits::digits10 + 0UL && precision_bin <= streamsize_max + 0UL) ); BOOST_STATIC_CONSTANT(std::streamsize, value = is_specialized_bin ? precision_bin : is_specialized_dec ? precision_dec : 6 ); }; #endif template<class T> inline std::streamsize lcast_get_precision(T* = 0) { #ifndef BOOST_LCAST_NO_COMPILE_TIME_PRECISION return lcast_precision<T>::value; #else // Follow lcast_precision algorithm at run-time: #ifdef BOOST_NO_IS_ABSTRACT typedef std::numeric_limits<T> limits; // No fix for SF:1358600. #else typedef BOOST_DEDUCED_TYPENAME boost::conditional< boost::is_abstract<T>::value , std::numeric_limits<lcast_abstract_stub> , std::numeric_limits<T> >::type limits; #endif bool const use_default_precision = !limits::is_specialized \|\| limits::is_exact; if(!use_default_precision) { // Includes all built-in floating-point types, float, double ... // and UDT types for which digits (significand bits) is defined (not zero) bool const is_specialized_bin = limits::radix == 2 && limits::digits > 0; bool const is_specialized_dec = limits::radix == 10 && limits::digits10 > 0; std::streamsize const streamsize_max = (boost::integer_traits<std::streamsize>::max)(); (void)streamsize_max; if(is_specialized_bin) { // Floating-point types with // limits::digits defined by the specialization. unsigned long const digits = limits::digits; unsigned long const precision = 2UL + digits * 30103UL / 100000UL; // unsigned long is selected because it is at least 32-bits // and thus ULONG_MAX / 30103UL is big enough for all types. BOOST_ASSERT( digits < ULONG_MAX / 30103UL && precision > limits::digits10 + 0UL && precision <= streamsize_max + 0UL ); return precision; } else if(is_specialized_dec) { // Decimal Floating-point type, most likely a User Defined Type // rather than a real floating-point hardware type. unsigned int const precision = limits::digits10 + 1U; BOOST_ASSERT(precision <= streamsize_max + 0UL); return precision; } } // Integral type (for which precision has no effect) // or type T for which limits is NOT specialized, // so assume stream precision remains the default 6 decimal digits. // Warning: if your User-defined Floating-point type T is NOT specialized, // then you may lose accuracy by only using 6 decimal digits. // To avoid this, you need to specialize T with either // radix == 2 and digits == the number of significand bits, // OR // radix = 10 and digits10 == the number of decimal digits. return 6; #endif } template<class T> inline void lcast_set_precision(std::ios_base& stream, T) { stream.precision(lcast_get_precision<T>()); } template<class Source, class Target> inline void lcast_set_precision(std::ios_base& stream, Source, Target) { std::streamsize const s = lcast_get_precision(static_cast<Source>(0)); std::streamsize const t = lcast_get_precision(static_cast<Target>(0)); stream.precision(s > t ? s : t); } }} #endif // BOOST_DETAIL_LCAST_PRECISION_HPP_INCLUDED PK��]�[��lightweight_main.hppnu��[��// boost/detail/lightweight_main.hpp -------------------------------------------------// // Copyright Beman Dawes 2010 // Distributed under the Boost Software License, Version 1.0. // See http://www.boost.org/LICENSE_1_0.txt #include <iostream> #include <exception> //--------------------------------------------------------------------------------------// // // // exception reporting main() that calls cpp_main() // // // //--------------------------------------------------------------------------------------// int cpp_main(int argc, char argv[]); int main(int argc, char* argv[]) { try { return cpp_main(argc, argv); } catch (const std::exception& ex) { std::cout << "\nERROR ERROR ERROR ERROR ERROR ERROR ERROR ERROR ERROR ERROR ERROR\n" << "\n**************************** std::exception *************************\n" << ex.what() << "\n************************************************************************\n" << std::endl; } return 1; } PK��]�[�2�n�7��7��interlocked.hppnu��[��#ifndef BOOST_DETAIL_INTERLOCKED_HPP_INCLUDED #define BOOST_DETAIL_INTERLOCKED_HPP_INCLUDED // // boost/detail/interlocked.hpp // // Copyright 2005 Peter Dimov // Copyright 2018, 2019 Andrey Semashev // // 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) // #include <boost/config.hpp> #ifdef BOOST_HAS_PRAGMA_ONCE #pragma once #endif // BOOST_INTERLOCKED_HAS_INTRIN_H // VC9 has intrin.h, but it collides with <utility> #if defined( BOOST_MSVC ) && BOOST_MSVC >= 1600 # define BOOST_INTERLOCKED_HAS_INTRIN_H // Unlike __MINGW64__, __MINGW64_VERSION_MAJOR is defined by MinGW-w64 for both 32 and 64-bit targets. #elif defined( __MINGW64_VERSION_MAJOR ) // MinGW-w64 provides intrin.h for both 32 and 64-bit targets. # define BOOST_INTERLOCKED_HAS_INTRIN_H #elif defined( __CYGWIN__ ) // Cygwin and Cygwin64 provide intrin.h. On Cygwin64 we have to use intrin.h because it's an LP64 target, // where long is 64-bit and therefore _Interlocked functions have different signatures. # define BOOST_INTERLOCKED_HAS_INTRIN_H // Intel C++ on Windows on VC10+ stdlib #elif defined( BOOST_INTEL_WIN ) && defined( _CPPLIB_VER ) && _CPPLIB_VER >= 520 # define BOOST_INTERLOCKED_HAS_INTRIN_H // clang-cl on Windows on VC10+ stdlib #elif defined( __clang__ ) && defined( _MSC_VER ) && defined( _CPPLIB_VER ) && _CPPLIB_VER >= 520 # define BOOST_INTERLOCKED_HAS_INTRIN_H #endif #if !defined(__LP64__) #define BOOST_INTERLOCKED_LONG32 long #else #define BOOST_INTERLOCKED_LONG32 int #endif #if defined( BOOST_USE_WINDOWS_H ) # include <windows.h> # define BOOST_INTERLOCKED_INCREMENT(dest) \ InterlockedIncrement((BOOST_INTERLOCKED_LONG32)(dest)) # define BOOST_INTERLOCKED_DECREMENT(dest) \ InterlockedDecrement((BOOST_INTERLOCKED_LONG32)(dest)) # define BOOST_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) \ InterlockedCompareExchange((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(exchange), (BOOST_INTERLOCKED_LONG32)(compare)) # define BOOST_INTERLOCKED_EXCHANGE(dest, exchange) \ InterlockedExchange((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(exchange)) # define BOOST_INTERLOCKED_EXCHANGE_ADD(dest, add) \ InterlockedExchangeAdd((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(add)) # define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) \ InterlockedCompareExchangePointer((void)(dest), (void)(exchange), (void)(compare)) # define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest, exchange) \ InterlockedExchangePointer((void)(dest), (void)(exchange)) #elif defined( BOOST_USE_INTRIN_H ) \|\| defined( BOOST_INTERLOCKED_HAS_INTRIN_H ) #include <intrin.h> # define BOOST_INTERLOCKED_INCREMENT(dest) \ _InterlockedIncrement((BOOST_INTERLOCKED_LONG32)(dest)) # define BOOST_INTERLOCKED_DECREMENT(dest) \ _InterlockedDecrement((BOOST_INTERLOCKED_LONG32)(dest)) # define BOOST_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) \ _InterlockedCompareExchange((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(exchange), (BOOST_INTERLOCKED_LONG32)(compare)) # define BOOST_INTERLOCKED_EXCHANGE(dest, exchange) \ _InterlockedExchange((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(exchange)) # define BOOST_INTERLOCKED_EXCHANGE_ADD(dest, add) \ _InterlockedExchangeAdd((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(add)) // Note: Though MSVC-12 defines _InterlockedCompareExchangePointer and _InterlockedExchangePointer in intrin.h, the latter // is actually broken as it conflicts with winnt.h from Windows SDK 8.1. # if (defined(_MSC_VER) && _MSC_VER >= 1900) \|\| \ (defined(_M_IA64) \|\| defined(_M_AMD64) \|\| defined(__x86_64__) \|\| defined(__x86_64) \|\| defined(_M_ARM64)) # define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) \ _InterlockedCompareExchangePointer((void)(dest), (void)(exchange), (void)(compare)) # define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest, exchange) \ _InterlockedExchangePointer((void)(dest), (void)(exchange)) # else # define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) \ ((void)BOOST_INTERLOCKED_COMPARE_EXCHANGE((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(exchange), (BOOST_INTERLOCKED_LONG32)(compare))) # define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest, exchange) \ ((void)BOOST_INTERLOCKED_EXCHANGE((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(exchange))) # endif #elif defined(_WIN32_WCE) #if _WIN32_WCE >= 0x600 extern "C" BOOST_INTERLOCKED_LONG32 __cdecl _InterlockedIncrement( BOOST_INTERLOCKED_LONG32 volatile * ); extern "C" BOOST_INTERLOCKED_LONG32 __cdecl _InterlockedDecrement( BOOST_INTERLOCKED_LONG32 volatile * ); extern "C" BOOST_INTERLOCKED_LONG32 __cdecl _InterlockedCompareExchange( BOOST_INTERLOCKED_LONG32 volatile , BOOST_INTERLOCKED_LONG32, BOOST_INTERLOCKED_LONG32 ); extern "C" BOOST_INTERLOCKED_LONG32 __cdecl _InterlockedExchange( BOOST_INTERLOCKED_LONG32 volatile , BOOST_INTERLOCKED_LONG32 ); extern "C" BOOST_INTERLOCKED_LONG32 __cdecl _InterlockedExchangeAdd( BOOST_INTERLOCKED_LONG32 volatile , BOOST_INTERLOCKED_LONG32 ); # define BOOST_INTERLOCKED_INCREMENT(dest) \ _InterlockedIncrement((BOOST_INTERLOCKED_LONG32)(dest)) # define BOOST_INTERLOCKED_DECREMENT(dest) \ _InterlockedDecrement((BOOST_INTERLOCKED_LONG32)(dest)) # define BOOST_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) \ _InterlockedCompareExchange((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(exchange), (BOOST_INTERLOCKED_LONG32)(compare)) # define BOOST_INTERLOCKED_EXCHANGE(dest, exchange) \ _InterlockedExchange((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(exchange)) # define BOOST_INTERLOCKED_EXCHANGE_ADD(dest, add) \ _InterlockedExchangeAdd((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(add)) #else // _WIN32_WCE >= 0x600 // under Windows CE we still have old-style Interlocked* functions extern "C" BOOST_INTERLOCKED_LONG32 __cdecl InterlockedIncrement( BOOST_INTERLOCKED_LONG32 * ); extern "C" BOOST_INTERLOCKED_LONG32 __cdecl InterlockedDecrement( BOOST_INTERLOCKED_LONG32 * ); extern "C" BOOST_INTERLOCKED_LONG32 __cdecl InterlockedCompareExchange( BOOST_INTERLOCKED_LONG32 , BOOST_INTERLOCKED_LONG32, BOOST_INTERLOCKED_LONG32 ); extern "C" BOOST_INTERLOCKED_LONG32 __cdecl InterlockedExchange( BOOST_INTERLOCKED_LONG32 , BOOST_INTERLOCKED_LONG32 ); extern "C" BOOST_INTERLOCKED_LONG32 __cdecl InterlockedExchangeAdd( BOOST_INTERLOCKED_LONG32 , BOOST_INTERLOCKED_LONG32 ); # define BOOST_INTERLOCKED_INCREMENT(dest) \ InterlockedIncrement((BOOST_INTERLOCKED_LONG32)(dest)) # define BOOST_INTERLOCKED_DECREMENT(dest) \ InterlockedDecrement((BOOST_INTERLOCKED_LONG32)(dest)) # define BOOST_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) \ InterlockedCompareExchange((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(exchange), (BOOST_INTERLOCKED_LONG32)(compare)) # define BOOST_INTERLOCKED_EXCHANGE(dest, exchange) \ InterlockedExchange((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(exchange)) # define BOOST_INTERLOCKED_EXCHANGE_ADD(dest, add) \ InterlockedExchangeAdd((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(add)) #endif // _WIN32_WCE >= 0x600 # define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) \ ((void)BOOST_INTERLOCKED_COMPARE_EXCHANGE((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(exchange), (BOOST_INTERLOCKED_LONG32)(compare))) # define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest, exchange) \ ((void)BOOST_INTERLOCKED_EXCHANGE((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(exchange))) #elif defined( BOOST_MSVC ) \|\| defined( BOOST_INTEL_WIN ) # if defined( __CLRCALL_PURE_OR_CDECL ) # define BOOST_INTERLOCKED_CLRCALL_PURE_OR_CDECL __CLRCALL_PURE_OR_CDECL # else # define BOOST_INTERLOCKED_CLRCALL_PURE_OR_CDECL __cdecl # endif extern "C" BOOST_INTERLOCKED_LONG32 BOOST_INTERLOCKED_CLRCALL_PURE_OR_CDECL _InterlockedIncrement( BOOST_INTERLOCKED_LONG32 volatile * ); extern "C" BOOST_INTERLOCKED_LONG32 BOOST_INTERLOCKED_CLRCALL_PURE_OR_CDECL _InterlockedDecrement( BOOST_INTERLOCKED_LONG32 volatile * ); extern "C" BOOST_INTERLOCKED_LONG32 BOOST_INTERLOCKED_CLRCALL_PURE_OR_CDECL _InterlockedCompareExchange( BOOST_INTERLOCKED_LONG32 volatile , BOOST_INTERLOCKED_LONG32, BOOST_INTERLOCKED_LONG32 ); extern "C" BOOST_INTERLOCKED_LONG32 BOOST_INTERLOCKED_CLRCALL_PURE_OR_CDECL _InterlockedExchange( BOOST_INTERLOCKED_LONG32 volatile , BOOST_INTERLOCKED_LONG32 ); extern "C" BOOST_INTERLOCKED_LONG32 BOOST_INTERLOCKED_CLRCALL_PURE_OR_CDECL _InterlockedExchangeAdd( BOOST_INTERLOCKED_LONG32 volatile , BOOST_INTERLOCKED_LONG32 ); # if defined( BOOST_MSVC ) && BOOST_MSVC >= 1310 # pragma intrinsic( _InterlockedIncrement ) # pragma intrinsic( _InterlockedDecrement ) # pragma intrinsic( _InterlockedCompareExchange ) # pragma intrinsic( _InterlockedExchange ) # pragma intrinsic( _InterlockedExchangeAdd ) # endif # if defined(_M_IA64) \|\| defined(_M_AMD64) \|\| defined(_M_ARM64) extern "C" void BOOST_INTERLOCKED_CLRCALL_PURE_OR_CDECL _InterlockedCompareExchangePointer( void* volatile , void, void* ); extern "C" void* BOOST_INTERLOCKED_CLRCALL_PURE_OR_CDECL _InterlockedExchangePointer( void* volatile , void ); # if defined( BOOST_MSVC ) && BOOST_MSVC >= 1310 # pragma intrinsic( _InterlockedCompareExchangePointer ) # pragma intrinsic( _InterlockedExchangePointer ) # endif # define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) \ _InterlockedCompareExchangePointer((void*)(dest), (void)(exchange), (void)(compare)) # define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest, exchange) \ _InterlockedExchangePointer((void)(dest), (void)(exchange)) # else # define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) \ ((void)BOOST_INTERLOCKED_COMPARE_EXCHANGE((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(exchange), (BOOST_INTERLOCKED_LONG32)(compare))) # define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest, exchange) \ ((void)BOOST_INTERLOCKED_EXCHANGE((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(exchange))) # endif # undef BOOST_INTERLOCKED_CLRCALL_PURE_OR_CDECL # define BOOST_INTERLOCKED_INCREMENT(dest) \ _InterlockedIncrement((BOOST_INTERLOCKED_LONG32)(dest)) # define BOOST_INTERLOCKED_DECREMENT(dest) \ _InterlockedDecrement((BOOST_INTERLOCKED_LONG32)(dest)) # define BOOST_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) \ _InterlockedCompareExchange((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(exchange), (BOOST_INTERLOCKED_LONG32)(compare)) # define BOOST_INTERLOCKED_EXCHANGE(dest, exchange) \ _InterlockedExchange((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(exchange)) # define BOOST_INTERLOCKED_EXCHANGE_ADD(dest, add) \ _InterlockedExchangeAdd((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(add)) #elif defined( WIN32 ) \|\| defined( _WIN32 ) \|\| defined( __WIN32__ ) #define BOOST_INTERLOCKED_IMPORT __declspec(dllimport) namespace boost { namespace detail { extern "C" BOOST_INTERLOCKED_IMPORT BOOST_INTERLOCKED_LONG32 __stdcall InterlockedIncrement( BOOST_INTERLOCKED_LONG32 volatile ); extern "C" BOOST_INTERLOCKED_IMPORT BOOST_INTERLOCKED_LONG32 __stdcall InterlockedDecrement( BOOST_INTERLOCKED_LONG32 volatile * ); extern "C" BOOST_INTERLOCKED_IMPORT BOOST_INTERLOCKED_LONG32 __stdcall InterlockedCompareExchange( BOOST_INTERLOCKED_LONG32 volatile , BOOST_INTERLOCKED_LONG32, BOOST_INTERLOCKED_LONG32 ); extern "C" BOOST_INTERLOCKED_IMPORT BOOST_INTERLOCKED_LONG32 __stdcall InterlockedExchange( BOOST_INTERLOCKED_LONG32 volatile , BOOST_INTERLOCKED_LONG32 ); extern "C" BOOST_INTERLOCKED_IMPORT BOOST_INTERLOCKED_LONG32 __stdcall InterlockedExchangeAdd( BOOST_INTERLOCKED_LONG32 volatile , BOOST_INTERLOCKED_LONG32 ); # if defined(_M_IA64) \|\| defined(_M_AMD64) \|\| defined(_M_ARM64) extern "C" BOOST_INTERLOCKED_IMPORT void __stdcall InterlockedCompareExchangePointer( void* volatile , void, void* ); extern "C" BOOST_INTERLOCKED_IMPORT void* __stdcall InterlockedExchangePointer( void* volatile , void ); # endif } // namespace detail } // namespace boost # define BOOST_INTERLOCKED_INCREMENT(dest) \ ::boost::detail::InterlockedIncrement((BOOST_INTERLOCKED_LONG32)(dest)) # define BOOST_INTERLOCKED_DECREMENT(dest) \ ::boost::detail::InterlockedDecrement((BOOST_INTERLOCKED_LONG32)(dest)) # define BOOST_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) \ ::boost::detail::InterlockedCompareExchange((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(exchange), (BOOST_INTERLOCKED_LONG32)(compare)) # define BOOST_INTERLOCKED_EXCHANGE(dest, exchange) \ ::boost::detail::InterlockedExchange((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(exchange)) # define BOOST_INTERLOCKED_EXCHANGE_ADD(dest, add) \ ::boost::detail::InterlockedExchangeAdd((BOOST_INTERLOCKED_LONG32)(dest), (BOOST_INTERLOCKED_LONG32)(add)) # if defined(_M_IA64) \|\| defined(_M_AMD64) \|\| defined(_M_ARM64) # define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) \ ::boost::detail::InterlockedCompareExchangePointer((void)(dest), (void)(exchange), (void)(compare)) # define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest, exchange) \ ::boost::detail::InterlockedExchangePointer((void)(dest), (void)(exchange)) # else # define BOOST_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) \ ((void)BOOST_INTERLOCKED_COMPARE_EXCHANGE((BOOST_INTERLOCKED_LONG32 volatile)(dest),(BOOST_INTERLOCKED_LONG32)(exchange),(BOOST_INTERLOCKED_LONG32)(compare))) # define BOOST_INTERLOCKED_EXCHANGE_POINTER(dest, exchange) \ ((void)BOOST_INTERLOCKED_EXCHANGE((BOOST_INTERLOCKED_LONG32)(dest),(BOOST_INTERLOCKED_LONG32)(exchange))) # endif #else # error "Interlocked intrinsics not available" #endif #endif // #ifndef BOOST_DETAIL_INTERLOCKED_HPP_INCLUDED PK��]�[e7Y��allocator_utilities.hppnu��[��/* Copyright 2003-2013 Joaquin M Lopez Munoz. * 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) * * See Boost website at http://www.boost.org/ / #ifndef BOOST_DETAIL_ALLOCATOR_UTILITIES_HPP #define BOOST_DETAIL_ALLOCATOR_UTILITIES_HPP #include <boost/config.hpp> / keep it first to prevent nasty warns in MSVC / #include <boost/detail/workaround.hpp> #include <boost/detail/select_type.hpp> #include <boost/type_traits/is_same.hpp> #include <cstddef> #include <memory> #include <new> namespace boost{ namespace detail{ / Allocator adaption layer. Some stdlibs provide allocators without rebind * and template ctors. These facilities are simulated with the external * template class rebind_to and the aid of partial_std_allocator_wrapper. / namespace allocator{ / partial_std_allocator_wrapper inherits the functionality of a std * allocator while providing a templatized ctor and other bits missing * in some stdlib implementation or another. / template<typename Type> class partial_std_allocator_wrapper:public std::allocator<Type> { public: / Oddly enough, STLport does not define std::allocator<void>::value_type * when configured to work without partial template specialization. * No harm in supplying the definition here unconditionally. / typedef Type value_type; partial_std_allocator_wrapper(){} template<typename Other> partial_std_allocator_wrapper(const partial_std_allocator_wrapper<Other>&){} partial_std_allocator_wrapper(const std::allocator<Type>& x): std::allocator<Type>(x) { } #if defined(BOOST_DINKUMWARE_STDLIB) / Dinkumware guys didn't provide a means to call allocate() without * supplying a hint, in disagreement with the standard. / Type allocate(std::size_t n,const void* hint=0) { std::allocator<Type>& a=this; return a.allocate(n,hint); } #endif }; / Detects whether a given allocator belongs to a defective stdlib not * having the required member templates. * Note that it does not suffice to check the Boost.Config stdlib * macros, as the user might have passed a custom, compliant allocator. * The checks also considers partial_std_allocator_wrapper to be * a standard defective allocator. / #if defined(BOOST_NO_STD_ALLOCATOR)&&\ (defined(BOOST_HAS_PARTIAL_STD_ALLOCATOR)\|\|defined(BOOST_DINKUMWARE_STDLIB)) template<typename Allocator> struct is_partial_std_allocator { BOOST_STATIC_CONSTANT(bool, value= (is_same< std::allocator<BOOST_DEDUCED_TYPENAME Allocator::value_type>, Allocator >::value)\|\| (is_same< partial_std_allocator_wrapper< BOOST_DEDUCED_TYPENAME Allocator::value_type>, Allocator >::value)); }; #else template<typename Allocator> struct is_partial_std_allocator { BOOST_STATIC_CONSTANT(bool,value=false); }; #endif / rebind operations for defective std allocators / template<typename Allocator,typename Type> struct partial_std_allocator_rebind_to { typedef partial_std_allocator_wrapper<Type> type; }; / rebind operation in all other cases / template<typename Allocator> struct rebinder { template<typename Type> struct result { #ifdef BOOST_NO_CXX11_ALLOCATOR typedef typename Allocator::BOOST_NESTED_TEMPLATE rebind<Type>::other other; #else typedef typename std::allocator_traits<Allocator>::BOOST_NESTED_TEMPLATE rebind_alloc<Type> other; #endif }; }; template<typename Allocator,typename Type> struct compliant_allocator_rebind_to { typedef typename rebinder<Allocator>:: BOOST_NESTED_TEMPLATE result<Type>::other type; }; / rebind front-end / template<typename Allocator,typename Type> struct rebind_to: boost::detail::if_true< is_partial_std_allocator<Allocator>::value >::template then< partial_std_allocator_rebind_to<Allocator,Type>, compliant_allocator_rebind_to<Allocator,Type> >::type { }; / allocator-independent versions of construct and destroy / template<typename Type> void construct(void p,const Type& t) { new (p) Type(t); } #if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1500)) /* MSVC++ issues spurious warnings about unreferencend formal parameters * in destroy<Type> when Type is a class with trivial dtor. / #pragma warning(push) #pragma warning(disable:4100) #endif template<typename Type> void destroy(const Type p) { #if BOOST_WORKAROUND(__SUNPRO_CC,BOOST_TESTED_AT(0x590)) const_cast<Type>(p)->~Type(); #else p->~Type(); #endif } #if BOOST_WORKAROUND(BOOST_MSVC,BOOST_TESTED_AT(1500)) #pragma warning(pop) #endif } / namespace boost::detail::allocator / } / namespace boost::detail / } / namespace boost / #endif PK��]�[�<N�� is_sorted.hppnu��[��/============================================================================== Copyright (c) 2010-2011 Bryce Lelbach 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_DETAIL_SORTED_HPP #define BOOST_DETAIL_SORTED_HPP #include <iterator> #include <functional> namespace boost { namespace detail { template<class Iterator, class Comp> inline Iterator is_sorted_until (Iterator first, Iterator last, Comp c) { if (first == last) return last; Iterator it = first; ++it; for (; it != last; first = it, ++it) if (c(it, first)) return it; return it; } template<class Iterator> inline Iterator is_sorted_until (Iterator first, Iterator last) { typedef typename std::iterator_traits<Iterator>::value_type value_type; typedef std::less<value_type> c; return ::boost::detail::is_sorted_until(first, last, c()); } template<class Iterator, class Comp> inline bool is_sorted (Iterator first, Iterator last, Comp c) { return ::boost::detail::is_sorted_until(first, last, c) == last; } template<class Iterator> inline bool is_sorted (Iterator first, Iterator last) { return ::boost::detail::is_sorted_until(first, last) == last; } } // detail } // boost #endif // BOOST_DETAIL_SORTED_HPP PK��]�[�]��scoped_enum_emulation.hppnu��[��/ * Copyright (c) 2014 Andrey Semashev * * 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_DETAIL_SCOPED_ENUM_EMULATION_HPP #define BOOST_DETAIL_SCOPED_ENUM_EMULATION_HPP // The header file at this path is deprecated; // use boost/core/scoped_enum.hpp instead. #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/core/scoped_enum.hpp>") #include <boost/core/scoped_enum.hpp> #endif PK��]�[uf?u��named_template_params.hppnu��[��// (C) Copyright Jeremy Siek 2001. // 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) // Revision History: // 04 Oct 2001 David Abrahams // Changed name of "bind" to "select" to avoid problems with MSVC. #ifndef BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP #define BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP #include <boost/config.hpp> #include <boost/type_traits/conversion_traits.hpp> #include <boost/type_traits/composite_traits.hpp> // for is_reference #if defined(BOOST_BORLANDC) #include <boost/type_traits/ice.hpp> #endif namespace boost { namespace detail { struct default_argument { }; struct dummy_default_gen { template <class Base, class Traits> struct select { typedef default_argument type; }; }; // This class template is a workaround for MSVC. template <class Gen> struct default_generator { typedef detail::dummy_default_gen type; }; template <class T> struct is_default { enum { value = false }; typedef type_traits::no_type type; }; template <> struct is_default<default_argument> { enum { value = true }; typedef type_traits::yes_type type; }; struct choose_default { template <class Arg, class DefaultGen, class Base, class Traits> struct select { typedef typename default_generator<DefaultGen>::type Gen; typedef typename Gen::template select<Base,Traits>::type type; }; }; struct choose_arg { template <class Arg, class DefaultGen, class Base, class Traits> struct select { typedef Arg type; }; }; #if defined(BOOST_BORLANDC) template <class UseDefault> struct choose_arg_or_default { typedef choose_arg type; }; template <> struct choose_arg_or_default<type_traits::yes_type> { typedef choose_default type; }; #else template <bool UseDefault> struct choose_arg_or_default { typedef choose_arg type; }; template <> struct choose_arg_or_default<true> { typedef choose_default type; }; #endif template <class Arg, class DefaultGen, class Base, class Traits> class resolve_default { #if defined(BOOST_BORLANDC) typedef typename choose_arg_or_default<typename is_default<Arg>::type>::type Selector; #else // This usually works for Borland, but I'm seeing weird errors in // iterator_adaptor_test.cpp when using this method. enum { is_def = is_default<Arg>::value }; typedef typename choose_arg_or_default<is_def>::type Selector; #endif public: typedef typename Selector ::template select<Arg, DefaultGen, Base, Traits>::type type; }; // To differentiate an unnamed parameter from a traits generator // we use is_convertible<X, iter_traits_gen_base>. struct named_template_param_base { }; template <class X> struct is_named_param_list { enum { value = is_convertible<X, named_template_param_base>::value }; }; struct choose_named_params { template <class Prev> struct select { typedef Prev type; }; }; struct choose_default_arg { template <class Prev> struct select { typedef detail::default_argument type; }; }; template <bool Named> struct choose_default_dispatch_; template <> struct choose_default_dispatch_<true> { typedef choose_named_params type; }; template <> struct choose_default_dispatch_<false> { typedef choose_default_arg type; }; // The use of inheritance here is a Solaris Forte 6 workaround. template <bool Named> struct choose_default_dispatch : public choose_default_dispatch_<Named> { }; template <class PreviousArg> struct choose_default_argument { enum { is_named = is_named_param_list<PreviousArg>::value }; typedef typename choose_default_dispatch<is_named>::type Selector; typedef typename Selector::template select<PreviousArg>::type type; }; // This macro assumes that there is a class named default_##TYPE // defined before the application of the macro. This class should // have a single member class template named "select" with two // template parameters: the type of the class being created (e.g., // the iterator_adaptor type when creating iterator adaptors) and // a traits class. The select class should have a single typedef // named "type" that produces the default for TYPE. See // boost/iterator_adaptors.hpp for an example usage. Also, // applications of this macro must be placed in namespace // boost::detail. #define BOOST_NAMED_TEMPLATE_PARAM(TYPE) \ struct get_##TYPE##_from_named { \ template <class Base, class NamedParams, class Traits> \ struct select { \ typedef typename NamedParams::traits NamedTraits; \ typedef typename NamedTraits::TYPE TYPE; \ typedef typename resolve_default<TYPE, \ default_##TYPE, Base, NamedTraits>::type type; \ }; \ }; \ struct pass_thru_##TYPE { \ template <class Base, class Arg, class Traits> struct select { \ typedef typename resolve_default<Arg, \ default_##TYPE, Base, Traits>::type type; \ };\ }; \ template <int NamedParam> \ struct get_##TYPE##_dispatch { }; \ template <> struct get_##TYPE##_dispatch<1> { \ typedef get_##TYPE##_from_named type; \ }; \ template <> struct get_##TYPE##_dispatch<0> { \ typedef pass_thru_##TYPE type; \ }; \ template <class Base, class X, class Traits> \ class get_##TYPE { \ enum { is_named = is_named_param_list<X>::value }; \ typedef typename get_##TYPE##_dispatch<is_named>::type Selector; \ public: \ typedef typename Selector::template select<Base, X, Traits>::type type; \ }; \ template <> struct default_generator<default_##TYPE> { \ typedef default_##TYPE type; \ } } // namespace detail } // namespace boost #endif // BOOST_DETAIL_NAMED_TEMPLATE_PARAMS_HPP PK��]�[�"�v��v�� algorithm.hppnu��[��// (C) Copyright Jeremy Siek 2001. // Distributed under the Boost Software License, Version 1.0. (See accompany- // ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) / * * Copyright (c) 1994 * Hewlett-Packard Company * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Hewlett-Packard Company makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. * * * Copyright (c) 1996 * Silicon Graphics Computer Systems, Inc. * * Permission to use, copy, modify, distribute and sell this software * and its documentation for any purpose is hereby granted without fee, * provided that the above copyright notice appear in all copies and * that both that copyright notice and this permission notice appear * in supporting documentation. Silicon Graphics makes no * representations about the suitability of this software for any * purpose. It is provided "as is" without express or implied warranty. / #ifndef BOOST_ALGORITHM_HPP #define BOOST_ALGORITHM_HPP #include <boost/detail/iterator.hpp> // Algorithms on sequences // // The functions in this file have not yet gone through formal // review, and are subject to change. This is a work in progress. // They have been checked into the detail directory because // there are some graph algorithms that use these functions. #include <algorithm> #include <vector> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/algorithm/copy.hpp> #include <boost/range/algorithm/equal.hpp> #include <boost/range/algorithm/sort.hpp> #include <boost/range/algorithm/stable_sort.hpp> #include <boost/range/algorithm/find_if.hpp> #include <boost/range/algorithm/count.hpp> #include <boost/range/algorithm/count_if.hpp> #include <boost/range/algorithm_ext/is_sorted.hpp> #include <boost/range/algorithm_ext/iota.hpp> namespace boost { template < typename InputIterator, typename Predicate > bool any_if(InputIterator first, InputIterator last, Predicate p) { return std::find_if(first, last, p) != last; } template < typename Container, typename Predicate > bool any_if(const Container& c, Predicate p) { return any_if(boost::begin(c), boost::end(c), p); } template < typename InputIterator, typename T > bool container_contains(InputIterator first, InputIterator last, T value) { return std::find(first, last, value) != last; } template < typename Container, typename T > bool container_contains(const Container& c, const T& value) { return container_contains(boost::begin(c), boost::end(c), value); } } // namespace boost #endif // BOOST_ALGORITHM_HPP PK��]�[��λz��z��iterator.hppnu��[��// (C) Copyright David Abrahams 2002. // 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 ITERATOR_DWA122600_HPP_ #define ITERATOR_DWA122600_HPP_ // This header is obsolete and deprecated. #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<iterator>") #include <iterator> #if defined(__SUNPRO_CC) && (defined(__SGI_STL_PORT) \|\| defined(_STLPORT_VERSION)) #include <cstddef> #endif namespace boost { namespace detail { using std::iterator_traits; using std::distance; #if defined(__SUNPRO_CC) && (defined(__SGI_STL_PORT) \|\| defined(_STLPORT_VERSION)) // std::distance from stlport with Oracle compiler 12.4 and 12.5 fails to deduce template parameters // when one of the arguments is an array and the other one is a pointer. template< typename T, std::size_t N > inline typename std::iterator_traits< T >::difference_type distance(T (&left)[N], T* right) { return std::distance(static_cast< T* >(left), right); } #endif } // namespace detail } // namespace boost #endif // ITERATOR_DWA122600_HPP_ PK��]�[j�~��lightweight_test.hppnu��[��/* * Copyright (c) 2014 Glen Fernandes * * 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_DETAIL_LIGHTWEIGHT_TEST_HPP #define BOOST_DETAIL_LIGHTWEIGHT_TEST_HPP // The header file at this path is deprecated; // use boost/core/lightweight_test.hpp instead. #include <boost/core/lightweight_test.hpp> #endif PK��]�[� ��j��j��select_type.hppnu��[��// (C) Copyright David Abrahams 2001. // 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) // // See http://www.boost.org for most recent version including documentation. // Revision History // 09 Feb 01 Applied John Maddock's Borland patch Moving <true> // specialization to unspecialized template (David Abrahams) // 06 Feb 01 Created (David Abrahams) #ifndef SELECT_TYPE_DWA20010206_HPP # define SELECT_TYPE_DWA20010206_HPP namespace boost { namespace detail { // Template class if_true -- select among 2 types based on a bool constant expression // Usage: // typename if_true<(bool_const_expression)>::template then<true_type, false_type>::type // HP aCC cannot deal with missing names for template value parameters template <bool b> struct if_true { template <class T, class F> struct then { typedef T type; }; }; template <> struct if_true<false> { template <class T, class F> struct then { typedef F type; }; }; }} #endif // SELECT_TYPE_DWA20010206_HPP PK��]�[r��5� �� reference_content.hppnu��[��//----------------------------------------------------------------------------- // boost detail/reference_content.hpp header file // See http://www.boost.org for updates, documentation, and revision history. //----------------------------------------------------------------------------- // // Copyright (c) 2003 // Eric Friedman // // 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_DETAIL_REFERENCE_CONTENT_HPP #define BOOST_DETAIL_REFERENCE_CONTENT_HPP #include "boost/config.hpp" # include "boost/type_traits/integral_constant.hpp" # include "boost/type_traits/has_nothrow_copy.hpp" namespace boost { namespace detail { struct void_type {}; /////////////////////////////////////////////////////////////////////////////// // (detail) class template reference_content // // Non-Assignable wrapper for references. // template <typename RefT> class reference_content { private: // representation RefT content_; public: // structors ~reference_content() { } reference_content(RefT r) : content_( r ) { } reference_content(const reference_content& operand) : content_( operand.content_ ) { } private: // non-Assignable reference_content& operator=(const reference_content&); public: // queries RefT get() const { return content_; } }; /////////////////////////////////////////////////////////////////////////////// // (detail) metafunction make_reference_content // // Wraps with reference_content if specified type is reference. // template <typename T = void_type> struct make_reference_content; template <typename T> struct make_reference_content { typedef T type; }; template <typename T> struct make_reference_content< T& > { typedef reference_content<T&> type; }; template <> struct make_reference_content< void_type > { template <typename T> struct apply : make_reference_content<T> { }; typedef void_type type; }; } // namespace detail /////////////////////////////////////////////////////////////////////////////// // reference_content<T&> type traits specializations // template <typename T> struct has_nothrow_copy< ::boost::detail::reference_content< T& > > : boost::true_type { }; } // namespace boost #endif // BOOST_DETAIL_REFERENCE_CONTENT_HPP PK��]�[��h(��(��container_fwd.hppnu��[�� // Copyright 2005-2011 Daniel James. // 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) // Note: if you change this include guard, you also need to change // container_fwd_compile_fail.cpp #if !defined(BOOST_DETAIL_CONTAINER_FWD_HPP) #define BOOST_DETAIL_CONTAINER_FWD_HPP #if defined(_MSC_VER) && \ !defined(BOOST_DETAIL_TEST_CONFIG_ONLY) # pragma once #endif #include <boost/config.hpp> #include <boost/detail/workaround.hpp> //////////////////////////////////////////////////////////////////////////////// // // // Define BOOST_DETAIL_NO_CONTAINER_FWD if you don't want this header to // // forward declare standard containers. // // // // BOOST_DETAIL_CONTAINER_FWD to make it foward declare containers even if it // // normally doesn't. // // // // BOOST_DETAIL_NO_CONTAINER_FWD overrides BOOST_DETAIL_CONTAINER_FWD. // // // //////////////////////////////////////////////////////////////////////////////// #if !defined(BOOST_DETAIL_NO_CONTAINER_FWD) # if defined(BOOST_DETAIL_CONTAINER_FWD) // Force forward declarations. # elif defined(__SGI_STL_PORT) \|\| defined(_STLPORT_VERSION) // STLport # define BOOST_DETAIL_NO_CONTAINER_FWD # elif defined(__LIBCOMO__) // Comeau STL: # define BOOST_DETAIL_NO_CONTAINER_FWD # elif defined(__STD_RWCOMPILER_H__) \|\| defined(_RWSTD_VER) // Rogue Wave library: # define BOOST_DETAIL_NO_CONTAINER_FWD # elif defined(_LIBCPP_VERSION) // libc++ # define BOOST_DETAIL_NO_CONTAINER_FWD # elif defined(__GLIBCPP__) \|\| defined(__GLIBCXX__) // GNU libstdc++ 3 // // Disable forwarding for all recent versions, as the library has a // versioned namespace mode, and I don't know how to detect it. # if __GLIBCXX__ >= 20070513 \ \|\| defined(_GLIBCXX_DEBUG) \ \|\| defined(_GLIBCXX_PARALLEL) \ \|\| defined(_GLIBCXX_PROFILE) # define BOOST_DETAIL_NO_CONTAINER_FWD # else # if defined(__GLIBCXX__) && __GLIBCXX__ >= 20040530 # define BOOST_CONTAINER_FWD_COMPLEX_STRUCT # endif # endif # elif defined(__STL_CONFIG_H) // generic SGI STL // // Forward declaration seems to be okay, but it has a couple of odd // implementations. # define BOOST_CONTAINER_FWD_BAD_BITSET # if !defined(__STL_NON_TYPE_TMPL_PARAM_BUG) # define BOOST_CONTAINER_FWD_BAD_DEQUE # endif # elif defined(__MSL_CPP__) // MSL standard lib: # define BOOST_DETAIL_NO_CONTAINER_FWD # elif defined(__IBMCPP__) // The default VACPP std lib, forward declaration seems to be fine. # elif defined(MSIPL_COMPILE_H) // Modena C++ standard library # define BOOST_DETAIL_NO_CONTAINER_FWD # elif (defined(_YVALS) && !defined(__IBMCPP__)) \|\| defined(_CPPLIB_VER) // Dinkumware Library (this has to appear after any possible replacement // libraries) # else # define BOOST_DETAIL_NO_CONTAINER_FWD # endif #endif #if !defined(BOOST_DETAIL_TEST_CONFIG_ONLY) #if defined(BOOST_DETAIL_NO_CONTAINER_FWD) && \ !defined(BOOST_DETAIL_TEST_FORCE_CONTAINER_FWD) #include <deque> #include <list> #include <vector> #include <map> #include <set> #include <bitset> #include <string> #include <complex> #else #include <cstddef> #if defined(BOOST_CONTAINER_FWD_BAD_DEQUE) #include <deque> #endif #if defined(BOOST_CONTAINER_FWD_BAD_BITSET) #include <bitset> #endif #if defined(BOOST_MSVC) #pragma warning(push) #pragma warning(disable:4099) // struct/class mismatch in fwd declarations #endif namespace std { template <class T> class allocator; template <class charT, class traits, class Allocator> class basic_string; template <class charT> struct char_traits; #if defined(BOOST_CONTAINER_FWD_COMPLEX_STRUCT) template <class T> struct complex; #else template <class T> class complex; #endif #if !defined(BOOST_CONTAINER_FWD_BAD_DEQUE) template <class T, class Allocator> class deque; #endif template <class T, class Allocator> class list; template <class T, class Allocator> class vector; template <class Key, class T, class Compare, class Allocator> class map; template <class Key, class T, class Compare, class Allocator> class multimap; template <class Key, class Compare, class Allocator> class set; template <class Key, class Compare, class Allocator> class multiset; #if !defined(BOOST_CONTAINER_FWD_BAD_BITSET) template <size_t N> class bitset; #endif template <class T1, class T2> struct pair; } #if defined(BOOST_MSVC) #pragma warning(pop) #endif #endif // BOOST_DETAIL_NO_CONTAINER_FWD && // !defined(BOOST_DETAIL_TEST_FORCE_CONTAINER_FWD) #endif // BOOST_DETAIL_TEST_CONFIG_ONLY #endif PK��]�[_��jB��jB��compressed_pair.hppnu��[��// (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. // Use, modification and distribution are subject to 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). // // See http://www.boost.org/libs/utility for most recent version including documentation. // compressed_pair: pair that "compresses" empty members // (see libs/utility/doc/html/compressed_pair.html) // // JM changes 25 Jan 2004: // For the case where T1 == T2 and both are empty, then first() and second() // should return different objects. // JM changes 25 Jan 2000: // Removed default arguments from compressed_pair_switch to get // C++ Builder 4 to accept them // rewriten swap to get gcc and C++ builder to compile. // added partial specialisations for case T1 == T2 to avoid duplicate constructor defs. #ifndef BOOST_DETAIL_COMPRESSED_PAIR_HPP #define BOOST_DETAIL_COMPRESSED_PAIR_HPP #include <algorithm> #include <boost/type_traits/remove_cv.hpp> #include <boost/type_traits/is_empty.hpp> #include <boost/type_traits/is_final.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/call_traits.hpp> #ifdef BOOST_MSVC # pragma warning(push) # pragma warning(disable:4512) #endif namespace boost { template <class T1, class T2> class compressed_pair; // compressed_pair namespace details { template<class T, bool E = boost::is_final<T>::value> struct compressed_pair_empty : ::boost::false_type { }; template<class T> struct compressed_pair_empty<T, false> : ::boost::is_empty<T> { }; // JM altered 26 Jan 2000: template <class T1, class T2, bool IsSame, bool FirstEmpty, bool SecondEmpty> struct compressed_pair_switch; template <class T1, class T2> struct compressed_pair_switch<T1, T2, false, false, false> {static const int value = 0;}; template <class T1, class T2> struct compressed_pair_switch<T1, T2, false, true, true> {static const int value = 3;}; template <class T1, class T2> struct compressed_pair_switch<T1, T2, false, true, false> {static const int value = 1;}; template <class T1, class T2> struct compressed_pair_switch<T1, T2, false, false, true> {static const int value = 2;}; template <class T1, class T2> struct compressed_pair_switch<T1, T2, true, true, true> {static const int value = 4;}; template <class T1, class T2> struct compressed_pair_switch<T1, T2, true, false, false> {static const int value = 5;}; template <class T1, class T2, int Version> class compressed_pair_imp; #ifdef __GNUC__ // workaround for GCC (JM): using std::swap; #endif // // can't call unqualified swap from within classname::swap // as Koenig lookup rules will find only the classname::swap // member function not the global declaration, so use cp_swap // as a forwarding function (JM): template <typename T> inline void cp_swap(T& t1, T& t2) { #ifndef __GNUC__ using std::swap; #endif swap(t1, t2); } // 0 derive from neither template <class T1, class T2> class compressed_pair_imp<T1, T2, 0> { public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits<first_type>::param_type first_param_type; typedef typename call_traits<second_type>::param_type second_param_type; typedef typename call_traits<first_type>::reference first_reference; typedef typename call_traits<second_type>::reference second_reference; typedef typename call_traits<first_type>::const_reference first_const_reference; typedef typename call_traits<second_type>::const_reference second_const_reference; compressed_pair_imp() {} compressed_pair_imp(first_param_type x, second_param_type y) : first_(x), second_(y) {} compressed_pair_imp(first_param_type x) : first_(x) {} compressed_pair_imp(second_param_type y) : second_(y) {} first_reference first() {return first_;} first_const_reference first() const {return first_;} second_reference second() {return second_;} second_const_reference second() const {return second_;} void swap(::boost::compressed_pair<T1, T2>& y) { cp_swap(first_, y.first()); cp_swap(second_, y.second()); } private: first_type first_; second_type second_; }; // 1 derive from T1 template <class T1, class T2> class compressed_pair_imp<T1, T2, 1> : protected ::boost::remove_cv<T1>::type { public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits<first_type>::param_type first_param_type; typedef typename call_traits<second_type>::param_type second_param_type; typedef typename call_traits<first_type>::reference first_reference; typedef typename call_traits<second_type>::reference second_reference; typedef typename call_traits<first_type>::const_reference first_const_reference; typedef typename call_traits<second_type>::const_reference second_const_reference; compressed_pair_imp() {} compressed_pair_imp(first_param_type x, second_param_type y) : first_type(x), second_(y) {} compressed_pair_imp(first_param_type x) : first_type(x) {} compressed_pair_imp(second_param_type y) : second_(y) {} first_reference first() {return this;} first_const_reference first() const {return this;} second_reference second() {return second_;} second_const_reference second() const {return second_;} void swap(::boost::compressed_pair<T1,T2>& y) { // no need to swap empty base class: cp_swap(second_, y.second()); } private: second_type second_; }; // 2 derive from T2 template <class T1, class T2> class compressed_pair_imp<T1, T2, 2> : protected ::boost::remove_cv<T2>::type { public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits<first_type>::param_type first_param_type; typedef typename call_traits<second_type>::param_type second_param_type; typedef typename call_traits<first_type>::reference first_reference; typedef typename call_traits<second_type>::reference second_reference; typedef typename call_traits<first_type>::const_reference first_const_reference; typedef typename call_traits<second_type>::const_reference second_const_reference; compressed_pair_imp() {} compressed_pair_imp(first_param_type x, second_param_type y) : second_type(y), first_(x) {} compressed_pair_imp(first_param_type x) : first_(x) {} compressed_pair_imp(second_param_type y) : second_type(y) {} first_reference first() {return first_;} first_const_reference first() const {return first_;} second_reference second() {return this;} second_const_reference second() const {return this;} void swap(::boost::compressed_pair<T1,T2>& y) { // no need to swap empty base class: cp_swap(first_, y.first()); } private: first_type first_; }; // 3 derive from T1 and T2 template <class T1, class T2> class compressed_pair_imp<T1, T2, 3> : protected ::boost::remove_cv<T1>::type, protected ::boost::remove_cv<T2>::type { public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits<first_type>::param_type first_param_type; typedef typename call_traits<second_type>::param_type second_param_type; typedef typename call_traits<first_type>::reference first_reference; typedef typename call_traits<second_type>::reference second_reference; typedef typename call_traits<first_type>::const_reference first_const_reference; typedef typename call_traits<second_type>::const_reference second_const_reference; compressed_pair_imp() {} compressed_pair_imp(first_param_type x, second_param_type y) : first_type(x), second_type(y) {} compressed_pair_imp(first_param_type x) : first_type(x) {} compressed_pair_imp(second_param_type y) : second_type(y) {} first_reference first() {return this;} first_const_reference first() const {return this;} second_reference second() {return this;} second_const_reference second() const {return this;} // // no need to swap empty bases: void swap(::boost::compressed_pair<T1,T2>&) {} }; // JM // 4 T1 == T2, T1 and T2 both empty // Originally this did not store an instance of T2 at all // but that led to problems beause it meant &x.first() == &x.second() // which is not true for any other kind of pair, so now we store an instance // of T2 just in case the user is relying on first() and second() returning // different objects (albeit both empty). template <class T1, class T2> class compressed_pair_imp<T1, T2, 4> : protected ::boost::remove_cv<T1>::type { public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits<first_type>::param_type first_param_type; typedef typename call_traits<second_type>::param_type second_param_type; typedef typename call_traits<first_type>::reference first_reference; typedef typename call_traits<second_type>::reference second_reference; typedef typename call_traits<first_type>::const_reference first_const_reference; typedef typename call_traits<second_type>::const_reference second_const_reference; compressed_pair_imp() {} compressed_pair_imp(first_param_type x, second_param_type y) : first_type(x), m_second(y) {} compressed_pair_imp(first_param_type x) : first_type(x), m_second(x) {} first_reference first() {return this;} first_const_reference first() const {return this;} second_reference second() {return m_second;} second_const_reference second() const {return m_second;} void swap(::boost::compressed_pair<T1,T2>&) {} private: T2 m_second; }; // 5 T1 == T2 and are not empty: //JM template <class T1, class T2> class compressed_pair_imp<T1, T2, 5> { public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits<first_type>::param_type first_param_type; typedef typename call_traits<second_type>::param_type second_param_type; typedef typename call_traits<first_type>::reference first_reference; typedef typename call_traits<second_type>::reference second_reference; typedef typename call_traits<first_type>::const_reference first_const_reference; typedef typename call_traits<second_type>::const_reference second_const_reference; compressed_pair_imp() {} compressed_pair_imp(first_param_type x, second_param_type y) : first_(x), second_(y) {} compressed_pair_imp(first_param_type x) : first_(x), second_(x) {} first_reference first() {return first_;} first_const_reference first() const {return first_;} second_reference second() {return second_;} second_const_reference second() const {return second_;} void swap(::boost::compressed_pair<T1, T2>& y) { cp_swap(first_, y.first()); cp_swap(second_, y.second()); } private: first_type first_; second_type second_; }; } // details template <class T1, class T2> class compressed_pair : private ::boost::details::compressed_pair_imp<T1, T2, ::boost::details::compressed_pair_switch< T1, T2, ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value, ::boost::details::compressed_pair_empty<T1>::value, ::boost::details::compressed_pair_empty<T2>::value>::value> { private: typedef details::compressed_pair_imp<T1, T2, ::boost::details::compressed_pair_switch< T1, T2, ::boost::is_same<typename remove_cv<T1>::type, typename remove_cv<T2>::type>::value, ::boost::details::compressed_pair_empty<T1>::value, ::boost::details::compressed_pair_empty<T2>::value>::value> base; public: typedef T1 first_type; typedef T2 second_type; typedef typename call_traits<first_type>::param_type first_param_type; typedef typename call_traits<second_type>::param_type second_param_type; typedef typename call_traits<first_type>::reference first_reference; typedef typename call_traits<second_type>::reference second_reference; typedef typename call_traits<first_type>::const_reference first_const_reference; typedef typename call_traits<second_type>::const_reference second_const_reference; compressed_pair() : base() {} compressed_pair(first_param_type x, second_param_type y) : base(x, y) {} explicit compressed_pair(first_param_type x) : base(x) {} explicit compressed_pair(second_param_type y) : base(y) {} first_reference first() {return base::first();} first_const_reference first() const {return base::first();} second_reference second() {return base::second();} second_const_reference second() const {return base::second();} void swap(compressed_pair& y) { base::swap(y); } }; // JM // Partial specialisation for case where T1 == T2: // template <class T> class compressed_pair<T, T> : private details::compressed_pair_imp<T, T, ::boost::details::compressed_pair_switch< T, T, ::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value, ::boost::details::compressed_pair_empty<T>::value, ::boost::details::compressed_pair_empty<T>::value>::value> { private: typedef details::compressed_pair_imp<T, T, ::boost::details::compressed_pair_switch< T, T, ::boost::is_same<typename remove_cv<T>::type, typename remove_cv<T>::type>::value, ::boost::details::compressed_pair_empty<T>::value, ::boost::details::compressed_pair_empty<T>::value>::value> base; public: typedef T first_type; typedef T second_type; typedef typename call_traits<first_type>::param_type first_param_type; typedef typename call_traits<second_type>::param_type second_param_type; typedef typename call_traits<first_type>::reference first_reference; typedef typename call_traits<second_type>::reference second_reference; typedef typename call_traits<first_type>::const_reference first_const_reference; typedef typename call_traits<second_type>::const_reference second_const_reference; compressed_pair() : base() {} compressed_pair(first_param_type x, second_param_type y) : base(x, y) {} #if !(defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)) explicit #endif compressed_pair(first_param_type x) : base(x) {} first_reference first() {return base::first();} first_const_reference first() const {return base::first();} second_reference second() {return base::second();} second_const_reference second() const {return base::second();} void swap(::boost::compressed_pair<T,T>& y) { base::swap(y); } }; template <class T1, class T2> inline void swap(compressed_pair<T1, T2>& x, compressed_pair<T1, T2>& y) { x.swap(y); } } // boost #ifdef BOOST_MSVC # pragma warning(pop) #endif #endif // BOOST_DETAIL_COMPRESSED_PAIR_HPP PK��]�[�&09+��+��lightweight_thread.hppnu��[��#ifndef BOOST_DETAIL_LIGHTWEIGHT_THREAD_HPP_INCLUDED #define BOOST_DETAIL_LIGHTWEIGHT_THREAD_HPP_INCLUDED // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif // boost/detail/lightweight_thread.hpp // // Copyright (c) 2002 Peter Dimov and Multi Media Ltd. // Copyright (c) 2008, 2018 Peter Dimov // // 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 // // // typedef /.../ lw_thread_t; // as pthread_t // template<class F> int lw_thread_create( lw_thread_t & th, F f ); // void lw_thread_join( lw_thread_t th ); #include <boost/smart_ptr/detail/lightweight_thread.hpp> #endif // #ifndef BOOST_DETAIL_LIGHTWEIGHT_THREAD_HPP_INCLUDED PK��]�[��a��a��numeric_traits.hppnu��[��// (C) Copyright David Abrahams 2001, Howard Hinnant 2001. // // 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) // // Template class numeric_traits<Number> -- // // Supplies: // // typedef difference_type -- a type used to represent the difference // between any two values of Number. // // Support: // 1. Not all specializations are supplied // // 2. Use of specializations that are not supplied will cause a // compile-time error // // 3. Users are free to specialize numeric_traits for any type. // // 4. Right now, specializations are only supplied for integer types. // // 5. On implementations which do not supply compile-time constants in // std::numeric_limits<>, only specializations for built-in integer types // are supplied. // // 6. Handling of numbers whose range of representation is at least as // great as boost::intmax_t can cause some differences to be // unrepresentable in difference_type: // // Number difference_type // ------ --------------- // signed Number // unsigned intmax_t // // template <class Number> typename numeric_traits<Number>::difference_type // numeric_distance(Number x, Number y) // computes (y - x), attempting to avoid overflows. // // See http://www.boost.org for most recent version including documentation. // Revision History // 11 Feb 2001 - Use BOOST_STATIC_CONSTANT (David Abrahams) // 11 Feb 2001 - Rolled back ineffective Borland-specific code // (David Abrahams) // 10 Feb 2001 - Rolled in supposed Borland fixes from John Maddock, but // not seeing any improvement yet (David Abrahams) // 06 Feb 2001 - Factored if_true out into boost/detail/select_type.hpp // (David Abrahams) // 23 Jan 2001 - Fixed logic of difference_type selection, which was // completely wack. In the process, added digit_traits<> // to compute the number of digits in intmax_t even when // not supplied by numeric_limits<>. (David Abrahams) // 21 Jan 2001 - Created (David Abrahams) #ifndef BOOST_NUMERIC_TRAITS_HPP_DWA20001901 #define BOOST_NUMERIC_TRAITS_HPP_DWA20001901 #include <cstddef> #include <boost/config.hpp> #include <boost/limits.hpp> #include <boost/cstdint.hpp> #include <boost/type_traits/is_signed.hpp> #include <boost/type_traits/conditional.hpp> #ifdef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS #include <boost/static_assert.hpp> #include <boost/type_traits/is_integral.hpp> #endif namespace boost { namespace detail { #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS // digit_traits - compute the number of digits in a built-in integer // type. Needed for implementations on which numeric_limits is not specialized // for some integer types, like __int128 in libstdc++ (gcc). template <class T, bool IsSpecialized = std::numeric_limits<T>::is_specialized> struct digit_traits { BOOST_STATIC_CONSTANT(int, digits = std::numeric_limits<T>::digits); }; // numeric_limits is not specialized; compute digits from sizeof(T) template <class T> struct digit_traits<T, false> { BOOST_STATIC_CONSTANT(int, digits = ( sizeof(T) std::numeric_limits<unsigned char>::digits - (boost::is_signed<T>::value ? 1 : 0)) ); }; #endif // Template class integer_traits<Integer> -- traits of various integer types // This should probably be rolled into boost::integer_traits one day, but I // need it to work without <limits> template <class Integer> struct integer_traits { #ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS private: typedef Integer integer_type; typedef std::numeric_limits<integer_type> x; public: typedef typename boost::conditional< (int(x::is_signed) && (!int(x::is_bounded) // digits is the number of no-sign bits \|\| (int(x::digits) + 1 >= digit_traits<boost::intmax_t>::digits))), Integer, typename boost::conditional< (int(x::digits) + 1 < digit_traits<signed int>::digits), signed int, typename boost::conditional< (int(x::digits) + 1 < digit_traits<signed long>::digits), signed long, boost::intmax_t >::type >::type >::type difference_type; #else BOOST_STATIC_ASSERT(boost::is_integral<Integer>::value); typedef typename boost::conditional< (sizeof(Integer) >= sizeof(intmax_t)), boost::conditional< (boost::is_signed<Integer>::value), Integer, boost::intmax_t >, boost::conditional< (sizeof(Integer) < sizeof(std::ptrdiff_t)), std::ptrdiff_t, boost::intmax_t > >::type::type difference_type; #endif }; // Right now, only supports integers, but should be expanded. template <class Number> struct numeric_traits { typedef typename integer_traits<Number>::difference_type difference_type; }; template <class Number> inline BOOST_CONSTEXPR typename numeric_traits<Number>::difference_type numeric_distance(Number x, Number y) { typedef typename numeric_traits<Number>::difference_type difference_type; return difference_type(y) - difference_type(x); } }} #endif // BOOST_NUMERIC_TRAITS_HPP_DWA20001901 PK��]�[~��templated_streams.hppnu��[��//----------------------------------------------------------------------------- // boost detail/templated_streams.hpp header file // See http://www.boost.org for updates, documentation, and revision history. //----------------------------------------------------------------------------- // // Copyright (c) 2003 // Eric Friedman // // 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_DETAIL_TEMPLATED_STREAMS_HPP #define BOOST_DETAIL_TEMPLATED_STREAMS_HPP #include "boost/config.hpp" /////////////////////////////////////////////////////////////////////////////// // (detail) BOOST_TEMPLATED_STREAM_* macros // // Provides workaround platforms without stream class templates. // #if !defined(BOOST_NO_STD_LOCALE) #define BOOST_TEMPLATED_STREAM_TEMPLATE(E,T) \ template < typename E , typename T > #define BOOST_TEMPLATED_STREAM_TEMPLATE_ALLOC(E,T,A) \ template < typename E , typename T , typename A > #define BOOST_TEMPLATED_STREAM_ARGS(E,T) \ typename E , typename T #define BOOST_TEMPLATED_STREAM_ARGS_ALLOC(E,T,A) \ typename E , typename T , typename A #define BOOST_TEMPLATED_STREAM_COMMA , #define BOOST_TEMPLATED_STREAM_ELEM(E) E #define BOOST_TEMPLATED_STREAM_TRAITS(T) T #define BOOST_TEMPLATED_STREAM_ALLOC(A) A #define BOOST_TEMPLATED_STREAM(X,E,T) \ BOOST_JOIN(std::basic_,X)< E , T > #define BOOST_TEMPLATED_STREAM_WITH_ALLOC(X,E,T,A) \ BOOST_JOIN(std::basic_,X)< E , T , A > #else // defined(BOOST_NO_STD_LOCALE) #define BOOST_TEMPLATED_STREAM_TEMPLATE(E,T) // #define BOOST_TEMPLATED_STREAM_TEMPLATE_ALLOC(E,T,A) // #define BOOST_TEMPLATED_STREAM_ARGS(E,T) // #define BOOST_TEMPLATED_STREAM_ARGS_ALLOC(E,T,A) // #define BOOST_TEMPLATED_STREAM_COMMA /*/ #define BOOST_TEMPLATED_STREAM_ELEM(E) char #define BOOST_TEMPLATED_STREAM_TRAITS(T) std::char_traits<char> #define BOOST_TEMPLATED_STREAM_ALLOC(A) std::allocator<char> #define BOOST_TEMPLATED_STREAM(X,E,T) \ std::X #define BOOST_TEMPLATED_STREAM_WITH_ALLOC(X,E,T,A) \ std::X #endif // BOOST_NO_STD_LOCALE #endif // BOOST_DETAIL_TEMPLATED_STREAMS_HPP PK��]�[�:+u.��.��utf8_codecvt_facet.hppnu��[��// Copyright (c) 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu) // Andrew Lumsdaine, Indiana University (lums@osl.iu.edu). // Distributed under the Boost Software License, Version 1.0. (See accompany- // ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_UTF8_CODECVT_FACET_HPP #define BOOST_UTF8_CODECVT_FACET_HPP // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 // utf8_codecvt_facet.hpp // This header defines class utf8_codecvt_facet, derived from // std::codecvt<wchar_t, char>, which can be used to convert utf8 data in // files into wchar_t strings in the application. // // The header is NOT STANDALONE, and is not to be included by the USER. // There are at least two libraries which want to use this functionality, and // we want to avoid code duplication. It would be possible to create utf8 // library, but: // - this requires review process first // - in the case, when linking the a library which uses utf8 // (say 'program_options'), user should also link to the utf8 library. // This seems inconvenient, and asking a user to link to an unrevieved // library is strange. // Until the above points are fixed, a library which wants to use utf8 must: // - include this header in one of it's headers or sources // - include the corresponding boost/detail/utf8_codecvt_facet.ipp file in one // of its sources // - before including either file, the library must define // - BOOST_UTF8_BEGIN_NAMESPACE to the namespace declaration that must be used // - BOOST_UTF8_END_NAMESPACE to the code to close the previous namespace // declaration. // - BOOST_UTF8_DECL -- to the code which must be used for all 'exportable' // symbols. // // For example, program_options library might contain: // #define BOOST_UTF8_BEGIN_NAMESPACE <backslash character> // namespace boost { namespace program_options { // #define BOOST_UTF8_END_NAMESPACE }} // #define BOOST_UTF8_DECL BOOST_PROGRAM_OPTIONS_DECL // #include <boost/detail/utf8_codecvt_facet.ipp> // // Essentially, each library will have its own copy of utf8 code, in // different namespaces. // Note:(Robert Ramey). I have made the following alterations in the original // code. // a) Rendered utf8_codecvt<wchar_t, char> with using templates // b) Move longer functions outside class definition to prevent inlining // and make code smaller // c) added on a derived class to permit translation to/from current // locale to utf8 // See http://www.boost.org for updates, documentation, and revision history. // archives stored as text - note these ar templated on the basic // stream templates to accommodate wide (and other?) kind of characters // // note the fact that on libraries without wide characters, ostream is // is not a specialization of basic_ostream which in fact is not defined // in such cases. So we can't use basic_ostream<OStream::char_type> but rather // use two template parameters // // utf8_codecvt_facet // This is an implementation of a std::codecvt facet for translating // from UTF-8 externally to UCS-4. Note that this is not tied to // any specific types in order to allow customization on platforms // where wchar_t is not big enough. // // NOTES: The current implementation jumps through some unpleasant hoops in // order to deal with signed character types. As a std::codecvt_base::result, // it is necessary for the ExternType to be convertible to unsigned char. // I chose not to tie the extern_type explicitly to char. But if any combination // of types other than <wchar_t,char_t> is used, then std::codecvt must be // specialized on those types for this to work. #include <locale> #include <cwchar> // for mbstate_t #include <cstddef> // for std::size_t #include <boost/config.hpp> #include <boost/detail/workaround.hpp> #if defined(BOOST_NO_STDC_NAMESPACE) namespace std { using ::mbstate_t; using ::size_t; } #endif // maximum lenght of a multibyte string #define MB_LENGTH_MAX 8 BOOST_UTF8_BEGIN_NAMESPACE //----------------------------------------------------------------------------// // // // utf8_codecvt_facet // // // // See utf8_codecvt_facet.ipp for the implementation. // //----------------------------------------------------------------------------// #ifndef BOOST_UTF8_DECL #define BOOST_UTF8_DECL #endif struct BOOST_UTF8_DECL utf8_codecvt_facet : public std::codecvt<wchar_t, char, std::mbstate_t> { public: explicit utf8_codecvt_facet(std::size_t no_locale_manage=0); virtual ~utf8_codecvt_facet(); protected: virtual std::codecvt_base::result do_in( std::mbstate_t& state, const char from, const char * from_end, const char * & from_next, wchar_t * to, wchar_t * to_end, wchar_t& to_next ) const; virtual std::codecvt_base::result do_out( std::mbstate_t & state, const wchar_t from, const wchar_t * from_end, const wchar_t* & from_next, char * to, char * to_end, char * & to_next ) const; bool invalid_continuing_octet(unsigned char octet_1) const { return (octet_1 < 0x80\|\| 0xbf< octet_1); } bool invalid_leading_octet(unsigned char octet_1) const { return (0x7f < octet_1 && octet_1 < 0xc0) \|\| (octet_1 > 0xfd); } // continuing octets = octets except for the leading octet static unsigned int get_cont_octet_count(unsigned char lead_octet) { return get_octet_count(lead_octet) - 1; } static unsigned int get_octet_count(unsigned char lead_octet); // How many "continuing octets" will be needed for this word // == total octets - 1. int get_cont_octet_out_count(wchar_t word) const ; virtual bool do_always_noconv() const BOOST_NOEXCEPT_OR_NOTHROW { return false; } // UTF-8 isn't really stateful since we rewind on partial conversions virtual std::codecvt_base::result do_unshift( std::mbstate_t&, char * from, char * /to/, char * & next ) const { next = from; return ok; } virtual int do_encoding() const BOOST_NOEXCEPT_OR_NOTHROW { const int variable_byte_external_encoding=0; return variable_byte_external_encoding; } // How many char objects can I process to get <= max_limit // wchar_t objects? virtual int do_length( std::mbstate_t &, const char * from, const char * from_end, std::size_t max_limit ) const #if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) throw() #endif ; // Nonstandard override virtual int do_length( const std::mbstate_t & s, const char * from, const char * from_end, std::size_t max_limit ) const #if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600)) throw() #endif { return do_length( const_cast<std::mbstate_t &>(s), from, from_end, max_limit ); } // Largest possible value do_length(state,from,from_end,1) could return. virtual int do_max_length() const BOOST_NOEXCEPT_OR_NOTHROW { return 6; // largest UTF-8 encoding of a UCS-4 character } }; BOOST_UTF8_END_NAMESPACE #endif // BOOST_UTF8_CODECVT_FACET_HPP PK��]�[� ҳ��has_default_constructor.hppnu��[�� // (C) Copyright Matthias Troyerk 2006. // Use, modification and distribution are subject to 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). // // See http://www.boost.org/libs/type_traits for most recent version including documentation. #ifndef BOOST_DETAIL_HAS_DEFAULT_CONSTRUCTOR_HPP_INCLUDED #define BOOST_DETAIL_HAS_DEFAULT_CONSTRUCTOR_HPP_INCLUDED #include <boost/type_traits/has_trivial_constructor.hpp> namespace boost { namespace detail { /// type trait to check for a default constructor /// /// The default implementation just checks for a trivial constructor. /// Using some compiler magic it might be possible to provide a better default template <class T> struct has_default_constructor : public has_trivial_constructor<T> {}; } } // namespace boost::detail #endif // BOOST_DETAIL_HAS_DEFAULT_CONSTRUCTOR_HPP_INCLUDED PK��]�[�o��bitmask.hppnu��[��// boost/detail/bitmask.hpp ------------------------------------------------// // Copyright Beman Dawes 2006 // Distributed under the Boost Software License, Version 1.0 // http://www.boost.org/LICENSE_1_0.txt // Usage: enum foo { a=1, b=2, c=4 }; // BOOST_BITMASK( foo ) // // void f( foo arg ); // ... // f( a \| c ); // // See [bitmask.types] in the C++ standard for the formal specification #ifndef BOOST_BITMASK_HPP #define BOOST_BITMASK_HPP #include <boost/config.hpp> #include <boost/cstdint.hpp> #define BOOST_BITMASK(Bitmask) \ \ inline BOOST_CONSTEXPR Bitmask operator\| (Bitmask x , Bitmask y ) \ { return static_cast<Bitmask>( static_cast<boost::int_least32_t>(x) \ \| static_cast<boost::int_least32_t>(y)); } \ \ inline BOOST_CONSTEXPR Bitmask operator& (Bitmask x , Bitmask y ) \ { return static_cast<Bitmask>( static_cast<boost::int_least32_t>(x) \ & static_cast<boost::int_least32_t>(y)); } \ \ inline BOOST_CONSTEXPR Bitmask operator^ (Bitmask x , Bitmask y ) \ { return static_cast<Bitmask>( static_cast<boost::int_least32_t>(x) \ ^ static_cast<boost::int_least32_t>(y)); } \ \ inline BOOST_CONSTEXPR Bitmask operator~ (Bitmask x ) \ { return static_cast<Bitmask>(~static_cast<boost::int_least32_t>(x)); } \ \ inline Bitmask & operator&=(Bitmask& x , Bitmask y) \ { x = x & y ; return x ; } \ \ inline Bitmask & operator\|=(Bitmask& x , Bitmask y) \ { x = x \| y ; return x ; } \ \ inline Bitmask & operator^=(Bitmask& x , Bitmask y) \ { x = x ^ y ; return x ; } \ \ /* Boost extensions to [bitmask.types] / \ \ inline BOOST_CONSTEXPR bool operator!(Bitmask x) \ { return !static_cast<int>(x); } \ \ inline BOOST_CONSTEXPR bool bitmask_set(Bitmask x) \ { return !!x; } #endif // BOOST_BITMASK_HPP PK��]�[��UiY��Y��sp_typeinfo.hppnu��[��#ifndef BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED #define BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif // detail/sp_typeinfo.hpp // // Deprecated, please use boost/core/typeinfo.hpp // // Copyright 2007 Peter Dimov // // 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) #include <boost/core/typeinfo.hpp> #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED( "<boost/core/typeinfo.hpp>" ) namespace boost { namespace detail { typedef boost::core::typeinfo sp_typeinfo; } // namespace detail } // namespace boost #define BOOST_SP_TYPEID(T) BOOST_CORE_TYPEID(T) #endif // #ifndef BOOST_DETAIL_SP_TYPEINFO_HPP_INCLUDED PK��]�[V�b�u��u��basic_pointerbuf.hppnu��[��//----------------------------------------------------------------------------- // boost detail/templated_streams.hpp header file // See http://www.boost.org for updates, documentation, and revision history. //----------------------------------------------------------------------------- // // Copyright (c) 2013 John Maddock, Antony Polukhin // // // 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_DETAIL_BASIC_POINTERBUF_HPP #define BOOST_DETAIL_BASIC_POINTERBUF_HPP // MS compatible compilers support #pragma once #if defined(_MSC_VER) # pragma once #endif #include "boost/config.hpp" #include <streambuf> namespace boost { namespace detail { // // class basic_pointerbuf: // acts as a stream buffer which wraps around a pair of pointers: // template <class charT, class BufferT > class basic_pointerbuf : public BufferT { protected: typedef BufferT base_type; typedef basic_pointerbuf<charT, BufferT> this_type; typedef typename base_type::int_type int_type; typedef typename base_type::char_type char_type; typedef typename base_type::pos_type pos_type; typedef ::std::streamsize streamsize; typedef typename base_type::off_type off_type; public: basic_pointerbuf() : base_type() { this_type::setbuf(0, 0); } const charT getnext() { return this->gptr(); } #ifndef BOOST_NO_USING_TEMPLATE using base_type::pptr; using base_type::pbase; #else charT* pptr() const { return base_type::pptr(); } charT* pbase() const { return base_type::pbase(); } #endif protected: // VC mistakenly assumes that `setbuf` and other functions are not referenced. // Marking those functions with `inline` suppresses the warnings. // There must be no harm from marking virtual functions as inline: inline virtual // call can be inlined ONLY when the compiler knows the "exact class". inline base_type* setbuf(char_type* s, streamsize n) BOOST_OVERRIDE; inline typename this_type::pos_type seekpos(pos_type sp, ::std::ios_base::openmode which) BOOST_OVERRIDE; inline typename this_type::pos_type seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which) BOOST_OVERRIDE; private: basic_pointerbuf& operator=(const basic_pointerbuf&); basic_pointerbuf(const basic_pointerbuf&); }; template<class charT, class BufferT> BufferT* basic_pointerbuf<charT, BufferT>::setbuf(char_type* s, streamsize n) { this->setg(s, s, s + n); return this; } template<class charT, class BufferT> typename basic_pointerbuf<charT, BufferT>::pos_type basic_pointerbuf<charT, BufferT>::seekoff(off_type off, ::std::ios_base::seekdir way, ::std::ios_base::openmode which) { typedef typename boost::int_t<sizeof(way) * CHAR_BIT>::least cast_type; if(which & ::std::ios_base::out) return pos_type(off_type(-1)); std::ptrdiff_t size = this->egptr() - this->eback(); std::ptrdiff_t pos = this->gptr() - this->eback(); charT* g = this->eback(); switch(static_cast<cast_type>(way)) { case ::std::ios_base::beg: if((off < 0) \|\| (off > size)) return pos_type(off_type(-1)); else this->setg(g, g + off, g + size); break; case ::std::ios_base::end: if((off < 0) \|\| (off > size)) return pos_type(off_type(-1)); else this->setg(g, g + size - off, g + size); break; case ::std::ios_base::cur: { std::ptrdiff_t newpos = static_cast<std::ptrdiff_t>(pos + off); if((newpos < 0) \|\| (newpos > size)) return pos_type(off_type(-1)); else this->setg(g, g + newpos, g + size); break; } default: ; } #ifdef BOOST_MSVC #pragma warning(push) #pragma warning(disable:4244) #endif return static_cast<pos_type>(this->gptr() - this->eback()); #ifdef BOOST_MSVC #pragma warning(pop) #endif } template<class charT, class BufferT> typename basic_pointerbuf<charT, BufferT>::pos_type basic_pointerbuf<charT, BufferT>::seekpos(pos_type sp, ::std::ios_base::openmode which) { if(which & ::std::ios_base::out) return pos_type(off_type(-1)); off_type size = static_cast<off_type>(this->egptr() - this->eback()); charT* g = this->eback(); if(off_type(sp) <= size) { this->setg(g, g + off_type(sp), g + size); } return pos_type(off_type(-1)); } }} // namespace boost::detail #endif // BOOST_DETAIL_BASIC_POINTERBUF_HPP PK��]�[�7:��:��no_exceptions_support.hppnu��[��/* * Copyright (c) 2014 Glen Fernandes * * 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_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP #define BOOST_DETAIL_NO_EXCEPTIONS_SUPPORT_HPP // The header file at this path is deprecated; // use boost/core/no_exceptions_support.hpp instead. #include <boost/config/header_deprecated.hpp> BOOST_HEADER_DEPRECATED("<boost/core/no_exceptions_support.hpp>") #include <boost/core/no_exceptions_support.hpp> #endif PK��Bb�[nש��uuid_generic.ippnu��[��/ * Copyright Andy Tompkins 2006. * Distributed under the Boost Software License, Version 1.0. * (See accompanying file LICENSE_1_0.txt or copy at * https://www.boost.org/LICENSE_1_0.txt) / /! * \file uuid/detail/uuid_generic.ipp * * \brief This header contains generic implementation of \c boost::uuid operations. / #ifndef BOOST_UUID_DETAIL_UUID_GENERIC_IPP_INCLUDED_ #define BOOST_UUID_DETAIL_UUID_GENERIC_IPP_INCLUDED_ #include <string.h> namespace boost { namespace uuids { inline bool uuid::is_nil() const BOOST_NOEXCEPT { for (std::size_t i = 0; i < sizeof(data); ++i) { if (data[i] != 0U) return false; } return true; } inline void uuid::swap(uuid& rhs) BOOST_NOEXCEPT { uuid tmp = this; this = rhs; rhs = tmp; } inline bool operator== (uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT { return memcmp(lhs.data, rhs.data, sizeof(lhs.data)) == 0; } inline bool operator< (uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT { return memcmp(lhs.data, rhs.data, sizeof(lhs.data)) < 0; } } // namespace uuids } // namespace boost #endif // BOOST_UUID_DETAIL_UUID_GENERIC_IPP_INCLUDED_ PK��Bb�[+�z�T ��T ��#��random_provider_detect_platform.hppnu��[��// // Copyright (c) 2017 James E. King III // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // https://www.boost.org/LICENSE_1_0.txt) // // Platform-specific random entropy provider platform detection // #ifndef BOOST_UUID_DETAIL_RANDOM_PROVIDER_PLATFORM_DETECTION_HPP #define BOOST_UUID_DETAIL_RANDOM_PROVIDER_PLATFORM_DETECTION_HPP #include <boost/predef/library/c/cloudabi.h> #include <boost/predef/library/c/gnu.h> #include <boost/predef/os/bsd/open.h> #include <boost/predef/os/windows.h> // Note: Don't use Boost.Predef to detect Linux and Android as it may give different results depending on header inclusion order. // https://github.com/boostorg/predef/issues/81#issuecomment-413329061 #if (defined(__linux__) \|\| defined(__linux) \|\| defined(linux)) && (!defined(__ANDROID__) \|\| __ANDROID_API__ >= 28) #include <sys/syscall.h> #if defined(SYS_getrandom) #define BOOST_UUID_RANDOM_PROVIDER_HAS_GETRANDOM #endif // defined(SYS_getrandom) #endif // On Linux, getentropy is implemented via getrandom. If we know that getrandom is not supported by the kernel, getentropy // will certainly not work, even if libc provides a wrapper function for it. There is no reason, ever, to use getentropy on that platform. #if !defined(BOOST_UUID_RANDOM_PROVIDER_DISABLE_GETENTROPY) && (defined(__linux__) \|\| defined(__linux) \|\| defined(linux) \|\| defined(__ANDROID__)) #define BOOST_UUID_RANDOM_PROVIDER_DISABLE_GETENTROPY #endif // // Platform Detection - will load in the correct header and // will define the class <tt>random_provider_base</tt>. // #if BOOST_OS_BSD_OPEN >= BOOST_VERSION_NUMBER(2, 1, 0) \|\| BOOST_LIB_C_CLOUDABI # define BOOST_UUID_RANDOM_PROVIDER_ARC4RANDOM # define BOOST_UUID_RANDOM_PROVIDER_NAME arc4random #elif BOOST_OS_WINDOWS # include <boost/winapi/config.hpp> # if BOOST_WINAPI_PARTITION_APP_SYSTEM && \ !defined(BOOST_UUID_RANDOM_PROVIDER_FORCE_WINCRYPT) && \ !defined(_WIN32_WCE) && \ (BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN6) # define BOOST_UUID_RANDOM_PROVIDER_BCRYPT # define BOOST_UUID_RANDOM_PROVIDER_NAME bcrypt # elif BOOST_WINAPI_PARTITION_DESKTOP \|\| BOOST_WINAPI_PARTITION_SYSTEM # define BOOST_UUID_RANDOM_PROVIDER_WINCRYPT # define BOOST_UUID_RANDOM_PROVIDER_NAME wincrypt # else # error Unable to find a suitable windows entropy provider # endif #elif defined(BOOST_UUID_RANDOM_PROVIDER_HAS_GETRANDOM) && !defined(BOOST_UUID_RANDOM_PROVIDER_FORCE_POSIX) && !defined(BOOST_UUID_RANDOM_PROVIDER_DISABLE_GETRANDOM) # define BOOST_UUID_RANDOM_PROVIDER_GETRANDOM # define BOOST_UUID_RANDOM_PROVIDER_NAME getrandom #elif BOOST_LIB_C_GNU >= BOOST_VERSION_NUMBER(2, 25, 0) && !defined(BOOST_UUID_RANDOM_PROVIDER_FORCE_POSIX) && !defined(BOOST_UUID_RANDOM_PROVIDER_DISABLE_GETENTROPY) # define BOOST_UUID_RANDOM_PROVIDER_GETENTROPY # define BOOST_UUID_RANDOM_PROVIDER_NAME getentropy #else # define BOOST_UUID_RANDOM_PROVIDER_POSIX # define BOOST_UUID_RANDOM_PROVIDER_NAME posix #endif #define BOOST_UUID_RANDOM_PROVIDER_STRINGIFY2(X) #X #define BOOST_UUID_RANDOM_PROVIDER_STRINGIFY(X) BOOST_UUID_RANDOM_PROVIDER_STRINGIFY2(X) #if defined(BOOST_UUID_RANDOM_PROVIDER_SHOW) #pragma message("BOOST_UUID_RANDOM_PROVIDER_NAME " BOOST_UUID_RANDOM_PROVIDER_STRINGIFY(BOOST_UUID_RANDOM_PROVIDER_NAME)) #endif #endif // BOOST_UUID_DETAIL_RANDOM_PROVIDER_PLATFORM_DETECTION_HPP PK��Bb�[��XF.�F.� ��config.hppnu��[��// // detail/config.hpp // ~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_CONFIG_HPP #define BOOST_ASIO_DETAIL_CONFIG_HPP #if defined(BOOST_ASIO_STANDALONE) # define BOOST_ASIO_DISABLE_BOOST_ARRAY 1 # define BOOST_ASIO_DISABLE_BOOST_ASSERT 1 # define BOOST_ASIO_DISABLE_BOOST_BIND 1 # define BOOST_ASIO_DISABLE_BOOST_CHRONO 1 # define BOOST_ASIO_DISABLE_BOOST_DATE_TIME 1 # define BOOST_ASIO_DISABLE_BOOST_LIMITS 1 # define BOOST_ASIO_DISABLE_BOOST_REGEX 1 # define BOOST_ASIO_DISABLE_BOOST_STATIC_CONSTANT 1 # define BOOST_ASIO_DISABLE_BOOST_THROW_EXCEPTION 1 # define BOOST_ASIO_DISABLE_BOOST_WORKAROUND 1 #else // defined(BOOST_ASIO_STANDALONE) # include <boost/config.hpp> # include <boost/version.hpp> # define BOOST_ASIO_HAS_BOOST_CONFIG 1 #endif // defined(BOOST_ASIO_STANDALONE) // Default to a header-only implementation. The user must specifically request // separate compilation by defining either BOOST_ASIO_SEPARATE_COMPILATION or // BOOST_ASIO_DYN_LINK (as a DLL/shared library implies separate compilation). #if !defined(BOOST_ASIO_HEADER_ONLY) # if !defined(BOOST_ASIO_SEPARATE_COMPILATION) # if !defined(BOOST_ASIO_DYN_LINK) # define BOOST_ASIO_HEADER_ONLY 1 # endif // !defined(BOOST_ASIO_DYN_LINK) # endif // !defined(BOOST_ASIO_SEPARATE_COMPILATION) #endif // !defined(BOOST_ASIO_HEADER_ONLY) #if defined(BOOST_ASIO_HEADER_ONLY) # define BOOST_ASIO_DECL inline #else // defined(BOOST_ASIO_HEADER_ONLY) # if defined(_MSC_VER) \|\| defined(__BORLANDC__) \|\| defined(__CODEGEARC__) // We need to import/export our code only if the user has specifically asked // for it by defining BOOST_ASIO_DYN_LINK. # if defined(BOOST_ASIO_DYN_LINK) // Export if this is our own source, otherwise import. # if defined(BOOST_ASIO_SOURCE) # define BOOST_ASIO_DECL __declspec(dllexport) # else // defined(BOOST_ASIO_SOURCE) # define BOOST_ASIO_DECL __declspec(dllimport) # endif // defined(BOOST_ASIO_SOURCE) # endif // defined(BOOST_ASIO_DYN_LINK) # endif // defined(_MSC_VER) \|\| defined(__BORLANDC__) \|\| defined(__CODEGEARC__) #endif // defined(BOOST_ASIO_HEADER_ONLY) // If BOOST_ASIO_DECL isn't defined yet define it now. #if !defined(BOOST_ASIO_DECL) # define BOOST_ASIO_DECL #endif // !defined(BOOST_ASIO_DECL) // Helper macro for documentation. #define BOOST_ASIO_UNSPECIFIED(e) e // Microsoft Visual C++ detection. #if !defined(BOOST_ASIO_MSVC) # if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_MSVC) # define BOOST_ASIO_MSVC BOOST_MSVC # elif defined(_MSC_VER) && (defined(__INTELLISENSE__) \ \|\| (!defined(__MWERKS__) && !defined(__EDG_VERSION__))) # define BOOST_ASIO_MSVC _MSC_VER # endif // defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_MSVC) #endif // !defined(BOOST_ASIO_MSVC) // Clang / libc++ detection. #if defined(__clang__) # if (__cplusplus >= 201103) # if __has_include(<__config>) # include <__config> # if defined(_LIBCPP_VERSION) # define BOOST_ASIO_HAS_CLANG_LIBCXX 1 # endif // defined(_LIBCPP_VERSION) # endif // __has_include(<__config>) # endif // (__cplusplus >= 201103) #endif // defined(__clang__) // Android platform detection. #if defined(__ANDROID__) # include <android/api-level.h> #endif // defined(__ANDROID__) // Support move construction and assignment on compilers known to allow it. #if !defined(BOOST_ASIO_HAS_MOVE) # if !defined(BOOST_ASIO_DISABLE_MOVE) # if defined(__clang__) # if __has_feature(__cxx_rvalue_references__) # define BOOST_ASIO_HAS_MOVE 1 # endif // __has_feature(__cxx_rvalue_references__) # endif // defined(__clang__) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_MOVE 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1700) # define BOOST_ASIO_HAS_MOVE 1 # endif // (_MSC_VER >= 1700) # endif // defined(BOOST_ASIO_MSVC) # if defined(__INTEL_CXX11_MODE__) # if defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1500) # define BOOST_ASIO_HAS_MOVE 1 # endif // defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1500) # if defined(__ICL) && (__ICL >= 1500) # define BOOST_ASIO_HAS_MOVE 1 # endif // defined(__ICL) && (__ICL >= 1500) # endif // defined(__INTEL_CXX11_MODE__) # endif // !defined(BOOST_ASIO_DISABLE_MOVE) #endif // !defined(BOOST_ASIO_HAS_MOVE) // If BOOST_ASIO_MOVE_CAST isn't defined, and move support is available, define // BOOST_ASIO_MOVE_ARG, // * BOOST_ASIO_NONDEDUCED_MOVE_ARG, and // * BOOST_ASIO_MOVE_CAST // to take advantage of rvalue references and perfect forwarding. #if defined(BOOST_ASIO_HAS_MOVE) && !defined(BOOST_ASIO_MOVE_CAST) # define BOOST_ASIO_MOVE_ARG(type) type&& # define BOOST_ASIO_MOVE_ARG2(type1, type2) type1, type2&& # define BOOST_ASIO_NONDEDUCED_MOVE_ARG(type) type& # define BOOST_ASIO_MOVE_CAST(type) static_cast<type&&> # define BOOST_ASIO_MOVE_CAST2(type1, type2) static_cast<type1, type2&&> # define BOOST_ASIO_MOVE_OR_LVALUE(type) static_cast<type&&> # define BOOST_ASIO_MOVE_OR_LVALUE_TYPE(type) type #endif // defined(BOOST_ASIO_HAS_MOVE) && !defined(BOOST_ASIO_MOVE_CAST) // If BOOST_ASIO_MOVE_CAST still isn't defined, default to a C++03-compatible // implementation. Note that older g++ and MSVC versions don't like it when you // pass a non-member function through a const reference, so for most compilers // we'll play it safe and stick with the old approach of passing the handler by // value. #if !defined(BOOST_ASIO_MOVE_CAST) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 1)) \|\| (__GNUC__ > 4) # define BOOST_ASIO_MOVE_ARG(type) const type& # else // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 1)) \|\| (__GNUC__ > 4) # define BOOST_ASIO_MOVE_ARG(type) type # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 1)) \|\| (__GNUC__ > 4) # elif defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1400) # define BOOST_ASIO_MOVE_ARG(type) const type& # else // (_MSC_VER >= 1400) # define BOOST_ASIO_MOVE_ARG(type) type # endif // (_MSC_VER >= 1400) # else # define BOOST_ASIO_MOVE_ARG(type) type # endif # define BOOST_ASIO_NONDEDUCED_MOVE_ARG(type) const type& # define BOOST_ASIO_MOVE_CAST(type) static_cast<const type&> # define BOOST_ASIO_MOVE_CAST2(type1, type2) static_cast<const type1, type2&> # define BOOST_ASIO_MOVE_OR_LVALUE(type) # define BOOST_ASIO_MOVE_OR_LVALUE_TYPE(type) type& #endif // !defined(BOOST_ASIO_MOVE_CAST) // Support variadic templates on compilers known to allow it. #if !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) # if !defined(BOOST_ASIO_DISABLE_VARIADIC_TEMPLATES) # if defined(__clang__) # if __has_feature(__cxx_variadic_templates__) # define BOOST_ASIO_HAS_VARIADIC_TEMPLATES 1 # endif // __has_feature(__cxx_variadic_templates__) # endif // defined(__clang__) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_VARIADIC_TEMPLATES 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1900) # define BOOST_ASIO_HAS_VARIADIC_TEMPLATES 1 # endif // (_MSC_VER >= 1900) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_VARIADIC_TEMPLATES) #endif // !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) #if !defined(BOOST_ASIO_ELLIPSIS) # if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) # define BOOST_ASIO_ELLIPSIS ... # else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) # define BOOST_ASIO_ELLIPSIS # endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) #endif // !defined(BOOST_ASIO_ELLIPSIS) // Support deleted functions on compilers known to allow it. #if !defined(BOOST_ASIO_DELETED) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_DELETED = delete # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(__clang__) # if __has_feature(__cxx_deleted_functions__) # define BOOST_ASIO_DELETED = delete # endif // __has_feature(__cxx_deleted_functions__) # endif // defined(__clang__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1900) # define BOOST_ASIO_DELETED = delete # endif // (_MSC_VER >= 1900) # endif // defined(BOOST_ASIO_MSVC) # if !defined(BOOST_ASIO_DELETED) # define BOOST_ASIO_DELETED # endif // !defined(BOOST_ASIO_DELETED) #endif // !defined(BOOST_ASIO_DELETED) // Support constexpr on compilers known to allow it. #if !defined(BOOST_ASIO_HAS_CONSTEXPR) # if !defined(BOOST_ASIO_DISABLE_CONSTEXPR) # if defined(__clang__) # if __has_feature(__cxx_constexpr__) # define BOOST_ASIO_HAS_CONSTEXPR 1 # endif // __has_feature(__cxx_constexpr__) # endif // defined(__clang__) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_CONSTEXPR 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1900) # define BOOST_ASIO_HAS_CONSTEXPR 1 # endif // (_MSC_VER >= 1900) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_CONSTEXPR) #endif // !defined(BOOST_ASIO_HAS_CONSTEXPR) #if !defined(BOOST_ASIO_CONSTEXPR) # if defined(BOOST_ASIO_HAS_CONSTEXPR) # define BOOST_ASIO_CONSTEXPR constexpr # else // defined(BOOST_ASIO_HAS_CONSTEXPR) # define BOOST_ASIO_CONSTEXPR # endif // defined(BOOST_ASIO_HAS_CONSTEXPR) #endif // !defined(BOOST_ASIO_CONSTEXPR) #if !defined(BOOST_ASIO_STATIC_CONSTEXPR) # if defined(BOOST_ASIO_HAS_CONSTEXPR) # define BOOST_ASIO_STATIC_CONSTEXPR(type, assignment) \ static constexpr type assignment # else // defined(BOOST_ASIO_HAS_CONSTEXPR) # define BOOST_ASIO_STATIC_CONSTEXPR(type, assignment) \ static const type assignment # endif // defined(BOOST_ASIO_HAS_CONSTEXPR) #endif // !defined(BOOST_ASIO_STATIC_CONSTEXPR) #if !defined(BOOST_ASIO_STATIC_CONSTEXPR_DEFAULT_INIT) # if defined(BOOST_ASIO_HAS_CONSTEXPR) # if defined(__GNUC__) # if (__GNUC__ >= 8) # define BOOST_ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(type, name) \ static constexpr const type name{} # else // (__GNUC__ >= 8) # define BOOST_ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(type, name) \ static const type name # endif // (__GNUC__ >= 8) # elif defined(BOOST_ASIO_MSVC) # define BOOST_ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(type, name) \ static const type name # else // defined(BOOST_ASIO_MSVC) # define BOOST_ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(type, name) \ static constexpr const type name{} # endif // defined(BOOST_ASIO_MSVC) # else // defined(BOOST_ASIO_HAS_CONSTEXPR) # define BOOST_ASIO_STATIC_CONSTEXPR_DEFAULT_INIT(type, name) \ static const type name # endif // defined(BOOST_ASIO_HAS_CONSTEXPR) #endif // !defined(BOOST_ASIO_STATIC_CONSTEXPR_DEFAULT_INIT) // Support noexcept on compilers known to allow it. #if !defined(BOOST_ASIO_HAS_NOEXCEPT) # if !defined(BOOST_ASIO_DISABLE_NOEXCEPT) # if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && (BOOST_VERSION >= 105300) # if !defined(BOOST_NO_NOEXCEPT) # define BOOST_ASIO_HAS_NOEXCEPT 1 # endif // !defined(BOOST_NO_NOEXCEPT) # define BOOST_ASIO_NOEXCEPT BOOST_NOEXCEPT # define BOOST_ASIO_NOEXCEPT_OR_NOTHROW BOOST_NOEXCEPT_OR_NOTHROW # define BOOST_ASIO_NOEXCEPT_IF(c) BOOST_NOEXCEPT_IF(c) # elif defined(__clang__) # if __has_feature(__cxx_noexcept__) # define BOOST_ASIO_HAS_NOEXCEPT 1 # endif // __has_feature(__cxx_noexcept__) # elif defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_NOEXCEPT 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # elif defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1900) # define BOOST_ASIO_HAS_NOEXCEPT 1 # endif // (_MSC_VER >= 1900) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_NOEXCEPT) # if !defined(BOOST_ASIO_NOEXCEPT) # endif // !defined(BOOST_ASIO_NOEXCEPT) # if !defined(BOOST_ASIO_NOEXCEPT_OR_NOTHROW) # endif // !defined(BOOST_ASIO_NOEXCEPT_OR_NOTHROW) #endif // !defined(BOOST_ASIO_HAS_NOEXCEPT) #if !defined(BOOST_ASIO_NOEXCEPT) # if defined(BOOST_ASIO_HAS_NOEXCEPT) # define BOOST_ASIO_NOEXCEPT noexcept(true) # else // defined(BOOST_ASIO_HAS_NOEXCEPT) # define BOOST_ASIO_NOEXCEPT # endif // defined(BOOST_ASIO_HAS_NOEXCEPT) #endif // !defined(BOOST_ASIO_NOEXCEPT) #if !defined(BOOST_ASIO_NOEXCEPT_OR_NOTHROW) # if defined(BOOST_ASIO_HAS_NOEXCEPT) # define BOOST_ASIO_NOEXCEPT_OR_NOTHROW noexcept(true) # else // defined(BOOST_ASIO_HAS_NOEXCEPT) # define BOOST_ASIO_NOEXCEPT_OR_NOTHROW throw() # endif // defined(BOOST_ASIO_HAS_NOEXCEPT) #endif // !defined(BOOST_ASIO_NOEXCEPT_OR_NOTHROW) #if !defined(BOOST_ASIO_NOEXCEPT_IF) # if defined(BOOST_ASIO_HAS_NOEXCEPT) # define BOOST_ASIO_NOEXCEPT_IF(c) noexcept(c) # else // defined(BOOST_ASIO_HAS_NOEXCEPT) # define BOOST_ASIO_NOEXCEPT_IF(c) # endif // defined(BOOST_ASIO_HAS_NOEXCEPT) #endif // !defined(BOOST_ASIO_NOEXCEPT_IF) // Support automatic type deduction on compilers known to support it. #if !defined(BOOST_ASIO_HAS_DECLTYPE) # if !defined(BOOST_ASIO_DISABLE_DECLTYPE) # if defined(__clang__) # if __has_feature(__cxx_decltype__) # define BOOST_ASIO_HAS_DECLTYPE 1 # endif // __has_feature(__cxx_decltype__) # endif // defined(__clang__) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_DECLTYPE 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1800) # define BOOST_ASIO_HAS_DECLTYPE 1 # endif // (_MSC_VER >= 1800) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_DECLTYPE) #endif // !defined(BOOST_ASIO_HAS_DECLTYPE) // Support alias templates on compilers known to allow it. #if !defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES) # if !defined(BOOST_ASIO_DISABLE_ALIAS_TEMPLATES) # if defined(__clang__) # if __has_feature(__cxx_alias_templates__) # define BOOST_ASIO_HAS_ALIAS_TEMPLATES 1 # endif // __has_feature(__cxx_alias_templates__) # endif // defined(__clang__) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_ALIAS_TEMPLATES 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1900) # define BOOST_ASIO_HAS_ALIAS_TEMPLATES 1 # endif // (_MSC_VER >= 1900) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_ALIAS_TEMPLATES) #endif // !defined(BOOST_ASIO_HAS_ALIAS_TEMPLATES) // Support return type deduction on compilers known to allow it. #if !defined(BOOST_ASIO_HAS_RETURN_TYPE_DEDUCTION) # if !defined(BOOST_ASIO_DISABLE_RETURN_TYPE_DEDUCTION) # if defined(__clang__) # if __has_feature(__cxx_return_type_deduction__) # define BOOST_ASIO_HAS_RETURN_TYPE_DEDUCTION 1 # endif // __has_feature(__cxx_return_type_deduction__) # elif (__cplusplus >= 201402) # define BOOST_ASIO_HAS_RETURN_TYPE_DEDUCTION 1 # elif defined(__cpp_return_type_deduction) # if (__cpp_return_type_deduction >= 201304) # define BOOST_ASIO_HAS_RETURN_TYPE_DEDUCTION 1 # endif // (__cpp_return_type_deduction >= 201304) # endif // defined(__cpp_return_type_deduction) # endif // !defined(BOOST_ASIO_DISABLE_RETURN_TYPE_DEDUCTION) #endif // !defined(BOOST_ASIO_HAS_RETURN_TYPE_DEDUCTION) // Support default function template arguments on compilers known to allow it. #if !defined(BOOST_ASIO_HAS_DEFAULT_FUNCTION_TEMPLATE_ARGUMENTS) # if !defined(BOOST_ASIO_DISABLE_DEFAULT_FUNCTION_TEMPLATE_ARGUMENTS) # if (__cplusplus >= 201103) # define BOOST_ASIO_HAS_DEFAULT_FUNCTION_TEMPLATE_ARGUMENTS 1 # endif // (__cplusplus >= 201103) # endif // !defined(BOOST_ASIO_DISABLE_DEFAULT_FUNCTION_TEMPLATE_ARGUMENTS) #endif // !defined(BOOST_ASIO_HAS_DEFAULT_FUNCTION_TEMPLATE_ARGUMENTS) // Support concepts on compilers known to allow them. #if !defined(BOOST_ASIO_HAS_CONCEPTS) # if !defined(BOOST_ASIO_DISABLE_CONCEPTS) # if defined(__cpp_concepts) # define BOOST_ASIO_HAS_CONCEPTS 1 # if (__cpp_concepts >= 201707) # define BOOST_ASIO_CONCEPT concept # else // (__cpp_concepts >= 201707) # define BOOST_ASIO_CONCEPT concept bool # endif // (__cpp_concepts >= 201707) # endif // defined(__cpp_concepts) # endif // !defined(BOOST_ASIO_DISABLE_CONCEPTS) #endif // !defined(BOOST_ASIO_HAS_CONCEPTS) // Support template variables on compilers known to allow it. #if !defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES) # if !defined(BOOST_ASIO_DISABLE_VARIABLE_TEMPLATES) # if defined(__clang__) # if (__cplusplus >= 201402) # if __has_feature(__cxx_variable_templates__) # define BOOST_ASIO_HAS_VARIABLE_TEMPLATES 1 # endif // __has_feature(__cxx_variable_templates__) # endif // (__cplusplus >= 201402) # endif // defined(__clang__) # if defined(__GNUC__) && !defined(__INTEL_COMPILER) # if (__GNUC__ >= 6) # if (__cplusplus >= 201402) # define BOOST_ASIO_HAS_VARIABLE_TEMPLATES 1 # endif // (__cplusplus >= 201402) # endif // (__GNUC__ >= 6) # endif // defined(__GNUC__) && !defined(__INTEL_COMPILER) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1901) # define BOOST_ASIO_HAS_VARIABLE_TEMPLATES 1 # endif // (_MSC_VER >= 1901) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_VARIABLE_TEMPLATES) #endif // !defined(BOOST_ASIO_HAS_VARIABLE_TEMPLATES) // Support SFINAEd template variables on compilers known to allow it. #if !defined(BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES) # if !defined(BOOST_ASIO_DISABLE_SFINAE_VARIABLE_TEMPLATES) # if defined(__clang__) # if (__cplusplus >= 201703) # if __has_feature(__cxx_variable_templates__) # define BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES 1 # endif // __has_feature(__cxx_variable_templates__) # endif // (__cplusplus >= 201703) # endif // defined(__clang__) # if defined(__GNUC__) # if ((__GNUC__ == 8) && (__GNUC_MINOR__ >= 4)) \|\| (__GNUC__ > 8) # if (__cplusplus >= 201402) # define BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES 1 # endif // (__cplusplus >= 201402) # endif // ((__GNUC__ == 8) && (__GNUC_MINOR__ >= 4)) \|\| (__GNUC__ > 8) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1901) # define BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES 1 # endif // (_MSC_VER >= 1901) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_SFINAE_VARIABLE_TEMPLATES) #endif // !defined(BOOST_ASIO_HAS_SFINAE_VARIABLE_TEMPLATES) // Support SFINAE use of constant expressions on compilers known to allow it. #if !defined(BOOST_ASIO_HAS_CONSTANT_EXPRESSION_SFINAE) # if !defined(BOOST_ASIO_DISABLE_CONSTANT_EXPRESSION_SFINAE) # if defined(__clang__) # if (__cplusplus >= 201402) # define BOOST_ASIO_HAS_CONSTANT_EXPRESSION_SFINAE 1 # endif // (__cplusplus >= 201402) # endif // defined(__clang__) # if defined(__GNUC__) && !defined(__INTEL_COMPILER) # if (__GNUC__ >= 7) # if (__cplusplus >= 201402) # define BOOST_ASIO_HAS_CONSTANT_EXPRESSION_SFINAE 1 # endif // (__cplusplus >= 201402) # endif // (__GNUC__ >= 7) # endif // defined(__GNUC__) && !defined(__INTEL_COMPILER) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1901) # define BOOST_ASIO_HAS_CONSTANT_EXPRESSION_SFINAE 1 # endif // (_MSC_VER >= 1901) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_CONSTANT_EXPRESSION_SFINAE) #endif // !defined(BOOST_ASIO_HAS_CONSTANT_EXPRESSION_SFINAE) // Enable workarounds for lack of working expression SFINAE. #if !defined(BOOST_ASIO_HAS_WORKING_EXPRESSION_SFINAE) # if !defined(BOOST_ASIO_DISABLE_WORKING_EXPRESSION_SFINAE) # if !defined(BOOST_ASIO_MSVC) && !defined(__INTEL_COMPILER) # if (__cplusplus >= 201103) # define BOOST_ASIO_HAS_WORKING_EXPRESSION_SFINAE 1 # endif // (__cplusplus >= 201103) # endif // !defined(BOOST_ASIO_MSVC) && !defined(__INTEL_COMPILER) # endif // !defined(BOOST_ASIO_DISABLE_WORKING_EXPRESSION_SFINAE) #endif // !defined(BOOST_ASIO_HAS_WORKING_EXPRESSION_SFINAE) // Support ref-qualified functions on compilers known to allow it. #if !defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS) # if !defined(BOOST_ASIO_DISABLE_REF_QUALIFIED_FUNCTIONS) # if defined(__clang__) # if __has_feature(__cxx_reference_qualified_functions__) # define BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS 1 # endif // __has_feature(__cxx_reference_qualified_functions__) # endif // defined(__clang__) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1900) # define BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS 1 # endif // (_MSC_VER >= 1900) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_REF_QUALIFIED_FUNCTIONS) #endif // !defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS) #if defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS) # if !defined(BOOST_ASIO_LVALUE_REF_QUAL) # define BOOST_ASIO_LVALUE_REF_QUAL & # endif // !defined(BOOST_ASIO_LVALUE_REF_QUAL) # if !defined(BOOST_ASIO_RVALUE_REF_QUAL) # define BOOST_ASIO_RVALUE_REF_QUAL && # endif // !defined(BOOST_ASIO_RVALUE_REF_QUAL) #else // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS) # if !defined(BOOST_ASIO_LVALUE_REF_QUAL) # define BOOST_ASIO_LVALUE_REF_QUAL # endif // !defined(BOOST_ASIO_LVALUE_REF_QUAL) # if !defined(BOOST_ASIO_RVALUE_REF_QUAL) # define BOOST_ASIO_RVALUE_REF_QUAL # endif // !defined(BOOST_ASIO_RVALUE_REF_QUAL) #endif // defined(BOOST_ASIO_HAS_REF_QUALIFIED_FUNCTIONS) // Standard library support for system errors. # if !defined(BOOST_ASIO_DISABLE_STD_SYSTEM_ERROR) # if defined(__clang__) # if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # define BOOST_ASIO_HAS_STD_SYSTEM_ERROR 1 # elif (__cplusplus >= 201103) # if __has_include(<system_error>) # define BOOST_ASIO_HAS_STD_SYSTEM_ERROR 1 # endif // __has_include(<system_error>) # endif // (__cplusplus >= 201103) # endif // defined(__clang__) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_STD_SYSTEM_ERROR 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1700) # define BOOST_ASIO_HAS_STD_SYSTEM_ERROR 1 # endif // (_MSC_VER >= 1700) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_STD_SYSTEM_ERROR) // Compliant C++11 compilers put noexcept specifiers on error_category members. #if !defined(BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT) # if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && (BOOST_VERSION >= 105300) # define BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT BOOST_NOEXCEPT # elif defined(__clang__) # if __has_feature(__cxx_noexcept__) # define BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT noexcept(true) # endif // __has_feature(__cxx_noexcept__) # elif defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT noexcept(true) # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # elif defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1900) # define BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT noexcept(true) # endif // (_MSC_VER >= 1900) # endif // defined(BOOST_ASIO_MSVC) # if !defined(BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT) # define BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT # endif // !defined(BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT) #endif // !defined(BOOST_ASIO_ERROR_CATEGORY_NOEXCEPT) // Standard library support for arrays. #if !defined(BOOST_ASIO_HAS_STD_ARRAY) # if !defined(BOOST_ASIO_DISABLE_STD_ARRAY) # if defined(__clang__) # if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # define BOOST_ASIO_HAS_STD_ARRAY 1 # elif (__cplusplus >= 201103) # if __has_include(<array>) # define BOOST_ASIO_HAS_STD_ARRAY 1 # endif // __has_include(<array>) # endif // (__cplusplus >= 201103) # endif // defined(__clang__) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_STD_ARRAY 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1600) # define BOOST_ASIO_HAS_STD_ARRAY 1 # endif // (_MSC_VER >= 1600) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_STD_ARRAY) #endif // !defined(BOOST_ASIO_HAS_STD_ARRAY) // Standard library support for shared_ptr and weak_ptr. #if !defined(BOOST_ASIO_HAS_STD_SHARED_PTR) # if !defined(BOOST_ASIO_DISABLE_STD_SHARED_PTR) # if defined(__clang__) # if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # define BOOST_ASIO_HAS_STD_SHARED_PTR 1 # elif (__cplusplus >= 201103) # define BOOST_ASIO_HAS_STD_SHARED_PTR 1 # endif // (__cplusplus >= 201103) # endif // defined(__clang__) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_STD_SHARED_PTR 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1600) # define BOOST_ASIO_HAS_STD_SHARED_PTR 1 # endif // (_MSC_VER >= 1600) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_STD_SHARED_PTR) #endif // !defined(BOOST_ASIO_HAS_STD_SHARED_PTR) // Standard library support for allocator_arg_t. #if !defined(BOOST_ASIO_HAS_STD_ALLOCATOR_ARG) # if !defined(BOOST_ASIO_DISABLE_STD_ALLOCATOR_ARG) # if defined(__clang__) # if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # define BOOST_ASIO_HAS_STD_ALLOCATOR_ARG 1 # elif (__cplusplus >= 201103) # define BOOST_ASIO_HAS_STD_ALLOCATOR_ARG 1 # endif // (__cplusplus >= 201103) # endif // defined(__clang__) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_STD_ALLOCATOR_ARG 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1600) # define BOOST_ASIO_HAS_STD_ALLOCATOR_ARG 1 # endif // (_MSC_VER >= 1600) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_STD_ALLOCATOR_ARG) #endif // !defined(BOOST_ASIO_HAS_STD_ALLOCATOR_ARG) // Standard library support for atomic operations. #if !defined(BOOST_ASIO_HAS_STD_ATOMIC) # if !defined(BOOST_ASIO_DISABLE_STD_ATOMIC) # if defined(__clang__) # if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # define BOOST_ASIO_HAS_STD_ATOMIC 1 # elif (__cplusplus >= 201103) # if __has_include(<atomic>) # define BOOST_ASIO_HAS_STD_ATOMIC 1 # endif // __has_include(<atomic>) # elif defined(__apple_build_version__) && defined(_LIBCPP_VERSION) # if (__clang_major__ >= 10) # if __has_include(<atomic>) # define BOOST_ASIO_HAS_STD_ATOMIC 1 # endif // __has_include(<atomic>) # endif // (__clang_major__ >= 10) # endif // defined(__apple_build_version__) && defined(_LIBCPP_VERSION) # endif // defined(__clang__) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_STD_ATOMIC 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1700) # define BOOST_ASIO_HAS_STD_ATOMIC 1 # endif // (_MSC_VER >= 1700) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_STD_ATOMIC) #endif // !defined(BOOST_ASIO_HAS_STD_ATOMIC) // Standard library support for chrono. Some standard libraries (such as the // libstdc++ shipped with gcc 4.6) provide monotonic_clock as per early C++0x // drafts, rather than the eventually standardised name of steady_clock. #if !defined(BOOST_ASIO_HAS_STD_CHRONO) # if !defined(BOOST_ASIO_DISABLE_STD_CHRONO) # if defined(__clang__) # if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # define BOOST_ASIO_HAS_STD_CHRONO 1 # elif (__cplusplus >= 201103) # if __has_include(<chrono>) # define BOOST_ASIO_HAS_STD_CHRONO 1 # endif // __has_include(<chrono>) # endif // (__cplusplus >= 201103) # endif // defined(__clang__) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_STD_CHRONO 1 # if ((__GNUC__ == 4) && (__GNUC_MINOR__ == 6)) # define BOOST_ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK 1 # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ == 6)) # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1700) # define BOOST_ASIO_HAS_STD_CHRONO 1 # endif // (_MSC_VER >= 1700) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_STD_CHRONO) #endif // !defined(BOOST_ASIO_HAS_STD_CHRONO) // Boost support for chrono. #if !defined(BOOST_ASIO_HAS_BOOST_CHRONO) # if !defined(BOOST_ASIO_DISABLE_BOOST_CHRONO) # if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && (BOOST_VERSION >= 104700) # define BOOST_ASIO_HAS_BOOST_CHRONO 1 # endif // defined(BOOST_ASIO_HAS_BOOST_CONFIG) && (BOOST_VERSION >= 104700) # endif // !defined(BOOST_ASIO_DISABLE_BOOST_CHRONO) #endif // !defined(BOOST_ASIO_HAS_BOOST_CHRONO) // Some form of chrono library is available. #if !defined(BOOST_ASIO_HAS_CHRONO) # if defined(BOOST_ASIO_HAS_STD_CHRONO) \ \|\| defined(BOOST_ASIO_HAS_BOOST_CHRONO) # define BOOST_ASIO_HAS_CHRONO 1 # endif // defined(BOOST_ASIO_HAS_STD_CHRONO) // \|\| defined(BOOST_ASIO_HAS_BOOST_CHRONO) #endif // !defined(BOOST_ASIO_HAS_CHRONO) // Boost support for the DateTime library. #if !defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) # if !defined(BOOST_ASIO_DISABLE_BOOST_DATE_TIME) # define BOOST_ASIO_HAS_BOOST_DATE_TIME 1 # endif // !defined(BOOST_ASIO_DISABLE_BOOST_DATE_TIME) #endif // !defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) // Standard library support for addressof. #if !defined(BOOST_ASIO_HAS_STD_ADDRESSOF) # if !defined(BOOST_ASIO_DISABLE_STD_ADDRESSOF) # if defined(__clang__) # if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # define BOOST_ASIO_HAS_STD_ADDRESSOF 1 # elif (__cplusplus >= 201103) # define BOOST_ASIO_HAS_STD_ADDRESSOF 1 # endif // (__cplusplus >= 201103) # endif // defined(__clang__) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_STD_ADDRESSOF 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1700) # define BOOST_ASIO_HAS_STD_ADDRESSOF 1 # endif // (_MSC_VER >= 1700) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_STD_ADDRESSOF) #endif // !defined(BOOST_ASIO_HAS_STD_ADDRESSOF) // Standard library support for the function class. #if !defined(BOOST_ASIO_HAS_STD_FUNCTION) # if !defined(BOOST_ASIO_DISABLE_STD_FUNCTION) # if defined(__clang__) # if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # define BOOST_ASIO_HAS_STD_FUNCTION 1 # elif (__cplusplus >= 201103) # define BOOST_ASIO_HAS_STD_FUNCTION 1 # endif // (__cplusplus >= 201103) # endif // defined(__clang__) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_STD_FUNCTION 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1700) # define BOOST_ASIO_HAS_STD_FUNCTION 1 # endif // (_MSC_VER >= 1700) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_STD_FUNCTION) #endif // !defined(BOOST_ASIO_HAS_STD_FUNCTION) // Standard library support for type traits. #if !defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) # if !defined(BOOST_ASIO_DISABLE_STD_TYPE_TRAITS) # if defined(__clang__) # if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # define BOOST_ASIO_HAS_STD_TYPE_TRAITS 1 # elif (__cplusplus >= 201103) # if __has_include(<type_traits>) # define BOOST_ASIO_HAS_STD_TYPE_TRAITS 1 # endif // __has_include(<type_traits>) # endif // (__cplusplus >= 201103) # endif // defined(__clang__) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_STD_TYPE_TRAITS 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1700) # define BOOST_ASIO_HAS_STD_TYPE_TRAITS 1 # endif // (_MSC_VER >= 1700) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_STD_TYPE_TRAITS) #endif // !defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) // Standard library support for the nullptr_t type. #if !defined(BOOST_ASIO_HAS_NULLPTR) # if !defined(BOOST_ASIO_DISABLE_NULLPTR) # if defined(__clang__) # if __has_feature(__cxx_nullptr__) # define BOOST_ASIO_HAS_NULLPTR 1 # endif // __has_feature(__cxx_nullptr__) # elif defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_NULLPTR 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1700) # define BOOST_ASIO_HAS_NULLPTR 1 # endif // (_MSC_VER >= 1700) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_NULLPTR) #endif // !defined(BOOST_ASIO_HAS_NULLPTR) // Standard library support for the C++11 allocator additions. #if !defined(BOOST_ASIO_HAS_CXX11_ALLOCATORS) # if !defined(BOOST_ASIO_DISABLE_CXX11_ALLOCATORS) # if defined(__clang__) # if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # define BOOST_ASIO_HAS_CXX11_ALLOCATORS 1 # elif (__cplusplus >= 201103) # define BOOST_ASIO_HAS_CXX11_ALLOCATORS 1 # endif // (__cplusplus >= 201103) # elif defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_CXX11_ALLOCATORS 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1800) # define BOOST_ASIO_HAS_CXX11_ALLOCATORS 1 # endif // (_MSC_VER >= 1800) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_CXX11_ALLOCATORS) #endif // !defined(BOOST_ASIO_HAS_CXX11_ALLOCATORS) // Standard library support for the cstdint header. #if !defined(BOOST_ASIO_HAS_CSTDINT) # if !defined(BOOST_ASIO_DISABLE_CSTDINT) # if defined(__clang__) # if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # define BOOST_ASIO_HAS_CSTDINT 1 # elif (__cplusplus >= 201103) # define BOOST_ASIO_HAS_CSTDINT 1 # endif // (__cplusplus >= 201103) # endif // defined(__clang__) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_CSTDINT 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1700) # define BOOST_ASIO_HAS_CSTDINT 1 # endif // (_MSC_VER >= 1700) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_CSTDINT) #endif // !defined(BOOST_ASIO_HAS_CSTDINT) // Standard library support for the thread class. #if !defined(BOOST_ASIO_HAS_STD_THREAD) # if !defined(BOOST_ASIO_DISABLE_STD_THREAD) # if defined(__clang__) # if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # define BOOST_ASIO_HAS_STD_THREAD 1 # elif (__cplusplus >= 201103) # if __has_include(<thread>) # define BOOST_ASIO_HAS_STD_THREAD 1 # endif // __has_include(<thread>) # endif // (__cplusplus >= 201103) # endif // defined(__clang__) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_STD_THREAD 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1700) # define BOOST_ASIO_HAS_STD_THREAD 1 # endif // (_MSC_VER >= 1700) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_STD_THREAD) #endif // !defined(BOOST_ASIO_HAS_STD_THREAD) // Standard library support for the mutex and condition variable classes. #if !defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) # if !defined(BOOST_ASIO_DISABLE_STD_MUTEX_AND_CONDVAR) # if defined(__clang__) # if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # define BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR 1 # elif (__cplusplus >= 201103) # if __has_include(<mutex>) # define BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR 1 # endif // __has_include(<mutex>) # endif // (__cplusplus >= 201103) # endif // defined(__clang__) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1700) # define BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR 1 # endif // (_MSC_VER >= 1700) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_STD_MUTEX_AND_CONDVAR) #endif // !defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) // Standard library support for the call_once function. #if !defined(BOOST_ASIO_HAS_STD_CALL_ONCE) # if !defined(BOOST_ASIO_DISABLE_STD_CALL_ONCE) # if defined(__clang__) # if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # define BOOST_ASIO_HAS_STD_CALL_ONCE 1 # elif (__cplusplus >= 201103) # if __has_include(<mutex>) # define BOOST_ASIO_HAS_STD_CALL_ONCE 1 # endif // __has_include(<mutex>) # endif // (__cplusplus >= 201103) # endif // defined(__clang__) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_STD_CALL_ONCE 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1700) # define BOOST_ASIO_HAS_STD_CALL_ONCE 1 # endif // (_MSC_VER >= 1700) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_STD_CALL_ONCE) #endif // !defined(BOOST_ASIO_HAS_STD_CALL_ONCE) // Standard library support for futures. #if !defined(BOOST_ASIO_HAS_STD_FUTURE) # if !defined(BOOST_ASIO_DISABLE_STD_FUTURE) # if defined(__clang__) # if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # define BOOST_ASIO_HAS_STD_FUTURE 1 # elif (__cplusplus >= 201103) # if __has_include(<future>) # define BOOST_ASIO_HAS_STD_FUTURE 1 # endif // __has_include(<future>) # endif // (__cplusplus >= 201103) # endif // defined(__clang__) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_STD_FUTURE 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1700) # define BOOST_ASIO_HAS_STD_FUTURE 1 # endif // (_MSC_VER >= 1700) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_STD_FUTURE) #endif // !defined(BOOST_ASIO_HAS_STD_FUTURE) // Standard library support for std::string_view. #if !defined(BOOST_ASIO_HAS_STD_STRING_VIEW) # if !defined(BOOST_ASIO_DISABLE_STD_STRING_VIEW) # if defined(__clang__) # if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # if (__cplusplus >= 201402) # if __has_include(<string_view>) # define BOOST_ASIO_HAS_STD_STRING_VIEW 1 # endif // __has_include(<string_view>) # endif // (__cplusplus >= 201402) # else // defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # if (__cplusplus >= 201703) # if __has_include(<string_view>) # define BOOST_ASIO_HAS_STD_STRING_VIEW 1 # endif // __has_include(<string_view>) # endif // (__cplusplus >= 201703) # endif // defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # elif defined(__GNUC__) # if (__GNUC__ >= 7) # if (__cplusplus >= 201703) # define BOOST_ASIO_HAS_STD_STRING_VIEW 1 # endif // (__cplusplus >= 201703) # endif // (__GNUC__ >= 7) # elif defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1910 && _MSVC_LANG >= 201703) # define BOOST_ASIO_HAS_STD_STRING_VIEW 1 # endif // (_MSC_VER >= 1910 && _MSVC_LANG >= 201703) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_STD_STRING_VIEW) #endif // !defined(BOOST_ASIO_HAS_STD_STRING_VIEW) // Standard library support for std::experimental::string_view. #if !defined(BOOST_ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW) # if !defined(BOOST_ASIO_DISABLE_STD_EXPERIMENTAL_STRING_VIEW) # if defined(__clang__) # if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # if (_LIBCPP_VERSION < 7000) # if (__cplusplus >= 201402) # if __has_include(<experimental/string_view>) # define BOOST_ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW 1 # endif // __has_include(<experimental/string_view>) # endif // (__cplusplus >= 201402) # endif // (_LIBCPP_VERSION < 7000) # else // defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # if (__cplusplus >= 201402) # if __has_include(<experimental/string_view>) # define BOOST_ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW 1 # endif // __has_include(<experimental/string_view>) # endif // (__cplusplus >= 201402) # endif // // defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # endif // defined(__clang__) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201402) # define BOOST_ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW 1 # endif // (__cplusplus >= 201402) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # endif // !defined(BOOST_ASIO_DISABLE_STD_EXPERIMENTAL_STRING_VIEW) #endif // !defined(BOOST_ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW) // Standard library has a string_view that we can use. #if !defined(BOOST_ASIO_HAS_STRING_VIEW) # if !defined(BOOST_ASIO_DISABLE_STRING_VIEW) # if defined(BOOST_ASIO_HAS_STD_STRING_VIEW) # define BOOST_ASIO_HAS_STRING_VIEW 1 # elif defined(BOOST_ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW) # define BOOST_ASIO_HAS_STRING_VIEW 1 # endif // defined(BOOST_ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW) # endif // !defined(BOOST_ASIO_DISABLE_STRING_VIEW) #endif // !defined(BOOST_ASIO_HAS_STRING_VIEW) // Standard library support for iostream move construction and assignment. #if !defined(BOOST_ASIO_HAS_STD_IOSTREAM_MOVE) # if !defined(BOOST_ASIO_DISABLE_STD_IOSTREAM_MOVE) # if defined(__GNUC__) # if (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_STD_IOSTREAM_MOVE 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1700) # define BOOST_ASIO_HAS_STD_IOSTREAM_MOVE 1 # endif // (_MSC_VER >= 1700) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_STD_IOSTREAM_MOVE) #endif // !defined(BOOST_ASIO_HAS_STD_IOSTREAM_MOVE) // Standard library has invoke_result (which supersedes result_of). #if !defined(BOOST_ASIO_HAS_STD_INVOKE_RESULT) # if !defined(BOOST_ASIO_DISABLE_STD_INVOKE_RESULT) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1911 && _MSVC_LANG >= 201703) # define BOOST_ASIO_HAS_STD_INVOKE_RESULT 1 # endif // (_MSC_VER >= 1911 && _MSVC_LANG >= 201703) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_STD_INVOKE_RESULT) #endif // !defined(BOOST_ASIO_HAS_STD_INVOKE_RESULT) // Standard library support for std::exception_ptr and std::current_exception. #if !defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) # if !defined(BOOST_ASIO_DISABLE_STD_EXCEPTION_PTR) # if defined(__clang__) # if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # define BOOST_ASIO_HAS_STD_EXCEPTION_PTR 1 # elif (__cplusplus >= 201103) # define BOOST_ASIO_HAS_STD_EXCEPTION_PTR 1 # endif // (__cplusplus >= 201103) # elif defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_STD_EXCEPTION_PTR 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1800) # define BOOST_ASIO_HAS_STD_EXCEPTION_PTR 1 # endif // (_MSC_VER >= 1800) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_STD_EXCEPTION_PTR) #endif // !defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) // Standard library support for std::nested_exception. #if !defined(BOOST_ASIO_HAS_STD_NESTED_EXCEPTION) # if !defined(BOOST_ASIO_DISABLE_STD_NESTED_EXCEPTION) # if defined(__clang__) # if defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # define BOOST_ASIO_HAS_STD_NESTED_EXCEPTION 1 # elif (__cplusplus >= 201103) # define BOOST_ASIO_HAS_STD_NESTED_EXCEPTION 1 # endif // (__cplusplus >= 201103) # elif defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # if (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_HAS_STD_NESTED_EXCEPTION 1 # endif // (__cplusplus >= 201103) \|\| defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1900) # define BOOST_ASIO_HAS_STD_NESTED_EXCEPTION 1 # endif // (_MSC_VER >= 1900) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_STD_NESTED_EXCEPTION) #endif // !defined(BOOST_ASIO_HAS_STD_NESTED_EXCEPTION) // Standard library support for std::any. #if !defined(BOOST_ASIO_HAS_STD_ANY) # if !defined(BOOST_ASIO_DISABLE_STD_ANY) # if defined(__clang__) # if (__cplusplus >= 201703) # if __has_include(<any>) # define BOOST_ASIO_HAS_STD_ANY 1 # endif // __has_include(<any>) # endif // (__cplusplus >= 201703) # elif defined(__GNUC__) # if (__GNUC__ >= 7) # if (__cplusplus >= 201703) # define BOOST_ASIO_HAS_STD_ANY 1 # endif // (__cplusplus >= 201703) # endif // (__GNUC__ >= 7) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1910) && (_MSVC_LANG >= 201703) # define BOOST_ASIO_HAS_STD_ANY 1 # endif // (_MSC_VER >= 1910) && (_MSVC_LANG >= 201703) # endif // defined(BOOST_ASIO_MSVC) # endif // !defined(BOOST_ASIO_DISABLE_STD_ANY) #endif // !defined(BOOST_ASIO_HAS_STD_ANY) // Standard library support for std::source_location. #if !defined(BOOST_ASIO_HAS_STD_SOURCE_LOCATION) # if !defined(BOOST_ASIO_DISABLE_STD_SOURCE_LOCATION) // ... # endif // !defined(BOOST_ASIO_DISABLE_STD_SOURCE_LOCATION) #endif // !defined(BOOST_ASIO_HAS_STD_SOURCE_LOCATION) // Standard library support for std::experimental::source_location. #if !defined(BOOST_ASIO_HAS_STD_EXPERIMENTAL_SOURCE_LOCATION) # if !defined(BOOST_ASIO_DISABLE_STD_EXPERIMENTAL_SOURCE_LOCATION) # if defined(__GNUC__) # if (__cplusplus >= 201709) # if __has_include(<experimental/source_location>) # define BOOST_ASIO_HAS_STD_EXPERIMENTAL_SOURCE_LOCATION 1 # endif // __has_include(<experimental/source_location>) # endif // (__cplusplus >= 201709) # endif // defined(__GNUC__) # endif // !defined(BOOST_ASIO_DISABLE_STD_EXPERIMENTAL_SOURCE_LOCATION) #endif // !defined(BOOST_ASIO_HAS_STD_EXPERIMENTAL_SOURCE_LOCATION) // Standard library has a source_location that we can use. #if !defined(BOOST_ASIO_HAS_SOURCE_LOCATION) # if !defined(BOOST_ASIO_DISABLE_SOURCE_LOCATION) # if defined(BOOST_ASIO_HAS_STD_SOURCE_LOCATION) # define BOOST_ASIO_HAS_SOURCE_LOCATION 1 # elif defined(BOOST_ASIO_HAS_STD_EXPERIMENTAL_SOURCE_LOCATION) # define BOOST_ASIO_HAS_SOURCE_LOCATION 1 # endif // defined(BOOST_ASIO_HAS_STD_EXPERIMENTAL_SOURCE_LOCATION) # endif // !defined(BOOST_ASIO_DISABLE_SOURCE_LOCATION) #endif // !defined(BOOST_ASIO_HAS_SOURCE_LOCATION) // Windows App target. Windows but with a limited API. #if !defined(BOOST_ASIO_WINDOWS_APP) # if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0603) # include <winapifamily.h> # if (WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) \ \|\| WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_TV_TITLE)) \ && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) # define BOOST_ASIO_WINDOWS_APP 1 # endif // WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) // && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) # endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0603) #endif // !defined(BOOST_ASIO_WINDOWS_APP) // Legacy WinRT target. Windows App is preferred. #if !defined(BOOST_ASIO_WINDOWS_RUNTIME) # if !defined(BOOST_ASIO_WINDOWS_APP) # if defined(__cplusplus_winrt) # include <winapifamily.h> # if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) \ && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) # define BOOST_ASIO_WINDOWS_RUNTIME 1 # endif // WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) // && !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) # endif // defined(__cplusplus_winrt) # endif // !defined(BOOST_ASIO_WINDOWS_APP) #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) // Windows target. Excludes WinRT but includes Windows App targets. #if !defined(BOOST_ASIO_WINDOWS) # if !defined(BOOST_ASIO_WINDOWS_RUNTIME) # if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_WINDOWS) # define BOOST_ASIO_WINDOWS 1 # elif defined(WIN32) \|\| defined(_WIN32) \|\| defined(__WIN32__) # define BOOST_ASIO_WINDOWS 1 # elif defined(BOOST_ASIO_WINDOWS_APP) # define BOOST_ASIO_WINDOWS 1 # endif // defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_WINDOWS) # endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // !defined(BOOST_ASIO_WINDOWS) // Windows: target OS version. #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) # if !defined(_WIN32_WINNT) && !defined(_WIN32_WINDOWS) # if defined(_MSC_VER) \|\| (defined(__BORLANDC__) && !defined(__clang__)) # pragma message( \ "Please define _WIN32_WINNT or _WIN32_WINDOWS appropriately. For example:\n"\ "- add -D_WIN32_WINNT=0x0601 to the compiler command line; or\n"\ "- add _WIN32_WINNT=0x0601 to your project's Preprocessor Definitions.\n"\ "Assuming _WIN32_WINNT=0x0601 (i.e. Windows 7 target).") # else // defined(_MSC_VER) \|\| (defined(__BORLANDC__) && !defined(__clang__)) # warning Please define _WIN32_WINNT or _WIN32_WINDOWS appropriately. # warning For example, add -D_WIN32_WINNT=0x0601 to the compiler command line. # warning Assuming _WIN32_WINNT=0x0601 (i.e. Windows 7 target). # endif // defined(_MSC_VER) \|\| (defined(__BORLANDC__) && !defined(__clang__)) # define _WIN32_WINNT 0x0601 # endif // !defined(_WIN32_WINNT) && !defined(_WIN32_WINDOWS) # if defined(_MSC_VER) # if defined(_WIN32) && !defined(WIN32) # if !defined(_WINSOCK2API_) # define WIN32 // Needed for correct types in winsock2.h # else // !defined(_WINSOCK2API_) # error Please define the macro WIN32 in your compiler options # endif // !defined(_WINSOCK2API_) # endif // defined(_WIN32) && !defined(WIN32) # endif // defined(_MSC_VER) # if defined(__BORLANDC__) # if defined(__WIN32__) && !defined(WIN32) # if !defined(_WINSOCK2API_) # define WIN32 // Needed for correct types in winsock2.h # else // !defined(_WINSOCK2API_) # error Please define the macro WIN32 in your compiler options # endif // !defined(_WINSOCK2API_) # endif // defined(__WIN32__) && !defined(WIN32) # endif // defined(__BORLANDC__) # if defined(__CYGWIN__) # if !defined(__USE_W32_SOCKETS) # error You must add -D__USE_W32_SOCKETS to your compiler options. # endif // !defined(__USE_W32_SOCKETS) # endif // defined(__CYGWIN__) #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) // Windows: minimise header inclusion. #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) # if !defined(BOOST_ASIO_NO_WIN32_LEAN_AND_MEAN) # if !defined(WIN32_LEAN_AND_MEAN) # define WIN32_LEAN_AND_MEAN # endif // !defined(WIN32_LEAN_AND_MEAN) # endif // !defined(BOOST_ASIO_NO_WIN32_LEAN_AND_MEAN) #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) // Windows: suppress definition of "min" and "max" macros. #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) # if !defined(BOOST_ASIO_NO_NOMINMAX) # if !defined(NOMINMAX) # define NOMINMAX 1 # endif // !defined(NOMINMAX) # endif // !defined(BOOST_ASIO_NO_NOMINMAX) #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) // Windows: IO Completion Ports. #if !defined(BOOST_ASIO_HAS_IOCP) # if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) # if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400) # if !defined(UNDER_CE) && !defined(BOOST_ASIO_WINDOWS_APP) # if !defined(BOOST_ASIO_DISABLE_IOCP) # define BOOST_ASIO_HAS_IOCP 1 # endif // !defined(BOOST_ASIO_DISABLE_IOCP) # endif // !defined(UNDER_CE) && !defined(BOOST_ASIO_WINDOWS_APP) # endif // defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0400) # endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) #endif // !defined(BOOST_ASIO_HAS_IOCP) // On POSIX (and POSIX-like) platforms we need to include unistd.h in order to // get access to the various platform feature macros, e.g. to be able to test // for threads support. #if !defined(BOOST_ASIO_HAS_UNISTD_H) # if !defined(BOOST_ASIO_HAS_BOOST_CONFIG) # if defined(unix) \ \|\| defined(__unix) \ \|\| defined(_XOPEN_SOURCE) \ \|\| defined(_POSIX_SOURCE) \ \|\| (defined(__MACH__) && defined(__APPLE__)) \ \|\| defined(__FreeBSD__) \ \|\| defined(__NetBSD__) \ \|\| defined(__OpenBSD__) \ \|\| defined(__linux__) \ \|\| defined(__HAIKU__) # define BOOST_ASIO_HAS_UNISTD_H 1 # endif # endif // !defined(BOOST_ASIO_HAS_BOOST_CONFIG) #endif // !defined(BOOST_ASIO_HAS_UNISTD_H) #if defined(BOOST_ASIO_HAS_UNISTD_H) # include <unistd.h> #endif // defined(BOOST_ASIO_HAS_UNISTD_H) // Linux: epoll, eventfd and timerfd. #if defined(__linux__) # include <linux/version.h> # if !defined(BOOST_ASIO_HAS_EPOLL) # if !defined(BOOST_ASIO_DISABLE_EPOLL) # if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,45) # define BOOST_ASIO_HAS_EPOLL 1 # endif // LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,45) # endif // !defined(BOOST_ASIO_DISABLE_EPOLL) # endif // !defined(BOOST_ASIO_HAS_EPOLL) # if !defined(BOOST_ASIO_HAS_EVENTFD) # if !defined(BOOST_ASIO_DISABLE_EVENTFD) # if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) # define BOOST_ASIO_HAS_EVENTFD 1 # endif // LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) # endif // !defined(BOOST_ASIO_DISABLE_EVENTFD) # endif // !defined(BOOST_ASIO_HAS_EVENTFD) # if !defined(BOOST_ASIO_HAS_TIMERFD) # if defined(BOOST_ASIO_HAS_EPOLL) # if (__GLIBC__ > 2) \|\| (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 8) # define BOOST_ASIO_HAS_TIMERFD 1 # endif // (__GLIBC__ > 2) \|\| (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 8) # endif // defined(BOOST_ASIO_HAS_EPOLL) # endif // !defined(BOOST_ASIO_HAS_TIMERFD) #endif // defined(__linux__) // Mac OS X, FreeBSD, NetBSD, OpenBSD: kqueue. #if (defined(__MACH__) && defined(__APPLE__)) \ \|\| defined(__FreeBSD__) \ \|\| defined(__NetBSD__) \ \|\| defined(__OpenBSD__) # if !defined(BOOST_ASIO_HAS_KQUEUE) # if !defined(BOOST_ASIO_DISABLE_KQUEUE) # define BOOST_ASIO_HAS_KQUEUE 1 # endif // !defined(BOOST_ASIO_DISABLE_KQUEUE) # endif // !defined(BOOST_ASIO_HAS_KQUEUE) #endif // (defined(__MACH__) && defined(__APPLE__)) // \|\| defined(__FreeBSD__) // \|\| defined(__NetBSD__) // \|\| defined(__OpenBSD__) // Solaris: /dev/poll. #if defined(__sun) # if !defined(BOOST_ASIO_HAS_DEV_POLL) # if !defined(BOOST_ASIO_DISABLE_DEV_POLL) # define BOOST_ASIO_HAS_DEV_POLL 1 # endif // !defined(BOOST_ASIO_DISABLE_DEV_POLL) # endif // !defined(BOOST_ASIO_HAS_DEV_POLL) #endif // defined(__sun) // Serial ports. #if !defined(BOOST_ASIO_HAS_SERIAL_PORT) # if defined(BOOST_ASIO_HAS_IOCP) \ \|\| !defined(BOOST_ASIO_WINDOWS) \ && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ && !defined(__CYGWIN__) # if !defined(__SYMBIAN32__) # if !defined(BOOST_ASIO_DISABLE_SERIAL_PORT) # define BOOST_ASIO_HAS_SERIAL_PORT 1 # endif // !defined(BOOST_ASIO_DISABLE_SERIAL_PORT) # endif // !defined(__SYMBIAN32__) # endif // defined(BOOST_ASIO_HAS_IOCP) // \|\| !defined(BOOST_ASIO_WINDOWS) // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) // && !defined(__CYGWIN__) #endif // !defined(BOOST_ASIO_HAS_SERIAL_PORT) // Windows: stream handles. #if !defined(BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE) # if !defined(BOOST_ASIO_DISABLE_WINDOWS_STREAM_HANDLE) # if defined(BOOST_ASIO_HAS_IOCP) # define BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE 1 # endif // defined(BOOST_ASIO_HAS_IOCP) # endif // !defined(BOOST_ASIO_DISABLE_WINDOWS_STREAM_HANDLE) #endif // !defined(BOOST_ASIO_HAS_WINDOWS_STREAM_HANDLE) // Windows: random access handles. #if !defined(BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE) # if !defined(BOOST_ASIO_DISABLE_WINDOWS_RANDOM_ACCESS_HANDLE) # if defined(BOOST_ASIO_HAS_IOCP) # define BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE 1 # endif // defined(BOOST_ASIO_HAS_IOCP) # endif // !defined(BOOST_ASIO_DISABLE_WINDOWS_RANDOM_ACCESS_HANDLE) #endif // !defined(BOOST_ASIO_HAS_WINDOWS_RANDOM_ACCESS_HANDLE) // Windows: object handles. #if !defined(BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE) # if !defined(BOOST_ASIO_DISABLE_WINDOWS_OBJECT_HANDLE) # if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) # if !defined(UNDER_CE) && !defined(BOOST_ASIO_WINDOWS_APP) # define BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE 1 # endif // !defined(UNDER_CE) && !defined(BOOST_ASIO_WINDOWS_APP) # endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) # endif // !defined(BOOST_ASIO_DISABLE_WINDOWS_OBJECT_HANDLE) #endif // !defined(BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE) // Windows: OVERLAPPED wrapper. #if !defined(BOOST_ASIO_HAS_WINDOWS_OVERLAPPED_PTR) # if !defined(BOOST_ASIO_DISABLE_WINDOWS_OVERLAPPED_PTR) # if defined(BOOST_ASIO_HAS_IOCP) # define BOOST_ASIO_HAS_WINDOWS_OVERLAPPED_PTR 1 # endif // defined(BOOST_ASIO_HAS_IOCP) # endif // !defined(BOOST_ASIO_DISABLE_WINDOWS_OVERLAPPED_PTR) #endif // !defined(BOOST_ASIO_HAS_WINDOWS_OVERLAPPED_PTR) // POSIX: stream-oriented file descriptors. #if !defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR) # if !defined(BOOST_ASIO_DISABLE_POSIX_STREAM_DESCRIPTOR) # if !defined(BOOST_ASIO_WINDOWS) \ && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ && !defined(__CYGWIN__) # define BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR 1 # endif // !defined(BOOST_ASIO_WINDOWS) // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) // && !defined(__CYGWIN__) # endif // !defined(BOOST_ASIO_DISABLE_POSIX_STREAM_DESCRIPTOR) #endif // !defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR) // UNIX domain sockets. #if !defined(BOOST_ASIO_HAS_LOCAL_SOCKETS) # if !defined(BOOST_ASIO_DISABLE_LOCAL_SOCKETS) # if !defined(BOOST_ASIO_WINDOWS_RUNTIME) # define BOOST_ASIO_HAS_LOCAL_SOCKETS 1 # endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) # endif // !defined(BOOST_ASIO_DISABLE_LOCAL_SOCKETS) #endif // !defined(BOOST_ASIO_HAS_LOCAL_SOCKETS) // Can use sigaction() instead of signal(). #if !defined(BOOST_ASIO_HAS_SIGACTION) # if !defined(BOOST_ASIO_DISABLE_SIGACTION) # if !defined(BOOST_ASIO_WINDOWS) \ && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ && !defined(__CYGWIN__) # define BOOST_ASIO_HAS_SIGACTION 1 # endif // !defined(BOOST_ASIO_WINDOWS) // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) // && !defined(__CYGWIN__) # endif // !defined(BOOST_ASIO_DISABLE_SIGACTION) #endif // !defined(BOOST_ASIO_HAS_SIGACTION) // Can use signal(). #if !defined(BOOST_ASIO_HAS_SIGNAL) # if !defined(BOOST_ASIO_DISABLE_SIGNAL) # if !defined(UNDER_CE) # define BOOST_ASIO_HAS_SIGNAL 1 # endif // !defined(UNDER_CE) # endif // !defined(BOOST_ASIO_DISABLE_SIGNAL) #endif // !defined(BOOST_ASIO_HAS_SIGNAL) // Can use getaddrinfo() and getnameinfo(). #if !defined(BOOST_ASIO_HAS_GETADDRINFO) # if !defined(BOOST_ASIO_DISABLE_GETADDRINFO) # if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) # if defined(_WIN32_WINNT) && (_WIN32_WINNT >= 0x0501) # define BOOST_ASIO_HAS_GETADDRINFO 1 # elif defined(UNDER_CE) # define BOOST_ASIO_HAS_GETADDRINFO 1 # endif // defined(UNDER_CE) # elif defined(__MACH__) && defined(__APPLE__) # if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) # if (__MAC_OS_X_VERSION_MIN_REQUIRED >= 1050) # define BOOST_ASIO_HAS_GETADDRINFO 1 # endif // (__MAC_OS_X_VERSION_MIN_REQUIRED >= 1050) # else // defined(__MAC_OS_X_VERSION_MIN_REQUIRED) # define BOOST_ASIO_HAS_GETADDRINFO 1 # endif // defined(__MAC_OS_X_VERSION_MIN_REQUIRED) # else // defined(__MACH__) && defined(__APPLE__) # define BOOST_ASIO_HAS_GETADDRINFO 1 # endif // defined(__MACH__) && defined(__APPLE__) # endif // !defined(BOOST_ASIO_DISABLE_GETADDRINFO) #endif // !defined(BOOST_ASIO_HAS_GETADDRINFO) // Whether standard iostreams are disabled. #if !defined(BOOST_ASIO_NO_IOSTREAM) # if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_NO_IOSTREAM) # define BOOST_ASIO_NO_IOSTREAM 1 # endif // !defined(BOOST_NO_IOSTREAM) #endif // !defined(BOOST_ASIO_NO_IOSTREAM) // Whether exception handling is disabled. #if !defined(BOOST_ASIO_NO_EXCEPTIONS) # if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_NO_EXCEPTIONS) # define BOOST_ASIO_NO_EXCEPTIONS 1 # endif // !defined(BOOST_NO_EXCEPTIONS) #endif // !defined(BOOST_ASIO_NO_EXCEPTIONS) // Whether the typeid operator is supported. #if !defined(BOOST_ASIO_NO_TYPEID) # if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_NO_TYPEID) # define BOOST_ASIO_NO_TYPEID 1 # endif // !defined(BOOST_NO_TYPEID) #endif // !defined(BOOST_ASIO_NO_TYPEID) // Threads. #if !defined(BOOST_ASIO_HAS_THREADS) # if !defined(BOOST_ASIO_DISABLE_THREADS) # if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_HAS_THREADS) # define BOOST_ASIO_HAS_THREADS 1 # elif defined(__GNUC__) && !defined(__MINGW32__) \ && !defined(linux) && !defined(__linux) && !defined(__linux__) # define BOOST_ASIO_HAS_THREADS 1 # elif defined(_MT) \|\| defined(__MT__) # define BOOST_ASIO_HAS_THREADS 1 # elif defined(_REENTRANT) # define BOOST_ASIO_HAS_THREADS 1 # elif defined(__APPLE__) # define BOOST_ASIO_HAS_THREADS 1 # elif defined(__HAIKU__) # define BOOST_ASIO_HAS_THREADS 1 # elif defined(_POSIX_THREADS) && (_POSIX_THREADS + 0 >= 0) # define BOOST_ASIO_HAS_THREADS 1 # elif defined(_PTHREADS) # define BOOST_ASIO_HAS_THREADS 1 # endif // defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_HAS_THREADS) # endif // !defined(BOOST_ASIO_DISABLE_THREADS) #endif // !defined(BOOST_ASIO_HAS_THREADS) // POSIX threads. #if !defined(BOOST_ASIO_HAS_PTHREADS) # if defined(BOOST_ASIO_HAS_THREADS) # if defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_HAS_PTHREADS) # define BOOST_ASIO_HAS_PTHREADS 1 # elif defined(_POSIX_THREADS) && (_POSIX_THREADS + 0 >= 0) # define BOOST_ASIO_HAS_PTHREADS 1 # elif defined(__HAIKU__) # define BOOST_ASIO_HAS_PTHREADS 1 # endif // defined(BOOST_ASIO_HAS_BOOST_CONFIG) && defined(BOOST_HAS_PTHREADS) # endif // defined(BOOST_ASIO_HAS_THREADS) #endif // !defined(BOOST_ASIO_HAS_PTHREADS) // Helper to prevent macro expansion. #define BOOST_ASIO_PREVENT_MACRO_SUBSTITUTION // Helper to define in-class constants. #if !defined(BOOST_ASIO_STATIC_CONSTANT) # if !defined(BOOST_ASIO_DISABLE_BOOST_STATIC_CONSTANT) # define BOOST_ASIO_STATIC_CONSTANT(type, assignment) \ BOOST_STATIC_CONSTANT(type, assignment) # else // !defined(BOOST_ASIO_DISABLE_BOOST_STATIC_CONSTANT) # define BOOST_ASIO_STATIC_CONSTANT(type, assignment) \ static const type assignment # endif // !defined(BOOST_ASIO_DISABLE_BOOST_STATIC_CONSTANT) #endif // !defined(BOOST_ASIO_STATIC_CONSTANT) // Boost array library. #if !defined(BOOST_ASIO_HAS_BOOST_ARRAY) # if !defined(BOOST_ASIO_DISABLE_BOOST_ARRAY) # define BOOST_ASIO_HAS_BOOST_ARRAY 1 # endif // !defined(BOOST_ASIO_DISABLE_BOOST_ARRAY) #endif // !defined(BOOST_ASIO_HAS_BOOST_ARRAY) // Boost assert macro. #if !defined(BOOST_ASIO_HAS_BOOST_ASSERT) # if !defined(BOOST_ASIO_DISABLE_BOOST_ASSERT) # define BOOST_ASIO_HAS_BOOST_ASSERT 1 # endif // !defined(BOOST_ASIO_DISABLE_BOOST_ASSERT) #endif // !defined(BOOST_ASIO_HAS_BOOST_ASSERT) // Boost limits header. #if !defined(BOOST_ASIO_HAS_BOOST_LIMITS) # if !defined(BOOST_ASIO_DISABLE_BOOST_LIMITS) # define BOOST_ASIO_HAS_BOOST_LIMITS 1 # endif // !defined(BOOST_ASIO_DISABLE_BOOST_LIMITS) #endif // !defined(BOOST_ASIO_HAS_BOOST_LIMITS) // Boost throw_exception function. #if !defined(BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION) # if !defined(BOOST_ASIO_DISABLE_BOOST_THROW_EXCEPTION) # define BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION 1 # endif // !defined(BOOST_ASIO_DISABLE_BOOST_THROW_EXCEPTION) #endif // !defined(BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION) // Boost regex library. #if !defined(BOOST_ASIO_HAS_BOOST_REGEX) # if !defined(BOOST_ASIO_DISABLE_BOOST_REGEX) # define BOOST_ASIO_HAS_BOOST_REGEX 1 # endif // !defined(BOOST_ASIO_DISABLE_BOOST_REGEX) #endif // !defined(BOOST_ASIO_HAS_BOOST_REGEX) // Boost bind function. #if !defined(BOOST_ASIO_HAS_BOOST_BIND) # if !defined(BOOST_ASIO_DISABLE_BOOST_BIND) # define BOOST_ASIO_HAS_BOOST_BIND 1 # endif // !defined(BOOST_ASIO_DISABLE_BOOST_BIND) #endif // !defined(BOOST_ASIO_HAS_BOOST_BIND) // Boost's BOOST_WORKAROUND macro. #if !defined(BOOST_ASIO_HAS_BOOST_WORKAROUND) # if !defined(BOOST_ASIO_DISABLE_BOOST_WORKAROUND) # define BOOST_ASIO_HAS_BOOST_WORKAROUND 1 # endif // !defined(BOOST_ASIO_DISABLE_BOOST_WORKAROUND) #endif // !defined(BOOST_ASIO_HAS_BOOST_WORKAROUND) // Microsoft Visual C++'s secure C runtime library. #if !defined(BOOST_ASIO_HAS_SECURE_RTL) # if !defined(BOOST_ASIO_DISABLE_SECURE_RTL) # if defined(BOOST_ASIO_MSVC) \ && (BOOST_ASIO_MSVC >= 1400) \ && !defined(UNDER_CE) # define BOOST_ASIO_HAS_SECURE_RTL 1 # endif // defined(BOOST_ASIO_MSVC) // && (BOOST_ASIO_MSVC >= 1400) // && !defined(UNDER_CE) # endif // !defined(BOOST_ASIO_DISABLE_SECURE_RTL) #endif // !defined(BOOST_ASIO_HAS_SECURE_RTL) // Handler hooking. Disabled for ancient Borland C++ and gcc compilers. #if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS) # if !defined(BOOST_ASIO_DISABLE_HANDLER_HOOKS) # if defined(__GNUC__) # if (__GNUC__ >= 3) # define BOOST_ASIO_HAS_HANDLER_HOOKS 1 # endif // (__GNUC__ >= 3) # elif !defined(__BORLANDC__) \|\| defined(__clang__) # define BOOST_ASIO_HAS_HANDLER_HOOKS 1 # endif // !defined(__BORLANDC__) \|\| defined(__clang__) # endif // !defined(BOOST_ASIO_DISABLE_HANDLER_HOOKS) #endif // !defined(BOOST_ASIO_HAS_HANDLER_HOOKS) // Support for the __thread keyword extension. #if !defined(BOOST_ASIO_DISABLE_THREAD_KEYWORD_EXTENSION) # if defined(__linux__) # if defined(__GNUC__) && (defined(__i386__) \|\| defined(__x86_64__)) # if ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) \|\| (__GNUC__ > 3) # if !defined(__INTEL_COMPILER) && !defined(__ICL) \ && !(defined(__clang__) && defined(__ANDROID__)) # define BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION 1 # define BOOST_ASIO_THREAD_KEYWORD __thread # elif defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1100) # define BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION 1 # endif // defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1100) // && !(defined(__clang__) && defined(__ANDROID__)) # endif // ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) \|\| (__GNUC__ > 3) # endif // defined(__GNUC__) && (defined(__i386__) \|\| defined(__x86_64__)) # endif // defined(__linux__) # if defined(BOOST_ASIO_MSVC) && defined(BOOST_ASIO_WINDOWS_RUNTIME) # if (_MSC_VER >= 1700) # define BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION 1 # define BOOST_ASIO_THREAD_KEYWORD __declspec(thread) # endif // (_MSC_VER >= 1700) # endif // defined(BOOST_ASIO_MSVC) && defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // !defined(BOOST_ASIO_DISABLE_THREAD_KEYWORD_EXTENSION) #if !defined(BOOST_ASIO_THREAD_KEYWORD) # define BOOST_ASIO_THREAD_KEYWORD __thread #endif // !defined(BOOST_ASIO_THREAD_KEYWORD) // Support for POSIX ssize_t typedef. #if !defined(BOOST_ASIO_DISABLE_SSIZE_T) # if defined(__linux__) \ \|\| (defined(__MACH__) && defined(__APPLE__)) # define BOOST_ASIO_HAS_SSIZE_T 1 # endif // defined(__linux__) // \|\| (defined(__MACH__) && defined(__APPLE__)) #endif // !defined(BOOST_ASIO_DISABLE_SSIZE_T) // Helper macros to manage transition away from error_code return values. #if defined(BOOST_ASIO_NO_DEPRECATED) # define BOOST_ASIO_SYNC_OP_VOID void # define BOOST_ASIO_SYNC_OP_VOID_RETURN(e) return #else // defined(BOOST_ASIO_NO_DEPRECATED) # define BOOST_ASIO_SYNC_OP_VOID boost::system::error_code # define BOOST_ASIO_SYNC_OP_VOID_RETURN(e) return e #endif // defined(BOOST_ASIO_NO_DEPRECATED) // Newer gcc, clang need special treatment to suppress unused typedef warnings. #if defined(__clang__) # if defined(__apple_build_version__) # if (__clang_major__ >= 7) # define BOOST_ASIO_UNUSED_TYPEDEF __attribute__((__unused__)) # endif // (__clang_major__ >= 7) # elif ((__clang_major__ == 3) && (__clang_minor__ >= 6)) \ \|\| (__clang_major__ > 3) # define BOOST_ASIO_UNUSED_TYPEDEF __attribute__((__unused__)) # endif // ((__clang_major__ == 3) && (__clang_minor__ >= 6)) // \|\| (__clang_major__ > 3) #elif defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) \|\| (__GNUC__ > 4) # define BOOST_ASIO_UNUSED_TYPEDEF __attribute__((__unused__)) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) \|\| (__GNUC__ > 4) #endif // defined(__GNUC__) #if !defined(BOOST_ASIO_UNUSED_TYPEDEF) # define BOOST_ASIO_UNUSED_TYPEDEF #endif // !defined(BOOST_ASIO_UNUSED_TYPEDEF) // Some versions of gcc generate spurious warnings about unused variables. #if defined(__GNUC__) # if (__GNUC__ >= 4) # define BOOST_ASIO_UNUSED_VARIABLE __attribute__((__unused__)) # endif // (__GNUC__ >= 4) #endif // defined(__GNUC__) #if !defined(BOOST_ASIO_UNUSED_VARIABLE) # define BOOST_ASIO_UNUSED_VARIABLE #endif // !defined(BOOST_ASIO_UNUSED_VARIABLE) // Support the co_await keyword on compilers known to allow it. #if !defined(BOOST_ASIO_HAS_CO_AWAIT) # if !defined(BOOST_ASIO_DISABLE_CO_AWAIT) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1928) && (_MSVC_LANG >= 201705) # define BOOST_ASIO_HAS_CO_AWAIT 1 # elif (_MSC_FULL_VER >= 190023506) # if defined(_RESUMABLE_FUNCTIONS_SUPPORTED) # define BOOST_ASIO_HAS_CO_AWAIT 1 # endif // defined(_RESUMABLE_FUNCTIONS_SUPPORTED) # endif // (_MSC_FULL_VER >= 190023506) # endif // defined(BOOST_ASIO_MSVC) # if defined(__clang__) # if (__cplusplus >= 201703) && (__cpp_coroutines >= 201703) # if __has_include(<experimental/coroutine>) # define BOOST_ASIO_HAS_CO_AWAIT 1 # endif // __has_include(<experimental/coroutine>) # endif // (__cplusplus >= 201703) && (__cpp_coroutines >= 201703) # elif defined(__GNUC__) # if (__cplusplus >= 201709) && (__cpp_impl_coroutine >= 201902) # if __has_include(<coroutine>) # define BOOST_ASIO_HAS_CO_AWAIT 1 # endif // __has_include(<coroutine>) # endif // (__cplusplus >= 201709) && (__cpp_impl_coroutine >= 201902) # endif // defined(__GNUC__) # endif // !defined(BOOST_ASIO_DISABLE_CO_AWAIT) #endif // !defined(BOOST_ASIO_HAS_CO_AWAIT) // Standard library support for coroutines. #if !defined(BOOST_ASIO_HAS_STD_COROUTINE) # if !defined(BOOST_ASIO_DISABLE_STD_COROUTINE) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1928) && (_MSVC_LANG >= 201705) # define BOOST_ASIO_HAS_STD_COROUTINE 1 # endif // (_MSC_VER >= 1928) && (_MSVC_LANG >= 201705) # endif // defined(BOOST_ASIO_MSVC) # if defined(__GNUC__) # if (__cplusplus >= 201709) && (__cpp_impl_coroutine >= 201902) # if __has_include(<coroutine>) # define BOOST_ASIO_HAS_STD_COROUTINE 1 # endif // __has_include(<coroutine>) # endif // (__cplusplus >= 201709) && (__cpp_impl_coroutine >= 201902) # endif // defined(__GNUC__) # endif // !defined(BOOST_ASIO_DISABLE_STD_COROUTINE) #endif // !defined(BOOST_ASIO_HAS_STD_COROUTINE) // Compiler support for the the [[nodiscard]] attribute. #if !defined(BOOST_ASIO_NODISCARD) # if defined(__has_cpp_attribute) # if __has_cpp_attribute(nodiscard) # if (__cplusplus >= 201703) # define BOOST_ASIO_NODISCARD [[nodiscard]] # endif // (__cplusplus >= 201703) # endif // __has_cpp_attribute(nodiscard) # endif // defined(__has_cpp_attribute) #endif // !defined(BOOST_ASIO_NODISCARD) #if !defined(BOOST_ASIO_NODISCARD) # define BOOST_ASIO_NODISCARD #endif // !defined(BOOST_ASIO_NODISCARD) // Kernel support for MSG_NOSIGNAL. #if !defined(BOOST_ASIO_HAS_MSG_NOSIGNAL) # if defined(__linux__) # define BOOST_ASIO_HAS_MSG_NOSIGNAL 1 # elif defined(_POSIX_VERSION) # if (_POSIX_VERSION >= 200809L) # define BOOST_ASIO_HAS_MSG_NOSIGNAL 1 # endif // _POSIX_VERSION >= 200809L # endif // defined(_POSIX_VERSION) #endif // !defined(BOOST_ASIO_HAS_MSG_NOSIGNAL) #endif // BOOST_ASIO_DETAIL_CONFIG_HPP PK��Bb�[��tϋ��random_provider.hppnu��[��// // Copyright (c) 2017 James E. King III // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // https://www.boost.org/LICENSE_1_0.txt) // // Platform-specific random entropy provider // #ifndef BOOST_UUID_DETAIL_RANDOM_PROVIDER_HPP #define BOOST_UUID_DETAIL_RANDOM_PROVIDER_HPP #include <boost/config.hpp> #include <boost/cstdint.hpp> #include <boost/limits.hpp> #include <boost/static_assert.hpp> #include <boost/move/core.hpp> #include <boost/move/utility_core.hpp> #include <boost/type_traits/is_integral.hpp> #include <boost/type_traits/is_unsigned.hpp> #include <boost/uuid/entropy_error.hpp> #include <climits> #include <iterator> // Detection of the platform is separated from inclusion of the correct // header to facilitate mock testing of the provider implementations. #include <boost/uuid/detail/random_provider_detect_platform.hpp> #include <boost/uuid/detail/random_provider_include_platform.hpp> namespace boost { namespace uuids { namespace detail { //! \brief Contains code common to all random_provider implementations. //! \note random_provider_base is required to provide this method: //! void get_random_bytes(void buf, size_t siz); //! \note noncopyable because of some base implementations so //! this makes it uniform across platforms to avoid any //! porting surprises class random_provider : public detail::random_provider_base { BOOST_MOVABLE_BUT_NOT_COPYABLE(random_provider) public: BOOST_DEFAULTED_FUNCTION(random_provider(), {}) random_provider(BOOST_RV_REF(random_provider) that) BOOST_NOEXCEPT : detail::random_provider_base(boost::move(static_cast< detail::random_provider_base& >(that))) { } random_provider& operator= (BOOST_RV_REF(random_provider) that) BOOST_NOEXCEPT { static_cast< detail::random_provider_base& >(this) = boost::move(static_cast< detail::random_provider_base& >(that)); return this; } //! Leverage the provider as a SeedSeq for //! PseudoRandomNumberGeneration seeing. //! \note: See Boost.Random documentation for more details template<class Iter> void generate(Iter first, Iter last) { typedef typename std::iterator_traits<Iter>::value_type value_type; BOOST_STATIC_ASSERT(is_integral<value_type>::value); BOOST_STATIC_ASSERT(is_unsigned<value_type>::value); BOOST_STATIC_ASSERT(sizeof(value_type) CHAR_BIT >= 32); for (; first != last; ++first) { get_random_bytes(&first, sizeof(first)); first &= (std::numeric_limits<boost::uint32_t>::max)(); } } //! Return the name of the selected provider const char name() const { return BOOST_UUID_RANDOM_PROVIDER_STRINGIFY(BOOST_UUID_RANDOM_PROVIDER_NAME); } }; } // detail } // uuids } // boost #endif // BOOST_UUID_DETAIL_RANDOM_PROVIDER_HPP PK��Bb�[ ��W��random_provider_bcrypt.ippnu��[��// // Copyright (c) 2017 James E. King III // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // https://www.boost.org/LICENSE_1_0.txt) // // BCrypt provider for entropy // #include <cstddef> #include <boost/config.hpp> #include <boost/core/ignore_unused.hpp> #include <boost/move/core.hpp> #include <boost/numeric/conversion/cast.hpp> #include <boost/winapi/bcrypt.hpp> #include <boost/winapi/get_last_error.hpp> #include <boost/throw_exception.hpp> #if defined(BOOST_UUID_FORCE_AUTO_LINK) \|\| (!defined(BOOST_ALL_NO_LIB) && !defined(BOOST_UUID_RANDOM_PROVIDER_NO_LIB)) # define BOOST_LIB_NAME "bcrypt" # if defined(BOOST_AUTO_LINK_NOMANGLE) # include <boost/config/auto_link.hpp> # else # define BOOST_AUTO_LINK_NOMANGLE # include <boost/config/auto_link.hpp> # undef BOOST_AUTO_LINK_NOMANGLE # endif #endif namespace boost { namespace uuids { namespace detail { class random_provider_base { BOOST_MOVABLE_BUT_NOT_COPYABLE(random_provider_base) public: random_provider_base() : hProv_(NULL) { boost::winapi::NTSTATUS_ status = boost::winapi::BCryptOpenAlgorithmProvider( &hProv_, boost::winapi::BCRYPT_RNG_ALGORITHM_, NULL, 0); if (BOOST_UNLIKELY(status != 0)) { BOOST_THROW_EXCEPTION(entropy_error(status, "BCryptOpenAlgorithmProvider")); } } random_provider_base(BOOST_RV_REF(random_provider_base) that) BOOST_NOEXCEPT : hProv_(that.hProv_) { that.hProv_ = NULL; } random_provider_base& operator= (BOOST_RV_REF(random_provider_base) that) BOOST_NOEXCEPT { destroy(); hProv_ = that.hProv_; that.hProv_ = NULL; return this; } ~random_provider_base() BOOST_NOEXCEPT { destroy(); } //! Obtain entropy and place it into a memory location //! \param[in] buf the location to write entropy //! \param[in] siz the number of bytes to acquire void get_random_bytes(void buf, std::size_t siz) { boost::winapi::NTSTATUS_ status = boost::winapi::BCryptGenRandom( hProv_, static_cast<boost::winapi::PUCHAR_>(buf), boost::numeric_cast<boost::winapi::ULONG_>(siz), 0); if (BOOST_UNLIKELY(status != 0)) { BOOST_THROW_EXCEPTION(entropy_error(status, "BCryptGenRandom")); } } private: void destroy() BOOST_NOEXCEPT { if (hProv_) { boost::ignore_unused(boost::winapi::BCryptCloseAlgorithmProvider(hProv_, 0)); } } private: boost::winapi::BCRYPT_ALG_HANDLE_ hProv_; }; } // detail } // uuids } // boost PK��Bb�[��z �� sha1.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_SHA1_HPP #define BOOST_COMPUTE_DETAIL_SHA1_HPP #include <sstream> #include <iomanip> #include <boost/version.hpp> #if BOOST_VERSION >= 106600 # include <boost/uuid/detail/sha1.hpp> #else # include <boost/uuid/sha1.hpp> #endif namespace boost { namespace compute { namespace detail { // Accumulates SHA1 hash of the passed strings. class sha1 { public: sha1(const std::string &s = "") { if (!s.empty()) this->process(s); } sha1& process(const std::string &s) { h.process_bytes(s.c_str(), s.size()); return this; } operator std::string() { unsigned int digest[5]; h.get_digest(digest); std::ostringstream buf; for(int i = 0; i < 5; ++i) buf << std::hex << std::setfill('0') << std::setw(8) << digest[i]; return buf.str(); } private: boost::uuids::detail::sha1 h; }; } // end detail namespace } // end compute namespace } // end boost namespace #endif // BOOST_COMPUTE_DETAIL_SHA1_HPP PK��Bb�[��wa��a��uuid_x86.ippnu��[��/ * Copyright Andrey Semashev 2013. * Distributed under the Boost Software License, Version 1.0. * (See accompanying file LICENSE_1_0.txt or copy at * https://www.boost.org/LICENSE_1_0.txt) / /! * \file uuid/detail/uuid_x86.ipp * * \brief This header contains optimized SSE implementation of \c boost::uuid operations. / #ifndef BOOST_UUID_DETAIL_UUID_X86_IPP_INCLUDED_ #define BOOST_UUID_DETAIL_UUID_X86_IPP_INCLUDED_ // MSVC does not always have immintrin.h (at least, not up to MSVC 10), so include the appropriate header for each instruction set #if defined(BOOST_UUID_USE_SSE41) #include <smmintrin.h> #elif defined(BOOST_UUID_USE_SSE3) #include <pmmintrin.h> #else #include <emmintrin.h> #endif #if defined(BOOST_MSVC) && defined(_M_X64) && !defined(BOOST_UUID_USE_SSE3) && (BOOST_MSVC < 1900 / Fixed in Visual Studio 2015 / ) // At least MSVC 9 (VS2008) and 12 (VS2013) have an optimizer bug that sometimes results in incorrect SIMD code // generated in Release x64 mode. In particular, it affects operator==, where the compiler sometimes generates // pcmpeqd with a memory opereand instead of movdqu followed by pcmpeqd. The problem is that uuid can be // not aligned to 16 bytes and pcmpeqd causes alignment violation in this case. We cannot be sure that other // MSVC versions are not affected so we apply the workaround for all versions, except VS2015 on up where // the bug has been fixed. // // https://svn.boost.org/trac/boost/ticket/8509#comment:3 // https://connect.microsoft.com/VisualStudio/feedbackdetail/view/981648#tabs #define BOOST_UUID_DETAIL_MSVC_BUG981648 #if BOOST_MSVC >= 1600 extern "C" void _ReadWriteBarrier(void); #pragma intrinsic(_ReadWriteBarrier) #endif #endif namespace boost { namespace uuids { namespace detail { BOOST_FORCEINLINE __m128i load_unaligned_si128(const uint8_t p) BOOST_NOEXCEPT { #if defined(BOOST_UUID_USE_SSE3) return _mm_lddqu_si128(reinterpret_cast< const __m128i* >(p)); #elif !defined(BOOST_UUID_DETAIL_MSVC_BUG981648) return _mm_loadu_si128(reinterpret_cast< const __m128i* >(p)); #elif defined(BOOST_MSVC) && BOOST_MSVC >= 1600 __m128i mm = _mm_loadu_si128(reinterpret_cast< const __m128i* >(p)); // Make sure this load doesn't get merged with the subsequent instructions _ReadWriteBarrier(); return mm; #else // VS2008 x64 doesn't respect _ReadWriteBarrier above, so we have to generate this crippled code to load unaligned data return _mm_unpacklo_epi64(_mm_loadl_epi64(reinterpret_cast< const __m128i* >(p)), _mm_loadl_epi64(reinterpret_cast< const __m128i* >(p + 8))); #endif } } // namespace detail inline bool uuid::is_nil() const BOOST_NOEXCEPT { __m128i mm = uuids::detail::load_unaligned_si128(data); #if defined(BOOST_UUID_USE_SSE41) return _mm_test_all_zeros(mm, mm) != 0; #else mm = _mm_cmpeq_epi32(mm, _mm_setzero_si128()); return _mm_movemask_epi8(mm) == 0xFFFF; #endif } inline void uuid::swap(uuid& rhs) BOOST_NOEXCEPT { __m128i mm_this = uuids::detail::load_unaligned_si128(data); __m128i mm_rhs = uuids::detail::load_unaligned_si128(rhs.data); _mm_storeu_si128(reinterpret_cast< __m128i* >(rhs.data), mm_this); _mm_storeu_si128(reinterpret_cast< __m128i* >(data), mm_rhs); } inline bool operator== (uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT { __m128i mm_left = uuids::detail::load_unaligned_si128(lhs.data); __m128i mm_right = uuids::detail::load_unaligned_si128(rhs.data); #if defined(BOOST_UUID_USE_SSE41) __m128i mm = _mm_xor_si128(mm_left, mm_right); return _mm_test_all_zeros(mm, mm) != 0; #else __m128i mm_cmp = _mm_cmpeq_epi32(mm_left, mm_right); return _mm_movemask_epi8(mm_cmp) == 0xFFFF; #endif } inline bool operator< (uuid const& lhs, uuid const& rhs) BOOST_NOEXCEPT { __m128i mm_left = uuids::detail::load_unaligned_si128(lhs.data); __m128i mm_right = uuids::detail::load_unaligned_si128(rhs.data); // To emulate lexicographical_compare behavior we have to perform two comparisons - the forward and reverse one. // Then we know which bytes are equivalent and which ones are different, and for those different the comparison results // will be opposite. Then we'll be able to find the first differing comparison result (for both forward and reverse ways), // and depending on which way it is for, this will be the result of the operation. There are a few notes to consider: // // 1. Due to little endian byte order the first bytes go into the lower part of the xmm registers, // so the comparison results in the least significant bits will actually be the most signigicant for the final operation result. // This means we have to determine which of the comparison results have the least significant bit on, and this is achieved with // the "(x - 1) ^ x" trick. // 2. Because there is only signed comparison in SSE/AVX, we have to invert byte comparison results whenever signs of the corresponding // bytes are different. I.e. in signed comparison it's -1 < 1, but in unsigned it is the opposite (255 > 1). To do that we XOR left and right, // making the most significant bit of each byte 1 if the signs are different, and later apply this mask with another XOR to the comparison results. // 3. pcmpgtw compares for "greater" relation, so we swap the arguments to get what we need. const __m128i mm_signs_mask = _mm_xor_si128(mm_left, mm_right); __m128i mm_cmp = _mm_cmpgt_epi8(mm_right, mm_left), mm_rcmp = _mm_cmpgt_epi8(mm_left, mm_right); mm_cmp = _mm_xor_si128(mm_signs_mask, mm_cmp); mm_rcmp = _mm_xor_si128(mm_signs_mask, mm_rcmp); uint32_t cmp = static_cast< uint32_t >(_mm_movemask_epi8(mm_cmp)), rcmp = static_cast< uint32_t >(_mm_movemask_epi8(mm_rcmp)); cmp = (cmp - 1u) ^ cmp; rcmp = (rcmp - 1u) ^ rcmp; return cmp < rcmp; } } // namespace uuids } // namespace boost #endif // BOOST_UUID_DETAIL_UUID_X86_IPP_INCLUDED_ PK��Bb�[��]c��random_provider_posix.ippnu��[��/* boost uuid/detail/random_provider_posix implementation * * Copyright Jens Maurer 2000 * Copyright 2007 Andy Tompkins. * Copyright Steven Watanabe 2010-2011 * Copyright 2017 James E. King III * * Distributed under the Boost Software License, Version 1.0. (See * accompanying file LICENSE_1_0.txt or copy at * https://www.boost.org/LICENSE_1_0.txt) * * $Id$ / #include <boost/config.hpp> #include <boost/core/ignore_unused.hpp> #include <boost/move/core.hpp> #include <boost/throw_exception.hpp> #include <boost/uuid/entropy_error.hpp> #include <cerrno> #include <cstddef> #include <fcntl.h> // open #include <sys/stat.h> #include <sys/types.h> #if defined(BOOST_HAS_UNISTD_H) #include <unistd.h> #endif #ifndef BOOST_UUID_RANDOM_PROVIDER_POSIX_IMPL_CLOSE #define BOOST_UUID_RANDOM_PROVIDER_POSIX_IMPL_CLOSE ::close #endif #ifndef BOOST_UUID_RANDOM_PROVIDER_POSIX_IMPL_OPEN #define BOOST_UUID_RANDOM_PROVIDER_POSIX_IMPL_OPEN ::open #endif #ifndef BOOST_UUID_RANDOM_PROVIDER_POSIX_IMPL_READ #define BOOST_UUID_RANDOM_PROVIDER_POSIX_IMPL_READ ::read #endif namespace boost { namespace uuids { namespace detail { class random_provider_base { BOOST_MOVABLE_BUT_NOT_COPYABLE(random_provider_base) public: random_provider_base() : fd_(-1) { int flags = O_RDONLY; #if defined(O_CLOEXEC) flags \|= O_CLOEXEC; #endif fd_ = BOOST_UUID_RANDOM_PROVIDER_POSIX_IMPL_OPEN("/dev/urandom", flags); if (BOOST_UNLIKELY(-1 == fd_)) { int err = errno; BOOST_THROW_EXCEPTION(entropy_error(err, "open /dev/urandom")); } } random_provider_base(BOOST_RV_REF(random_provider_base) that) BOOST_NOEXCEPT : fd_(that.fd_) { that.fd_ = -1; } random_provider_base& operator= (BOOST_RV_REF(random_provider_base) that) BOOST_NOEXCEPT { destroy(); fd_ = that.fd_; that.fd_ = -1; return this; } ~random_provider_base() BOOST_NOEXCEPT { destroy(); } //! Obtain entropy and place it into a memory location //! \param[in] buf the location to write entropy //! \param[in] siz the number of bytes to acquire void get_random_bytes(void buf, std::size_t siz) { std::size_t offset = 0; while (offset < siz) { ssize_t sz = BOOST_UUID_RANDOM_PROVIDER_POSIX_IMPL_READ( fd_, static_cast<char >(buf) + offset, siz - offset); if (BOOST_UNLIKELY(sz < 0)) { int err = errno; if (err == EINTR) continue; BOOST_THROW_EXCEPTION(entropy_error(err, "read")); } offset += sz; } } private: void destroy() BOOST_NOEXCEPT { if (fd_ >= 0) { boost::ignore_unused(BOOST_UUID_RANDOM_PROVIDER_POSIX_IMPL_CLOSE(fd_)); } } private: int fd_; }; } // detail } // uuids } // boost PK��Bb�[�C>ϒD��D��md5.hppnu��[��/* * This RFC 1321 compatible MD5 implementation originated at: * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5 * * Author: * Alexander Peslyak, better known as Solar Designer <solar at openwall.com> * * This software was written by Alexander Peslyak in 2001. No copyright is * claimed, and the software is hereby placed in the public domain. * In case this attempt to disclaim copyright and place the software in the * public domain is deemed null and void, then the software is * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the * general public under the following terms: * * Redistribution and use in source and binary forms, with or without * modification, are permitted. * * There's ABSOLUTELY NO WARRANTY, express or implied. * / // Distributed under the Boost Software License, Version 1.0. (See // accompanying file LICENSE_1_0.txt or copy at // https://www.boost.org/LICENSE_1_0.txt) #ifndef BOOST_UUID_MD5_HPP #define BOOST_UUID_MD5_HPP #include <boost/cast.hpp> #include <boost/config.hpp> #include <boost/cstdint.hpp> #include <boost/uuid/uuid.hpp> // for version #include <boost/predef/other/endian.h> #include <string.h> namespace boost { namespace uuids { namespace detail { class md5 { public: typedef unsigned int(digest_type)[4]; md5() { MD5_Init(&ctx_); } void process_byte(unsigned char byte) { MD5_Update(&ctx_, &byte, 1); } void process_bytes(void const buffer, std::size_t byte_count) { MD5_Update(&ctx_, buffer, boost::numeric_cast<unsigned long>(byte_count)); } void get_digest(digest_type& digest) { MD5_Final(reinterpret_cast<unsigned char >(&digest[0]), &ctx_); } unsigned char get_version() const { // RFC 4122 Section 4.1.3 return uuid::version_name_based_md5; } private: / Any 32-bit or wider unsigned integer data type will do / typedef uint32_t MD5_u32plus; typedef struct { MD5_u32plus lo, hi; MD5_u32plus a, b, c, d; unsigned char buffer[64]; MD5_u32plus block[16]; } MD5_CTX; / * The basic MD5 functions. * * F and G are optimized compared to their RFC 1321 definitions for * architectures that lack an AND-NOT instruction, just like in Colin Plumb's * implementation. / BOOST_FORCEINLINE MD5_u32plus BOOST_UUID_DETAIL_MD5_F(MD5_u32plus x, MD5_u32plus y, MD5_u32plus z) { return ((z) ^ ((x) & ((y) ^ (z)))); } BOOST_FORCEINLINE MD5_u32plus BOOST_UUID_DETAIL_MD5_G(MD5_u32plus x, MD5_u32plus y, MD5_u32plus z) { return ((y) ^ ((z) & ((x) ^ (y)))); } BOOST_FORCEINLINE MD5_u32plus BOOST_UUID_DETAIL_MD5_H(MD5_u32plus x, MD5_u32plus y, MD5_u32plus z) { return (((x) ^ (y)) ^ (z)); } BOOST_FORCEINLINE MD5_u32plus BOOST_UUID_DETAIL_MD5_H2(MD5_u32plus x, MD5_u32plus y, MD5_u32plus z) { return ((x) ^ ((y) ^ (z))); } BOOST_FORCEINLINE MD5_u32plus BOOST_UUID_DETAIL_MD5_I(MD5_u32plus x, MD5_u32plus y, MD5_u32plus z) { return ((y) ^ ((x) \| ~(z))); } / * The MD5 transformation for all four rounds. / #define BOOST_UUID_DETAIL_MD5_STEP(f, a, b, c, d, x, t, s) \ (a) += f((b), (c), (d)) + (x) + (t); \ (a) = (((a) << (s)) \| (((a) & 0xffffffff) >> (32 - (s)))); \ (a) += (b); / * SET reads 4 input bytes in little-endian byte order and stores them in a * properly aligned word in host byte order. * * The check for little-endian architectures that tolerate unaligned memory * accesses is just an optimization. Nothing will break if it fails to detect * a suitable architecture. * * Unfortunately, this optimization may be a C strict aliasing rules violation * if the caller's data buffer has effective type that cannot be aliased by * MD5_u32plus. In practice, this problem may occur if these MD5 routines are * inlined into a calling function, or with future and dangerously advanced * link-time optimizations. For the time being, keeping these MD5 routines in * their own translation unit avoids the problem. / #if defined(__i386__) \|\| defined(__x86_64__) \|\| defined(__vax__) #define BOOST_UUID_DETAIL_MD5_SET(n) \ ((MD5_u32plus )&ptr[(n) 4]) #define BOOST_UUID_DETAIL_MD5_GET(n) \ BOOST_UUID_DETAIL_MD5_SET(n) #else #define BOOST_UUID_DETAIL_MD5_SET(n) \ (ctx->block[(n)] = \ (MD5_u32plus)ptr[(n) * 4] \| \ ((MD5_u32plus)ptr[(n) * 4 + 1] << 8) \| \ ((MD5_u32plus)ptr[(n) * 4 + 2] << 16) \| \ ((MD5_u32plus)ptr[(n) * 4 + 3] << 24)) #define BOOST_UUID_DETAIL_MD5_GET(n) \ (ctx->block[(n)]) #endif /* * This processes one or more 64-byte data blocks, but does NOT update the bit * counters. There are no alignment requirements. / const void body(MD5_CTX ctx, const void data, unsigned long size) { const unsigned char ptr; MD5_u32plus a, b, c, d; MD5_u32plus saved_a, saved_b, saved_c, saved_d; ptr = (const unsigned char )data; a = ctx->a; b = ctx->b; c = ctx->c; d = ctx->d; do { saved_a = a; saved_b = b; saved_c = c; saved_d = d; /* Round 1 / BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_F, a, b, c, d, BOOST_UUID_DETAIL_MD5_SET(0), 0xd76aa478, 7) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_F, d, a, b, c, BOOST_UUID_DETAIL_MD5_SET(1), 0xe8c7b756, 12) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_F, c, d, a, b, BOOST_UUID_DETAIL_MD5_SET(2), 0x242070db, 17) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_F, b, c, d, a, BOOST_UUID_DETAIL_MD5_SET(3), 0xc1bdceee, 22) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_F, a, b, c, d, BOOST_UUID_DETAIL_MD5_SET(4), 0xf57c0faf, 7) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_F, d, a, b, c, BOOST_UUID_DETAIL_MD5_SET(5), 0x4787c62a, 12) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_F, c, d, a, b, BOOST_UUID_DETAIL_MD5_SET(6), 0xa8304613, 17) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_F, b, c, d, a, BOOST_UUID_DETAIL_MD5_SET(7), 0xfd469501, 22) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_F, a, b, c, d, BOOST_UUID_DETAIL_MD5_SET(8), 0x698098d8, 7) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_F, d, a, b, c, BOOST_UUID_DETAIL_MD5_SET(9), 0x8b44f7af, 12) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_F, c, d, a, b, BOOST_UUID_DETAIL_MD5_SET(10), 0xffff5bb1, 17) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_F, b, c, d, a, BOOST_UUID_DETAIL_MD5_SET(11), 0x895cd7be, 22) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_F, a, b, c, d, BOOST_UUID_DETAIL_MD5_SET(12), 0x6b901122, 7) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_F, d, a, b, c, BOOST_UUID_DETAIL_MD5_SET(13), 0xfd987193, 12) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_F, c, d, a, b, BOOST_UUID_DETAIL_MD5_SET(14), 0xa679438e, 17) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_F, b, c, d, a, BOOST_UUID_DETAIL_MD5_SET(15), 0x49b40821, 22) / Round 2 / BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_G, a, b, c, d, BOOST_UUID_DETAIL_MD5_GET(1), 0xf61e2562, 5) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_G, d, a, b, c, BOOST_UUID_DETAIL_MD5_GET(6), 0xc040b340, 9) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_G, c, d, a, b, BOOST_UUID_DETAIL_MD5_GET(11), 0x265e5a51, 14) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_G, b, c, d, a, BOOST_UUID_DETAIL_MD5_GET(0), 0xe9b6c7aa, 20) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_G, a, b, c, d, BOOST_UUID_DETAIL_MD5_GET(5), 0xd62f105d, 5) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_G, d, a, b, c, BOOST_UUID_DETAIL_MD5_GET(10), 0x02441453, 9) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_G, c, d, a, b, BOOST_UUID_DETAIL_MD5_GET(15), 0xd8a1e681, 14) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_G, b, c, d, a, BOOST_UUID_DETAIL_MD5_GET(4), 0xe7d3fbc8, 20) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_G, a, b, c, d, BOOST_UUID_DETAIL_MD5_GET(9), 0x21e1cde6, 5) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_G, d, a, b, c, BOOST_UUID_DETAIL_MD5_GET(14), 0xc33707d6, 9) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_G, c, d, a, b, BOOST_UUID_DETAIL_MD5_GET(3), 0xf4d50d87, 14) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_G, b, c, d, a, BOOST_UUID_DETAIL_MD5_GET(8), 0x455a14ed, 20) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_G, a, b, c, d, BOOST_UUID_DETAIL_MD5_GET(13), 0xa9e3e905, 5) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_G, d, a, b, c, BOOST_UUID_DETAIL_MD5_GET(2), 0xfcefa3f8, 9) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_G, c, d, a, b, BOOST_UUID_DETAIL_MD5_GET(7), 0x676f02d9, 14) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_G, b, c, d, a, BOOST_UUID_DETAIL_MD5_GET(12), 0x8d2a4c8a, 20) / Round 3 / BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_H, a, b, c, d, BOOST_UUID_DETAIL_MD5_GET(5), 0xfffa3942, 4) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_H2, d, a, b, c, BOOST_UUID_DETAIL_MD5_GET(8), 0x8771f681, 11) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_H, c, d, a, b, BOOST_UUID_DETAIL_MD5_GET(11), 0x6d9d6122, 16) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_H2, b, c, d, a, BOOST_UUID_DETAIL_MD5_GET(14), 0xfde5380c, 23) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_H, a, b, c, d, BOOST_UUID_DETAIL_MD5_GET(1), 0xa4beea44, 4) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_H2, d, a, b, c, BOOST_UUID_DETAIL_MD5_GET(4), 0x4bdecfa9, 11) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_H, c, d, a, b, BOOST_UUID_DETAIL_MD5_GET(7), 0xf6bb4b60, 16) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_H2, b, c, d, a, BOOST_UUID_DETAIL_MD5_GET(10), 0xbebfbc70, 23) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_H, a, b, c, d, BOOST_UUID_DETAIL_MD5_GET(13), 0x289b7ec6, 4) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_H2, d, a, b, c, BOOST_UUID_DETAIL_MD5_GET(0), 0xeaa127fa, 11) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_H, c, d, a, b, BOOST_UUID_DETAIL_MD5_GET(3), 0xd4ef3085, 16) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_H2, b, c, d, a, BOOST_UUID_DETAIL_MD5_GET(6), 0x04881d05, 23) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_H, a, b, c, d, BOOST_UUID_DETAIL_MD5_GET(9), 0xd9d4d039, 4) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_H2, d, a, b, c, BOOST_UUID_DETAIL_MD5_GET(12), 0xe6db99e5, 11) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_H, c, d, a, b, BOOST_UUID_DETAIL_MD5_GET(15), 0x1fa27cf8, 16) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_H2, b, c, d, a, BOOST_UUID_DETAIL_MD5_GET(2), 0xc4ac5665, 23) / Round 4 / BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_I, a, b, c, d, BOOST_UUID_DETAIL_MD5_GET(0), 0xf4292244, 6) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_I, d, a, b, c, BOOST_UUID_DETAIL_MD5_GET(7), 0x432aff97, 10) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_I, c, d, a, b, BOOST_UUID_DETAIL_MD5_GET(14), 0xab9423a7, 15) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_I, b, c, d, a, BOOST_UUID_DETAIL_MD5_GET(5), 0xfc93a039, 21) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_I, a, b, c, d, BOOST_UUID_DETAIL_MD5_GET(12), 0x655b59c3, 6) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_I, d, a, b, c, BOOST_UUID_DETAIL_MD5_GET(3), 0x8f0ccc92, 10) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_I, c, d, a, b, BOOST_UUID_DETAIL_MD5_GET(10), 0xffeff47d, 15) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_I, b, c, d, a, BOOST_UUID_DETAIL_MD5_GET(1), 0x85845dd1, 21) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_I, a, b, c, d, BOOST_UUID_DETAIL_MD5_GET(8), 0x6fa87e4f, 6) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_I, d, a, b, c, BOOST_UUID_DETAIL_MD5_GET(15), 0xfe2ce6e0, 10) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_I, c, d, a, b, BOOST_UUID_DETAIL_MD5_GET(6), 0xa3014314, 15) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_I, b, c, d, a, BOOST_UUID_DETAIL_MD5_GET(13), 0x4e0811a1, 21) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_I, a, b, c, d, BOOST_UUID_DETAIL_MD5_GET(4), 0xf7537e82, 6) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_I, d, a, b, c, BOOST_UUID_DETAIL_MD5_GET(11), 0xbd3af235, 10) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_I, c, d, a, b, BOOST_UUID_DETAIL_MD5_GET(2), 0x2ad7d2bb, 15) BOOST_UUID_DETAIL_MD5_STEP(BOOST_UUID_DETAIL_MD5_I, b, c, d, a, BOOST_UUID_DETAIL_MD5_GET(9), 0xeb86d391, 21) a += saved_a; b += saved_b; c += saved_c; d += saved_d; ptr += 64; } while (size -= 64); ctx->a = a; ctx->b = b; ctx->c = c; ctx->d = d; return ptr; } void MD5_Init(MD5_CTX ctx) { ctx->a = 0x67452301; ctx->b = 0xefcdab89; ctx->c = 0x98badcfe; ctx->d = 0x10325476; ctx->lo = 0; ctx->hi = 0; } void MD5_Update(MD5_CTX ctx, const void data, unsigned long size) { MD5_u32plus saved_lo; unsigned long used, available; saved_lo = ctx->lo; if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo) ctx->hi++; ctx->hi += size >> 29; used = saved_lo & 0x3f; if (used) { available = 64 - used; if (size < available) { memcpy(&ctx->buffer[used], data, size); return; } memcpy(&ctx->buffer[used], data, available); data = (const unsigned char )data + available; size -= available; body(ctx, ctx->buffer, 64); } if (size >= 64) { data = body(ctx, data, size & ~(unsigned long)0x3f); size &= 0x3f; } memcpy(ctx->buffer, data, size); } // This must remain consistent no matter the endianness #define BOOST_UUID_DETAIL_MD5_OUT(dst, src) \ (dst)[0] = (unsigned char)(src); \ (dst)[1] = (unsigned char)((src) >> 8); \ (dst)[2] = (unsigned char)((src) >> 16); \ (dst)[3] = (unsigned char)((src) >> 24); // // A big-endian issue with MD5 results was resolved // in boost 1.71. If you generated md5 name-based uuids // with boost 1.66 through 1.70 and stored them, then // set the following compatibility flag to ensure that // your hash generation remains consistent. // #if defined(BOOST_UUID_COMPAT_PRE_1_71_MD5) #define BOOST_UUID_DETAIL_MD5_BYTE_OUT(dst, src) \ BOOST_UUID_DETAIL_MD5_OUT(dst, src) #else // // We're copying into a byte buffer which is actually // backed by an unsigned int array, which later on // is then swabbed one more time by the basic name // generator. Therefore the logic here is reversed. // This was done to minimize the impact to existing // name-based hash generation. The correct fix would // be to make this and name generation endian-correct // but that would even break previously generated sha1 // hashes too. // #if BOOST_ENDIAN_LITTLE_BYTE #define BOOST_UUID_DETAIL_MD5_BYTE_OUT(dst, src) \ (dst)[0] = (unsigned char)((src) >> 24); \ (dst)[1] = (unsigned char)((src) >> 16); \ (dst)[2] = (unsigned char)((src) >> 8); \ (dst)[3] = (unsigned char)(src); #else #define BOOST_UUID_DETAIL_MD5_BYTE_OUT(dst, src) \ (dst)[0] = (unsigned char)(src); \ (dst)[1] = (unsigned char)((src) >> 8); \ (dst)[2] = (unsigned char)((src) >> 16); \ (dst)[3] = (unsigned char)((src) >> 24); #endif #endif // BOOST_UUID_COMPAT_PRE_1_71_MD5 void MD5_Final(unsigned char result, MD5_CTX ctx) { unsigned long used, available; used = ctx->lo & 0x3f; ctx->buffer[used++] = 0x80; available = 64 - used; if (available < 8) { memset(&ctx->buffer[used], 0, available); body(ctx, ctx->buffer, 64); used = 0; available = 64; } memset(&ctx->buffer[used], 0, available - 8); ctx->lo <<= 3; BOOST_UUID_DETAIL_MD5_OUT(&ctx->buffer[56], ctx->lo) BOOST_UUID_DETAIL_MD5_OUT(&ctx->buffer[60], ctx->hi) body(ctx, ctx->buffer, 64); BOOST_UUID_DETAIL_MD5_BYTE_OUT(&result[0], ctx->a) BOOST_UUID_DETAIL_MD5_BYTE_OUT(&result[4], ctx->b) BOOST_UUID_DETAIL_MD5_BYTE_OUT(&result[8], ctx->c) BOOST_UUID_DETAIL_MD5_BYTE_OUT(&result[12], ctx->d) memset(ctx, 0, sizeof(ctx)); } #undef BOOST_UUID_DETAIL_MD5_OUT #undef BOOST_UUID_DETAIL_MD5_SET #undef BOOST_UUID_DETAIL_MD5_GET #undef BOOST_UUID_DETAIL_MD5_STEP MD5_CTX ctx_; }; } // detail } // uuids } // boost #endif // BOOST_UUID_MD5_HPP PK��Bb�[�mA�o��o��random_provider_getrandom.ippnu��[��// // Copyright (c) 2018 Andrey Semashev // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // https://www.boost.org/LICENSE_1_0.txt) // // getrandom() capable platforms // #include <boost/config.hpp> #include <boost/throw_exception.hpp> #include <boost/predef/library/c/gnu.h> #include <cerrno> #include <cstddef> #if !defined(BOOST_UUID_RANDOM_PROVIDER_GETRANDOM_IMPL_GETRANDOM) #if BOOST_LIB_C_GNU >= BOOST_VERSION_NUMBER(2, 25, 0) #define BOOST_UUID_RANDOM_PROVIDER_GETRANDOM_HAS_LIBC_WRAPPER #elif defined(__has_include) #if __has_include(<sys/random.h>) #define BOOST_UUID_RANDOM_PROVIDER_GETRANDOM_HAS_LIBC_WRAPPER #endif #endif #endif // !defined(BOOST_UUID_RANDOM_PROVIDER_GETRANDOM_IMPL_GETRANDOM) #if defined(BOOST_UUID_RANDOM_PROVIDER_GETRANDOM_HAS_LIBC_WRAPPER) #include <sys/random.h> #else #include <stddef.h> // ssize_t #endif namespace boost { namespace uuids { namespace detail { class random_provider_base { public: //! Obtain entropy and place it into a memory location //! \param[in] buf the location to write entropy //! \param[in] siz the number of bytes to acquire void get_random_bytes(void buf, std::size_t siz) { std::size_t offset = 0; while (offset < siz) { ssize_t sz = get_random(static_cast< char >(buf) + offset, siz - offset, 0u); if (BOOST_UNLIKELY(sz < 0)) { int err = errno; if (err == EINTR) continue; BOOST_THROW_EXCEPTION(entropy_error(err, "getrandom")); } offset += sz; } } private: static ssize_t get_random(void buf, std::size_t size, unsigned int flags) { #if defined(BOOST_UUID_RANDOM_PROVIDER_GETRANDOM_IMPL_GETRANDOM) return BOOST_UUID_RANDOM_PROVIDER_GETRANDOM_IMPL_GETRANDOM(buf, size, flags); #elif defined(BOOST_UUID_RANDOM_PROVIDER_GETRANDOM_HAS_LIBC_WRAPPER) return ::getrandom(buf, size, flags); #else return ::syscall(SYS_getrandom, buf, size, flags); #endif } }; } // detail } // uuids } // boost PK��Bb�[�l`"��"��random_provider_wincrypt.ippnu��[��/ boost uuid/detail/random_provider_wincrypt implementation * * Copyright Jens Maurer 2000 * Copyright 2007 Andy Tompkins. * Copyright Steven Watanabe 2010-2011 * Copyright 2017 James E. King III * * Distributed under the Boost Software License, Version 1.0. (See * accompanying file LICENSE_1_0.txt or copy at * https://www.boost.org/LICENSE_1_0.txt) * * $Id$ / #include <cstddef> #include <boost/config.hpp> #include <boost/core/ignore_unused.hpp> #include <boost/move/core.hpp> #include <boost/numeric/conversion/cast.hpp> #include <boost/winapi/crypt.hpp> #include <boost/winapi/get_last_error.hpp> #include <boost/throw_exception.hpp> #if defined(BOOST_UUID_FORCE_AUTO_LINK) \|\| (!defined(BOOST_ALL_NO_LIB) && !defined(BOOST_UUID_RANDOM_PROVIDER_NO_LIB)) # if defined(_WIN32_WCE) # define BOOST_LIB_NAME "coredll" # else # define BOOST_LIB_NAME "advapi32" # endif # if defined(BOOST_AUTO_LINK_NOMANGLE) # include <boost/config/auto_link.hpp> # else # define BOOST_AUTO_LINK_NOMANGLE # include <boost/config/auto_link.hpp> # undef BOOST_AUTO_LINK_NOMANGLE # endif #endif namespace boost { namespace uuids { namespace detail { class random_provider_base { BOOST_MOVABLE_BUT_NOT_COPYABLE(random_provider_base) public: random_provider_base() : hProv_(0) { boost::winapi::BOOL_ res = boost::winapi::CryptAcquireContextW( &hProv_, NULL, NULL, boost::winapi::PROV_RSA_FULL_, boost::winapi::CRYPT_VERIFYCONTEXT_ \| boost::winapi::CRYPT_SILENT_); if (BOOST_UNLIKELY(!res)) { boost::winapi::DWORD_ err = boost::winapi::GetLastError(); BOOST_THROW_EXCEPTION(entropy_error(err, "CryptAcquireContext")); } } random_provider_base(BOOST_RV_REF(random_provider_base) that) BOOST_NOEXCEPT : hProv_(that.hProv_) { that.hProv_ = 0; } random_provider_base& operator= (BOOST_RV_REF(random_provider_base) that) BOOST_NOEXCEPT { destroy(); hProv_ = that.hProv_; that.hProv_ = 0; return this; } ~random_provider_base() BOOST_NOEXCEPT { destroy(); } //! Obtain entropy and place it into a memory location //! \param[in] buf the location to write entropy //! \param[in] siz the number of bytes to acquire void get_random_bytes(void buf, std::size_t siz) { boost::winapi::BOOL_ res = boost::winapi::CryptGenRandom( hProv_, boost::numeric_cast<boost::winapi::DWORD_>(siz), static_cast<boost::winapi::BYTE_ >(buf)); if (BOOST_UNLIKELY(!res)) { boost::winapi::DWORD_ err = boost::winapi::GetLastError(); BOOST_THROW_EXCEPTION(entropy_error(err, "CryptGenRandom")); } } private: void destroy() BOOST_NOEXCEPT { if (hProv_) { boost::ignore_unused(boost::winapi::CryptReleaseContext(hProv_, 0)); } } private: boost::winapi::HCRYPTPROV_ hProv_; }; } // detail } // uuids } // boost PK��Bb�[6D �r��r��$��random_provider_include_platform.hppnu��[��// // Copyright (c) 2017 James E. King III // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // https://www.boost.org/LICENSE_1_0.txt) // // Platform-specific random entropy provider platform definition // #ifndef BOOST_UUID_DETAIL_RANDOM_PROVIDER_PLATFORM_INCLUDE_HPP #define BOOST_UUID_DETAIL_RANDOM_PROVIDER_PLATFORM_INCLUDE_HPP #if defined(BOOST_UUID_RANDOM_PROVIDER_ARC4RANDOM) # include <boost/uuid/detail/random_provider_arc4random.ipp> #elif defined(BOOST_UUID_RANDOM_PROVIDER_BCRYPT) # include <boost/uuid/detail/random_provider_bcrypt.ipp> #elif defined(BOOST_UUID_RANDOM_PROVIDER_GETENTROPY) # include <boost/uuid/detail/random_provider_getentropy.ipp> #elif defined(BOOST_UUID_RANDOM_PROVIDER_GETRANDOM) # include <boost/uuid/detail/random_provider_getrandom.ipp> #elif defined(BOOST_UUID_RANDOM_PROVIDER_POSIX) # include <boost/uuid/detail/random_provider_posix.ipp> #elif defined(BOOST_UUID_RANDOM_PROVIDER_WINCRYPT) # include <boost/uuid/detail/random_provider_wincrypt.ipp> #endif #endif // BOOST_UUID_DETAIL_RANDOM_PROVIDER_PLATFORM_INCLUDE_HPP PK��Bb�[q��R��random_provider_arc4random.ippnu��[��// // Copyright (c) 2017 James E. King III // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // https://www.boost.org/LICENSE_1_0.txt) // // "A Replacement Call for Random" // https://man.openbsd.org/arc4random.3 // #include <cstddef> #include <stdlib.h> namespace boost { namespace uuids { namespace detail { class random_provider_base { public: //! Obtain entropy and place it into a memory location //! \param[in] buf the location to write entropy //! \param[in] siz the number of bytes to acquire void get_random_bytes(void buf, std::size_t siz) { arc4random_buf(buf, siz); } }; } // detail } // uuids } // boost PK��Bb�[�ؿ��random_provider_getentropy.ippnu��[��// // Copyright (c) 2017 James E. King III // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // https://www.boost.org/LICENSE_1_0.txt) // // getentropy() capable platforms // #include <boost/config.hpp> #include <boost/throw_exception.hpp> #include <cerrno> #include <cstddef> #include <unistd.h> namespace boost { namespace uuids { namespace detail { class random_provider_base { public: //! Obtain entropy and place it into a memory location //! \param[in] buf the location to write entropy //! \param[in] siz the number of bytes to acquire void get_random_bytes(void buf, std::size_t siz) { int res = getentropy(buf, siz); if (BOOST_UNLIKELY(-1 == res)) { int err = errno; BOOST_THROW_EXCEPTION(entropy_error(err, "getentropy")); } } }; } // detail } // uuids } // boost PK��b�[X��type_traits.hppnu��[��// // detail/type_traits.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_TYPE_TRAITS_HPP #define BOOST_ASIO_DETAIL_TYPE_TRAITS_HPP #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_HAS_STD_TYPE_TRAITS) # include <type_traits> #else // defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) # include <boost/type_traits/add_const.hpp> # include <boost/type_traits/add_lvalue_reference.hpp> # include <boost/type_traits/aligned_storage.hpp> # include <boost/type_traits/alignment_of.hpp> # include <boost/type_traits/conditional.hpp> # include <boost/type_traits/decay.hpp> # include <boost/type_traits/has_nothrow_copy.hpp> # include <boost/type_traits/has_nothrow_destructor.hpp> # include <boost/type_traits/integral_constant.hpp> # include <boost/type_traits/is_base_of.hpp> # include <boost/type_traits/is_class.hpp> # include <boost/type_traits/is_const.hpp> # include <boost/type_traits/is_convertible.hpp> # include <boost/type_traits/is_constructible.hpp> # include <boost/type_traits/is_copy_constructible.hpp> # include <boost/type_traits/is_destructible.hpp> # include <boost/type_traits/is_function.hpp> # include <boost/type_traits/is_object.hpp> # include <boost/type_traits/is_same.hpp> # include <boost/type_traits/remove_cv.hpp> # include <boost/type_traits/remove_pointer.hpp> # include <boost/type_traits/remove_reference.hpp> # include <boost/utility/declval.hpp> # include <boost/utility/enable_if.hpp> # include <boost/utility/result_of.hpp> #endif // defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) namespace boost { namespace asio { #if defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) using std::add_const; using std::add_lvalue_reference; using std::aligned_storage; using std::alignment_of; using std::conditional; using std::decay; using std::declval; using std::enable_if; using std::false_type; using std::integral_constant; using std::is_base_of; using std::is_class; using std::is_const; using std::is_constructible; using std::is_convertible; using std::is_copy_constructible; using std::is_destructible; using std::is_function; using std::is_move_constructible; using std::is_nothrow_copy_constructible; using std::is_nothrow_destructible; using std::is_object; using std::is_reference; using std::is_same; using std::is_scalar; using std::remove_cv; template <typename T> struct remove_cvref : remove_cv<typename std::remove_reference<T>::type> {}; using std::remove_pointer; using std::remove_reference; #if defined(BOOST_ASIO_HAS_STD_INVOKE_RESULT) template <typename> struct result_of; template <typename F, typename... Args> struct result_of<F(Args...)> : std::invoke_result<F, Args...> {}; #else // defined(BOOST_ASIO_HAS_STD_INVOKE_RESULT) using std::result_of; #endif // defined(BOOST_ASIO_HAS_STD_INVOKE_RESULT) using std::true_type; #else // defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) using boost::add_const; using boost::add_lvalue_reference; using boost::aligned_storage; using boost::alignment_of; template <bool Condition, typename Type = void> struct enable_if : boost::enable_if_c<Condition, Type> {}; using boost::conditional; using boost::decay; using boost::declval; using boost::false_type; using boost::integral_constant; using boost::is_base_of; using boost::is_class; using boost::is_const; using boost::is_constructible; using boost::is_convertible; using boost::is_copy_constructible; using boost::is_destructible; using boost::is_function; #if defined(BOOST_ASIO_HAS_MOVE) template <typename T> struct is_move_constructible : false_type {}; #else // defined(BOOST_ASIO_HAS_MOVE) template <typename T> struct is_move_constructible : is_copy_constructible<T> {}; #endif // defined(BOOST_ASIO_HAS_MOVE) template <typename T> struct is_nothrow_copy_constructible : boost::has_nothrow_copy<T> {}; template <typename T> struct is_nothrow_destructible : boost::has_nothrow_destructor<T> {}; using boost::is_object; using boost::is_reference; using boost::is_same; using boost::is_scalar; using boost::remove_cv; template <typename T> struct remove_cvref : remove_cv<typename boost::remove_reference<T>::type> {}; using boost::remove_pointer; using boost::remove_reference; using boost::result_of; using boost::true_type; #endif // defined(BOOST_ASIO_HAS_STD_TYPE_TRAITS) template <typename> struct void_type { typedef void type; }; #if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) template <typename...> struct conjunction : true_type {}; template <typename T> struct conjunction<T> : T {}; template <typename Head, typename... Tail> struct conjunction<Head, Tail...> : conditional<Head::value, conjunction<Tail...>, Head>::type {}; #endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) } // namespace asio } // namespace boost #endif // BOOST_ASIO_DETAIL_TYPE_TRAITS_HPP PK��b�[�谓e��e��math.hppnu��[��// // Copyright 2019 Olzhas Zhumabek <anonymous.from.applecity@gmail.com> // // Use, modification and distribution are subject to 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_GIL_IMAGE_PROCESSING_DETAIL_MATH_HPP #define BOOST_GIL_IMAGE_PROCESSING_DETAIL_MATH_HPP #include <array> #include <boost/gil/extension/numeric/kernel.hpp> namespace boost { namespace gil { namespace detail { static constexpr double pi = 3.14159265358979323846; static constexpr std::array<float, 9> dx_sobel = {{-1, 0, 1, -2, 0, 2, -1, 0, 1}}; static constexpr std::array<float, 9> dx_scharr = {{-1, 0, 1, -1, 0, 1, -1, 0, 1}}; static constexpr std::array<float, 9> dy_sobel = {{1, 2, 1, 0, 0, 0, -1, -2, -1}}; static constexpr std::array<float, 9> dy_scharr = {{1, 1, 1, 0, 0, 0, -1, -1, -1}}; template <typename T, typename Allocator> inline detail::kernel_2d<T, Allocator> get_identity_kernel() { detail::kernel_2d<T, Allocator> kernel(1, 0, 0); kernel[0] = 1; return kernel; } }}} // namespace boost::gil::detail #endif PK��b�[%�YI��std_common_type.hppnu��[��// // Copyright Louis Dionne 2013-2017 // // Distributed under the Boost Software License, Version 1.0. //(See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt) // #ifndef BOOST_GIL_DETAIL_STD_COMMON_TYPE_HPP #define BOOST_GIL_DETAIL_STD_COMMON_TYPE_HPP #include <type_traits> #include <utility> namespace boost { namespace gil { namespace detail { // Defines a SFINAE-friendly version of `std::common_type`. // // Based on boost/hana/detail/std_common_type.hpp // Equivalent to `std::common_type`, except it is SFINAE-friendly and // does not support custom specializations. template <typename T, typename U, typename = void> struct std_common_type {}; template <typename T, typename U> struct std_common_type < T, U, decltype((void)(true ? std::declval<T>() : std::declval<U>())) > { using type = typename std::decay < decltype(true ? std::declval<T>() : std::declval<U>()) >::type; }; }}} // namespace boost::gil::detail #endif PK��b�[��k��k��is_channel_integral.hppnu��[��// // Copyright 2019 Mateusz Loskot <mateusz at loskot dot net> // Copyright 2005-2007 Adobe Systems Incorporated // // 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_GIL_DETAIL_IS_CHANNEL_INTEGRAL_HPP #define BOOST_GIL_DETAIL_IS_CHANNEL_INTEGRAL_HPP #include <boost/gil/channel.hpp> #include <type_traits> namespace boost { namespace gil { namespace detail { template <typename ChannelValue> struct is_channel_integral : std::is_integral<ChannelValue> {}; template <int NumBits> struct is_channel_integral<boost::gil::packed_channel_value<NumBits>> : std::true_type {}; template <typename BitField, int FirstBit, int NumBits, bool IsMutable> struct is_channel_integral < boost::gil::packed_channel_reference<BitField, FirstBit, NumBits, IsMutable> > : std::true_type {}; template <typename BitField, int NumBits, bool IsMutable> struct is_channel_integral < boost::gil::packed_dynamic_channel_reference<BitField, NumBits, IsMutable> > : std::true_type {}; template <typename BaseChannelValue, typename MinVal, typename MaxVal> struct is_channel_integral < boost::gil::scoped_channel_value<BaseChannelValue, MinVal, MaxVal> > : std::is_integral<BaseChannelValue> {}; }}} //namespace boost::gil::detail #endif PK��b�[osP��mp11.hppnu��[��// // Copyright 2017 Peter Dimov. // Copyright 2019 Mateusz Loskot <mateusz at loskot dot net> // // 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_GIL_DETAIL_MP11_HPP #define BOOST_GIL_DETAIL_MP11_HPP #include <boost/mp11.hpp> #include <boost/mp11/mpl.hpp> // required by dynamic_image and boost::variant (?) namespace boost { namespace gil { namespace detail { template<typename L> using mp_back = ::boost::mp11::mp_at_c<L, ::boost::mp11::mp_size<L>::value - 1>; template<typename L> using mp_pop_back = ::boost::mp11::mp_take_c<L, ::boost::mp11::mp_size<L>::value - 1>; }}} // namespace boost::gil::detail #endif PK��=��[w";�� guard.hppnu��[��// Copyright (C) 2000 Stephen Cleary // // 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) // // See http://www.boost.org for updates, documentation, and revision history. #ifndef BOOST_POOL_GUARD_HPP #define BOOST_POOL_GUARD_HPP /! \file \brief Extremely Light-Weight guard class. \details Auto-lock/unlock-er detail/guard.hpp provides a type guard<Mutex> that allows scoped access to the Mutex's locking and unlocking operations. It is used to ensure that a Mutex is unlocked, even if an exception is thrown. / namespace boost { namespace details { namespace pool { template <typename Mutex> //!< \tparam Mutex (platform-specific) mutex class. class guard { //! Locks the mutex, binding guard<Mutex> to Mutex. /! Example: Given a (platform-specific) mutex class, we can wrap code as follows: extern mutex global_lock; static void f() { boost::details::pool::guard<mutex> g(global_lock); // g's constructor locks "global_lock" ... // do anything: // throw exceptions // return // or just fall through } // g's destructor unlocks "global_lock" / private: Mutex & mtx; guard(const guard &); //!< Guards the mutex, ensuring unlocked on destruction, even if exception is thrown. void operator=(const guard &); public: explicit guard(Mutex & nmtx) :mtx(nmtx) { //! Locks the mutex of the guard class. mtx.lock(); } ~guard() { //! destructor unlocks the mutex of the guard class. mtx.unlock(); } }; // class guard } // namespace pool } // namespace details } // namespace boost #endif PK��=��[6CI`��I`��pool_construct.ippnu��[��// Copyright (C) 2000 Stephen Cleary // // Distributed under the Boost Software License, Version 1.0. (See accompany- // ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // See http://www.boost.org for updates, documentation, and revision history. // This file was AUTOMATICALLY GENERATED from "stdin" // Do NOT include directly! // Do NOT edit! template <typename T0> element_type * construct(T0 & a0) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0> element_type * construct(const T0 & a0) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0> element_type * construct(volatile T0 & a0) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0> element_type * construct(const volatile T0 & a0) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1> element_type * construct(T0 & a0, T1 & a1) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1> element_type * construct(const T0 & a0, T1 & a1) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1> element_type * construct(volatile T0 & a0, T1 & a1) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1> element_type * construct(const volatile T0 & a0, T1 & a1) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1> element_type * construct(T0 & a0, const T1 & a1) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1> element_type * construct(const T0 & a0, const T1 & a1) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1> element_type * construct(volatile T0 & a0, const T1 & a1) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1> element_type * construct(const volatile T0 & a0, const T1 & a1) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1> element_type * construct(T0 & a0, volatile T1 & a1) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1> element_type * construct(const T0 & a0, volatile T1 & a1) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1> element_type * construct(volatile T0 & a0, volatile T1 & a1) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1> element_type * construct(const volatile T0 & a0, volatile T1 & a1) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1> element_type * construct(T0 & a0, const volatile T1 & a1) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1> element_type * construct(const T0 & a0, const volatile T1 & a1) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1> element_type * construct(volatile T0 & a0, const volatile T1 & a1) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1> element_type * construct(const volatile T0 & a0, const volatile T1 & a1) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(T0 & a0, T1 & a1, T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const T0 & a0, T1 & a1, T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(volatile T0 & a0, T1 & a1, T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const volatile T0 & a0, T1 & a1, T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(T0 & a0, const T1 & a1, T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const T0 & a0, const T1 & a1, T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(volatile T0 & a0, const T1 & a1, T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const volatile T0 & a0, const T1 & a1, T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(T0 & a0, volatile T1 & a1, T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const T0 & a0, volatile T1 & a1, T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(volatile T0 & a0, volatile T1 & a1, T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const volatile T0 & a0, volatile T1 & a1, T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(T0 & a0, const volatile T1 & a1, T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const T0 & a0, const volatile T1 & a1, T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(volatile T0 & a0, const volatile T1 & a1, T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const volatile T0 & a0, const volatile T1 & a1, T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(T0 & a0, T1 & a1, const T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const T0 & a0, T1 & a1, const T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(volatile T0 & a0, T1 & a1, const T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const volatile T0 & a0, T1 & a1, const T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(T0 & a0, const T1 & a1, const T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const T0 & a0, const T1 & a1, const T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(volatile T0 & a0, const T1 & a1, const T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const volatile T0 & a0, const T1 & a1, const T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(T0 & a0, volatile T1 & a1, const T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const T0 & a0, volatile T1 & a1, const T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(volatile T0 & a0, volatile T1 & a1, const T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const volatile T0 & a0, volatile T1 & a1, const T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(T0 & a0, const volatile T1 & a1, const T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const T0 & a0, const volatile T1 & a1, const T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(volatile T0 & a0, const volatile T1 & a1, const T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const volatile T0 & a0, const volatile T1 & a1, const T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(T0 & a0, T1 & a1, volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const T0 & a0, T1 & a1, volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(volatile T0 & a0, T1 & a1, volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const volatile T0 & a0, T1 & a1, volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(T0 & a0, const T1 & a1, volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const T0 & a0, const T1 & a1, volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(volatile T0 & a0, const T1 & a1, volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const volatile T0 & a0, const T1 & a1, volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(T0 & a0, volatile T1 & a1, volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const T0 & a0, volatile T1 & a1, volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(volatile T0 & a0, volatile T1 & a1, volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const volatile T0 & a0, volatile T1 & a1, volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(T0 & a0, const volatile T1 & a1, volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const T0 & a0, const volatile T1 & a1, volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(volatile T0 & a0, const volatile T1 & a1, volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const volatile T0 & a0, const volatile T1 & a1, volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(T0 & a0, T1 & a1, const volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const T0 & a0, T1 & a1, const volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(volatile T0 & a0, T1 & a1, const volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const volatile T0 & a0, T1 & a1, const volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(T0 & a0, const T1 & a1, const volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const T0 & a0, const T1 & a1, const volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(volatile T0 & a0, const T1 & a1, const volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const volatile T0 & a0, const T1 & a1, const volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(T0 & a0, volatile T1 & a1, const volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const T0 & a0, volatile T1 & a1, const volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(volatile T0 & a0, volatile T1 & a1, const volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const volatile T0 & a0, volatile T1 & a1, const volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(T0 & a0, const volatile T1 & a1, const volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const T0 & a0, const volatile T1 & a1, const volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(volatile T0 & a0, const volatile T1 & a1, const volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const volatile T0 & a0, const volatile T1 & a1, const volatile T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } PK��=��[��G��G�� mutex.hppnu��[��// // detail/mutex.hpp // ~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_MUTEX_HPP #define BOOST_ASIO_DETAIL_MUTEX_HPP #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_HAS_THREADS) # include <boost/asio/detail/null_mutex.hpp> #elif defined(BOOST_ASIO_WINDOWS) # include <boost/asio/detail/win_mutex.hpp> #elif defined(BOOST_ASIO_HAS_PTHREADS) # include <boost/asio/detail/posix_mutex.hpp> #elif defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) # include <boost/asio/detail/std_mutex.hpp> #else # error Only Windows, POSIX and std::mutex are supported! #endif namespace boost { namespace asio { namespace detail { #if !defined(BOOST_ASIO_HAS_THREADS) typedef null_mutex mutex; #elif defined(BOOST_ASIO_WINDOWS) typedef win_mutex mutex; #elif defined(BOOST_ASIO_HAS_PTHREADS) typedef posix_mutex mutex; #elif defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) typedef std_mutex mutex; #endif } // namespace detail } // namespace asio } // namespace boost #endif // BOOST_ASIO_DETAIL_MUTEX_HPP PK��=��[ �#��pool_construct_simple.ippnu��[��// Copyright (C) 2000 Stephen Cleary // // 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) // // See http://www.boost.org for updates, documentation, and revision history. // This file was AUTOMATICALLY GENERATED from "stdin" // Do NOT include directly! // Do NOT edit! template <typename T0> element_type * construct(const T0 & a0) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1> element_type * construct(const T0 & a0, const T1 & a1) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1); } catch (...) { (free)(ret); throw; } return ret; } template <typename T0, typename T1, typename T2> element_type * construct(const T0 & a0, const T1 & a1, const T2 & a2) { element_type * const ret = (malloc)(); if (ret == 0) return ret; try { new (ret) element_type(a0, a1, a2); } catch (...) { (free)(ret); throw; } return ret; } PK��iX!\��,��,��variadic_macros.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_VARIDAIC_MACROS_HPP #define BOOST_COMPUTE_DETAIL_VARIDAIC_MACROS_HPP #include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/config/config.hpp> #include <boost/preprocessor/tuple/to_seq.hpp> #if BOOST_PP_VARIADICS == 1 # include <boost/preprocessor/variadic/size.hpp> #endif #ifdef BOOST_PP_VARIADIC_SIZE # define BOOST_COMPUTE_PP_VARIADIC_SIZE BOOST_PP_VARIADIC_SIZE #else # define BOOST_COMPUTE_PP_VARIADIC_SIZE(...) BOOST_COMPUTE_PP_VARIADIC_SIZE_I(__VA_ARGS__, 64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,) # define BOOST_COMPUTE_PP_VARIADIC_SIZE_I(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, e10, e11, e12, e13, e14, e15, e16, e17, e18, e19, e20, e21, e22, e23, e24, e25, e26, e27, e28, e29, e30, e31, e32, e33, e34, e35, e36, e37, e38, e39, e40, e41, e42, e43, e44, e45, e46, e47, e48, e49, e50, e51, e52, e53, e54, e55, e56, e57, e58, e59, e60, e61, e62, e63, size, ...) size #endif #define BOOST_COMPUTE_PP_TUPLE_SIZE(tuple) \ BOOST_COMPUTE_PP_VARIADIC_SIZE tuple #define BOOST_COMPUTE_PP_TUPLE_TO_SEQ(tuple) \ BOOST_PP_TUPLE_TO_SEQ(BOOST_COMPUTE_PP_TUPLE_SIZE(tuple), tuple) #endif // BOOST_COMPUTE_DETAIL_VARIDAIC_MACROS_HPP PK��iX!\��~��~��iterator_plus_distance.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_ITERATOR_PLUS_DISTANCE_HPP #define BOOST_COMPUTE_DETAIL_ITERATOR_PLUS_DISTANCE_HPP #include <iterator> namespace boost { namespace compute { namespace detail { template<class Iterator, class Distance, class Tag> inline Iterator iterator_plus_distance(Iterator i, Distance n, Tag) { while(n--){ i++; } return i; } template<class Iterator, class Distance> inline Iterator iterator_plus_distance(Iterator i, Distance n, std::random_access_iterator_tag) { typedef typename std::iterator_traits<Iterator>::difference_type difference_type; return i + static_cast<difference_type>(n); } // similar to std::advance() except returns the advanced iterator and // also works with iterators that don't define difference_type template<class Iterator, class Distance> inline Iterator iterator_plus_distance(Iterator i, Distance n) { typedef typename std::iterator_traits<Iterator>::iterator_category tag; return iterator_plus_distance(i, n, tag()); } } // end detail namespace } // end compute namespace } // end boost namespace #endif // BOOST_COMPUTE_DETAIL_ITERATOR_PLUS_DISTANCE_HPP PK��iX!\��.��iterator_range_size.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_ITERATOR_RANGE_SIZE_H #define BOOST_COMPUTE_DETAIL_ITERATOR_RANGE_SIZE_H #include <cstddef> #include <algorithm> #include <iterator> namespace boost { namespace compute { namespace detail { // This is a convenience function which returns the size of a range // bounded by two iterators. This function has two differences from // the std::distance() function: 1) the return type (size_t) is // unsigned, and 2) the return value is always positive. template<class Iterator> inline size_t iterator_range_size(Iterator first, Iterator last) { typedef typename std::iterator_traits<Iterator>::difference_type difference_type; difference_type difference = std::distance(first, last); return static_cast<size_t>( (std::max)(difference, static_cast<difference_type>(0)) ); } } // end detail namespace } // end compute namespace } // end boost namespace #endif // BOOST_COMPUTE_DETAIL_ITERATOR_RANGE_SIZE_H PK��iX!\�ʮ�L��L��diagnostic.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2016 Jakub Szuppe <j.szuppe@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_DIAGNOSTIC_HPP #define BOOST_COMPUTE_DETAIL_DIAGNOSTIC_HPP // Macros for suppressing warnings for GCC version 4.6 or later. Usage: // // BOOST_COMPUTE_BOOST_COMPUTE_GCC_DIAG_OFF(sign-compare); // if(a < b){ // BOOST_COMPUTE_BOOST_COMPUTE_GCC_DIAG_ON(sign-compare); // // Source: https://svn.boost.org/trac/boost/wiki/Guidelines/WarningsGuidelines #if ((__GNUC__ * 100) + __GNUC_MINOR__) >= 402 #define BOOST_COMPUTE_GCC_DIAG_STR(s) #s #define BOOST_COMPUTE_GCC_DIAG_JOINSTR(x,y) BOOST_COMPUTE_GCC_DIAG_STR(x ## y) # define BOOST_COMPUTE_GCC_DIAG_DO_PRAGMA(x) _Pragma (#x) # define BOOST_COMPUTE_GCC_DIAG_PRAGMA(x) BOOST_COMPUTE_GCC_DIAG_DO_PRAGMA(GCC diagnostic x) # if ((__GNUC__ * 100) + __GNUC_MINOR__) >= 406 # define BOOST_COMPUTE_GCC_DIAG_OFF(x) BOOST_COMPUTE_GCC_DIAG_PRAGMA(push) \ BOOST_COMPUTE_GCC_DIAG_PRAGMA(ignored BOOST_COMPUTE_GCC_DIAG_JOINSTR(-W,x)) # define BOOST_COMPUTE_GCC_DIAG_ON(x) BOOST_COMPUTE_GCC_DIAG_PRAGMA(pop) # else # define BOOST_COMPUTE_GCC_DIAG_OFF(x) \ BOOST_COMPUTE_GCC_DIAG_PRAGMA(ignored BOOST_COMPUTE_GCC_DIAG_JOINSTR(-W,x)) # define BOOST_COMPUTE_GCC_DIAG_ON(x) \ BOOST_COMPUTE_GCC_DIAG_PRAGMA(warning BOOST_COMPUTE_GCC_DIAG_JOINSTR(-W,x)) # endif #else // Ensure these macros do nothing for other compilers. # define BOOST_COMPUTE_GCC_DIAG_OFF(x) # define BOOST_COMPUTE_GCC_DIAG_ON(x) #endif // Macros for suppressing warnings for Clang. // // BOOST_COMPUTE_BOOST_COMPUTE_CLANG_DIAG_OFF(sign-compare); // if(a < b){ // BOOST_COMPUTE_BOOST_COMPUTE_CLANG_DIAG_ON(sign-compare); // // Source: https://svn.boost.org/trac/boost/wiki/Guidelines/WarningsGuidelines #ifdef __clang__ # define BOOST_COMPUTE_CLANG_DIAG_STR(s) # s // stringize s to "no-sign-compare" # define BOOST_COMPUTE_CLANG_DIAG_JOINSTR(x,y) BOOST_COMPUTE_CLANG_DIAG_STR(x ## y) // join -W with no-unused-variable to "-Wno-sign-compare" # define BOOST_COMPUTE_CLANG_DIAG_DO_PRAGMA(x) _Pragma (#x) // _Pragma is unary operator #pragma ("") # define BOOST_COMPUTE_CLANG_DIAG_PRAGMA(x) \ BOOST_COMPUTE_CLANG_DIAG_DO_PRAGMA(clang diagnostic x) # define BOOST_COMPUTE_CLANG_DIAG_OFF(x) BOOST_COMPUTE_CLANG_DIAG_PRAGMA(push) \ BOOST_COMPUTE_CLANG_DIAG_PRAGMA(ignored BOOST_COMPUTE_CLANG_DIAG_JOINSTR(-W,x)) // For example: #pragma clang diagnostic ignored "-Wno-sign-compare" # define BOOST_COMPUTE_CLANG_DIAG_ON(x) BOOST_COMPUTE_CLANG_DIAG_PRAGMA(pop) // For example: #pragma clang diagnostic warning "-Wno-sign-compare" #else // Ensure these macros do nothing for other compilers. # define BOOST_COMPUTE_CLANG_DIAG_OFF(x) # define BOOST_COMPUTE_CLANG_DIAG_ON(x) # define BOOST_COMPUTE_CLANG_DIAG_PRAGMA(x) #endif // Macros for suppressing warnings for MSVC. Usage: // // BOOST_COMPUTE_BOOST_COMPUTE_MSVC_DIAG_OFF(4018); //sign-compare // if(a < b){ // BOOST_COMPUTE_BOOST_COMPUTE_MSVC_DIAG_ON(4018); // #if defined(_MSC_VER) # define BOOST_COMPUTE_MSVC_DIAG_DO_PRAGMA(x) __pragma(x) # define BOOST_COMPUTE_MSVC_DIAG_PRAGMA(x) \ BOOST_COMPUTE_MSVC_DIAG_DO_PRAGMA(warning(x)) # define BOOST_COMPUTE_MSVC_DIAG_OFF(x) BOOST_COMPUTE_MSVC_DIAG_PRAGMA(push) \ BOOST_COMPUTE_MSVC_DIAG_PRAGMA(disable: x) # define BOOST_COMPUTE_MSVC_DIAG_ON(x) BOOST_COMPUTE_MSVC_DIAG_PRAGMA(pop) #else // Ensure these macros do nothing for other compilers. # define BOOST_COMPUTE_MSVC_DIAG_OFF(x) # define BOOST_COMPUTE_MSVC_DIAG_ON(x) #endif // Macros for suppressing warnings for GCC, Clang and MSVC. Usage: // // BOOST_COMPUTE_DIAG_OFF(sign-compare, sign-compare, 4018); // if(a < b){ // BOOST_COMPUTE_DIAG_ON(sign-compare, sign-compare, 4018); // #if defined(_MSC_VER) // MSVC # define BOOST_COMPUTE_DIAG_OFF(gcc, clang, msvc) BOOST_COMPUTE_MSVC_DIAG_OFF(msvc) # define BOOST_COMPUTE_DIAG_ON(gcc, clang, msvc) BOOST_COMPUTE_MSVC_DIAG_ON(msvc) #elif defined(__clang__) // Clang # define BOOST_COMPUTE_DIAG_OFF(gcc, clang, msvc) BOOST_COMPUTE_CLANG_DIAG_OFF(clang) # define BOOST_COMPUTE_DIAG_ON(gcc, clang, msvc) BOOST_COMPUTE_CLANG_DIAG_ON(clang) #elif defined(__GNUC__) // GCC/G++ # define BOOST_COMPUTE_DIAG_OFF(gcc, clang, msvc) BOOST_COMPUTE_GCC_DIAG_OFF(gcc) # define BOOST_COMPUTE_DIAG_ON(gcc, clang, msvc) BOOST_COMPUTE_GCC_DIAG_ON(gcc) #else // Ensure these macros do nothing for other compilers. # define BOOST_COMPUTE_DIAG_OFF(gcc, clang, msvc) # define BOOST_COMPUTE_DIAG_ON(gcc, clang, msvc) #endif #define BOOST_COMPUTE_DISABLE_DEPRECATED_DECLARATIONS() \ BOOST_COMPUTE_DIAG_OFF(deprecated-declarations, deprecated-declarations, 4996) #define BOOST_COMPUTE_ENABLE_DEPRECATED_DECLARATIONS() \ BOOST_COMPUTE_DIAG_ON(deprecated-declarations, deprecated-declarations, 4996); #endif /* BOOST_COMPUTE_DETAIL_DIAGNOSTIC_HPP / PK��iX!\�Ն��iterator_traits.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_ITERATOR_TRAITS_HPP #define BOOST_COMPUTE_DETAIL_ITERATOR_TRAITS_HPP #include <iterator> #include <boost/compute/detail/is_contiguous_iterator.hpp> #include <boost/compute/type_traits/is_device_iterator.hpp> namespace boost { namespace compute { namespace detail { template<class Iterator> struct iterator_traits : public std::iterator_traits<Iterator> { static const bool is_contiguous = is_contiguous_iterator<Iterator>::value; static const bool is_on_device = is_device_iterator<Iterator>::value; static const bool is_on_host = !is_on_device; }; } // end detail namespace } // end compute namespace } // end boost namespace #endif // BOOST_COMPUTE_ITERATOR_TRAITS_HPP PK��iX!\��u4��4��path.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_PATH_HPP #define BOOST_COMPUTE_DETAIL_PATH_HPP #include <boost/filesystem/path.hpp> #include <boost/filesystem/operations.hpp> #include <boost/compute/detail/getenv.hpp> namespace boost { namespace compute { namespace detail { // Path delimiter symbol for the current OS. static const std::string& path_delim() { static const std::string delim = boost::filesystem::path("/").make_preferred().string(); return delim; } // Path to appdata folder. inline const std::string& appdata_path() { #ifdef _WIN32 static const std::string appdata = detail::getenv("APPDATA") + path_delim() + "boost_compute"; #else static const std::string appdata = detail::getenv("HOME") + path_delim() + ".boost_compute"; #endif return appdata; } // Path to cached binaries. inline std::string program_binary_path(const std::string &hash, bool create = false) { std::string dir = detail::appdata_path() + path_delim() + hash.substr(0, 2) + path_delim() + hash.substr(2); if(create && !boost::filesystem::exists(dir)){ boost::filesystem::create_directories(dir); } return dir + path_delim(); } // Path to parameter caches. inline std::string parameter_cache_path(bool create = false) { const static std::string dir = appdata_path() + path_delim() + "tune"; if(create && !boost::filesystem::exists(dir)){ boost::filesystem::create_directories(dir); } return dir + path_delim(); } } // end detail namespace } // end compute namespace } // end boost namespace #endif // BOOST_COMPUTE_DETAIL_PATH_HPP PK��iX!\�:�a�� vendor.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_VENDOR_HPP #define BOOST_COMPUTE_DETAIL_VENDOR_HPP #include <boost/compute/device.hpp> #include <boost/compute/platform.hpp> namespace boost { namespace compute { namespace detail { // returns true if the device is an nvidia gpu inline bool is_nvidia_device(const device &device) { std::string nvidia("NVIDIA"); return device.vendor().compare(0, nvidia.size(), nvidia) == 0; } // returns true if the device is an amd cpu or gpu inline bool is_amd_device(const device &device) { return device.platform().vendor() == "Advanced Micro Devices, Inc."; } // returns true if the platform is Apple OpenCL platform inline bool is_apple_platform(const platform &platform) { return platform.name() == "Apple"; } // returns true if the device is from Apple OpenCL Platform inline bool is_apple_platform_device(const device &device) { return is_apple_platform(device.platform()); } } // end detail namespace } // end compute namespace } // end boost namespace #endif // BOOST_COMPUTE_DETAIL_VENDOR_HPP PK��iX!\L�I� �� lru_cache.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_LRU_CACHE_HPP #define BOOST_COMPUTE_DETAIL_LRU_CACHE_HPP #include <map> #include <list> #include <utility> #include <boost/optional.hpp> namespace boost { namespace compute { namespace detail { // a cache which evicts the least recently used item when it is full template<class Key, class Value> class lru_cache { public: typedef Key key_type; typedef Value value_type; typedef std::list<key_type> list_type; typedef std::map< key_type, std::pair<value_type, typename list_type::iterator> > map_type; lru_cache(size_t capacity) : m_capacity(capacity) { } ~lru_cache() { } size_t size() const { return m_map.size(); } size_t capacity() const { return m_capacity; } bool empty() const { return m_map.empty(); } bool contains(const key_type &key) { return m_map.find(key) != m_map.end(); } void insert(const key_type &key, const value_type &value) { typename map_type::iterator i = m_map.find(key); if(i == m_map.end()){ // insert item into the cache, but first check if it is full if(size() >= m_capacity){ // cache is full, evict the least recently used item evict(); } // insert the new item m_list.push_front(key); m_map[key] = std::make_pair(value, m_list.begin()); } } boost::optional<value_type> get(const key_type &key) { // lookup value in the cache typename map_type::iterator i = m_map.find(key); if(i == m_map.end()){ // value not in cache return boost::none; } // return the value, but first update its place in the most // recently used list typename list_type::iterator j = i->second.second; if(j != m_list.begin()){ // move item to the front of the most recently used list m_list.erase(j); m_list.push_front(key); // update iterator in map j = m_list.begin(); const value_type &value = i->second.first; m_map[key] = std::make_pair(value, j); // return the value return value; } else { // the item is already at the front of the most recently // used list so just return it return i->second.first; } } void clear() { m_map.clear(); m_list.clear(); } private: void evict() { // evict item from the end of most recently used list typename list_type::iterator i = --m_list.end(); m_map.erase(i); m_list.erase(i); } private: map_type m_map; list_type m_list; size_t m_capacity; }; } // end detail namespace } // end compute namespace } // end boost namespace #endif // BOOST_COMPUTE_DETAIL_LRU_CACHE_HPP PK��iX!\��_i��i��duration.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_DURATION_HPP #define BOOST_COMPUTE_DETAIL_DURATION_HPP #include <boost/config.hpp> #ifndef BOOST_COMPUTE_NO_HDR_CHRONO #include <chrono> #endif #ifndef BOOST_COMPUTE_NO_BOOST_CHRONO #include <boost/chrono/duration.hpp> #endif namespace boost { namespace compute { namespace detail { #ifndef BOOST_COMPUTE_NO_HDR_CHRONO template<class Rep, class Period> inline std::chrono::duration<Rep, Period> make_duration_from_nanoseconds(std::chrono::duration<Rep, Period>, size_t nanoseconds) { return std::chrono::duration_cast<std::chrono::duration<Rep, Period> >( std::chrono::nanoseconds(nanoseconds) ); } #endif // BOOST_COMPUTE_NO_HDR_CHRONO #ifndef BOOST_COMPUTE_NO_BOOST_CHRONO template<class Rep, class Period> inline boost::chrono::duration<Rep, Period> make_duration_from_nanoseconds(boost::chrono::duration<Rep, Period>, size_t nanoseconds) { return boost::chrono::duration_cast<boost::chrono::duration<Rep, Period> >( boost::chrono::nanoseconds(nanoseconds) ); } #endif // BOOST_COMPUTE_NO_BOOST_CHRONO } // end detail namespace } // end compute namespace } // end boost namespace #endif // BOOST_COMPUTE_DETAIL_DURATION_HPP PK��iX!\��K\| ��\| ��get_object_info.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_GET_OBJECT_INFO_HPP #define BOOST_COMPUTE_DETAIL_GET_OBJECT_INFO_HPP #include <string> #include <vector> #include <boost/preprocessor/seq/for_each.hpp> #include <boost/preprocessor/tuple/elem.hpp> #include <boost/throw_exception.hpp> #include <boost/compute/cl.hpp> #include <boost/compute/exception/opencl_error.hpp> namespace boost { namespace compute { namespace detail { template<class Function, class Object, class AuxInfo> struct bound_info_function { bound_info_function(Function function, Object object, AuxInfo aux_info) : m_function(function), m_object(object), m_aux_info(aux_info) { } template<class Info> cl_int operator()(Info info, size_t input_size, const void input, size_t size, void value, size_t size_ret) const { return m_function( m_object, m_aux_info, info, input_size, input, size, value, size_ret ); } template<class Info> cl_int operator()(Info info, size_t size, void value, size_t size_ret) const { return m_function(m_object, m_aux_info, info, size, value, size_ret); } Function m_function; Object m_object; AuxInfo m_aux_info; }; template<class Function, class Object> struct bound_info_function<Function, Object, void> { bound_info_function(Function function, Object object) : m_function(function), m_object(object) { } template<class Info> cl_int operator()(Info info, size_t size, void value, size_t size_ret) const { return m_function(m_object, info, size, value, size_ret); } Function m_function; Object m_object; }; template<class Function, class Object> inline bound_info_function<Function, Object, void> bind_info_function(Function f, Object o) { return bound_info_function<Function, Object, void>(f, o); } template<class Function, class Object, class AuxInfo> inline bound_info_function<Function, Object, AuxInfo> bind_info_function(Function f, Object o, AuxInfo j) { return bound_info_function<Function, Object, AuxInfo>(f, o, j); } // default implementation template<class T> struct get_object_info_impl { template<class Function, class Info> T operator()(Function function, Info info) const { T value; cl_int ret = function(info, sizeof(T), &value, 0); if(ret != CL_SUCCESS){ BOOST_THROW_EXCEPTION(opencl_error(ret)); } return value; } template<class Function, class Info> T operator()(Function function, Info info, const size_t input_size, const void input) const { T value; cl_int ret = function(info, input_size, input, sizeof(T), &value, 0); if(ret != CL_SUCCESS){ BOOST_THROW_EXCEPTION(opencl_error(ret)); } return value; } }; // specialization for bool template<> struct get_object_info_impl<bool> { template<class Function, class Info> bool operator()(Function function, Info info) const { cl_bool value; cl_int ret = function(info, sizeof(cl_bool), &value, 0); if(ret != CL_SUCCESS){ BOOST_THROW_EXCEPTION(opencl_error(ret)); } return value == CL_TRUE; } }; // specialization for std::string template<> struct get_object_info_impl<std::string> { template<class Function, class Info> std::string operator()(Function function, Info info) const { size_t size = 0; cl_int ret = function(info, 0, 0, &size); if(ret != CL_SUCCESS){ BOOST_THROW_EXCEPTION(opencl_error(ret)); } if(size == 0){ return std::string(); } std::string value(size - 1, 0); ret = function(info, size, &value[0], 0); if(ret != CL_SUCCESS){ BOOST_THROW_EXCEPTION(opencl_error(ret)); } return value; } }; // specialization for std::vector<T> template<class T> struct get_object_info_impl<std::vector<T> > { template<class Function, class Info> std::vector<T> operator()(Function function, Info info) const { size_t size = 0; cl_int ret = function(info, 0, 0, &size); if(ret != CL_SUCCESS){ BOOST_THROW_EXCEPTION(opencl_error(ret)); } if(size == 0) return std::vector<T>(); std::vector<T> vector(size / sizeof(T)); ret = function(info, size, &vector[0], 0); if(ret != CL_SUCCESS){ BOOST_THROW_EXCEPTION(opencl_error(ret)); } return vector; } template<class Function, class Info> std::vector<T> operator()(Function function, Info info, const size_t input_size, const void* input) const { #ifdef BOOST_COMPUTE_CL_VERSION_2_1 // For CL_KERNEL_LOCAL_SIZE_FOR_SUB_GROUP_COUNT in clGetKernelSubGroupInfo // we can't get param_value_size using param_value_size_ret if(info == CL_KERNEL_LOCAL_SIZE_FOR_SUB_GROUP_COUNT) { std::vector<T> vector(3); cl_int ret = function( info, input_size, input, sizeof(T) * vector.size(), &vector[0], 0 ); if(ret != CL_SUCCESS){ BOOST_THROW_EXCEPTION(opencl_error(ret)); } return vector; } #endif size_t size = 0; cl_int ret = function(info, input_size, input, 0, 0, &size); if(ret != CL_SUCCESS){ BOOST_THROW_EXCEPTION(opencl_error(ret)); } std::vector<T> vector(size / sizeof(T)); ret = function(info, input_size, input, size, &vector[0], 0); if(ret != CL_SUCCESS){ BOOST_THROW_EXCEPTION(opencl_error(ret)); } return vector; } }; // returns the value (of type T) from the given clGetInfo() function call. template<class T, class Function, class Object, class Info> inline T get_object_info(Function f, Object o, Info i) { return get_object_info_impl<T>()(bind_info_function(f, o), i); } template<class T, class Function, class Object, class Info, class AuxInfo> inline T get_object_info(Function f, Object o, Info i, AuxInfo j) { return get_object_info_impl<T>()(bind_info_function(f, o, j), i); } template<class T, class Function, class Object, class Info, class AuxInfo> inline T get_object_info(Function f, Object o, Info i, AuxInfo j, const size_t k, const void l) { return get_object_info_impl<T>()(bind_info_function(f, o, j), i, k, l); } // returns the value type for the clGetInfo() call on Object with Enum. template<class Object, int Enum> struct get_object_info_type; // defines the object::get_info<Enum>() specialization #define BOOST_COMPUTE_DETAIL_DEFINE_GET_INFO_SPECIALIZATION(object_type, result_type, value) \ namespace detail { \ template<> struct get_object_info_type<object_type, value> { typedef result_type type; }; \ } \ template<> inline result_type object_type::get_info<value>() const \ { \ return get_info<result_type>(value); \ } // used by BOOST_COMPUTE_DETAIL_DEFINE_GET_INFO_SPECIALIZATIONS() #define BOOST_COMPUTE_DETAIL_DEFINE_GET_INFO_IMPL(r, data, elem) \ BOOST_COMPUTE_DETAIL_DEFINE_GET_INFO_SPECIALIZATION( \ data, BOOST_PP_TUPLE_ELEM(2, 0, elem), BOOST_PP_TUPLE_ELEM(2, 1, elem) \ ) // defines the object::get_info<Enum>() specialization for each // (result_type, value) tuple in seq for object_type. #define BOOST_COMPUTE_DETAIL_DEFINE_GET_INFO_SPECIALIZATIONS(object_type, seq) \ BOOST_PP_SEQ_FOR_EACH( \ BOOST_COMPUTE_DETAIL_DEFINE_GET_INFO_IMPL, object_type, seq \ ) } // end detail namespace } // end compute namespace } // end boost namespace #endif // BOOST_COMPUTE_DETAIL_GET_OBJECT_INFO_HPP PK��iX!\p/2��device_ptr.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DEVICE_PTR_HPP #define BOOST_COMPUTE_DEVICE_PTR_HPP #include <boost/type_traits.hpp> #include <boost/static_assert.hpp> #include <boost/compute/buffer.hpp> #include <boost/compute/config.hpp> #include <boost/compute/detail/is_buffer_iterator.hpp> #include <boost/compute/detail/read_write_single_value.hpp> #include <boost/compute/type_traits/is_device_iterator.hpp> namespace boost { namespace compute { namespace detail { template<class T, class IndexExpr> struct device_ptr_index_expr { typedef T result_type; device_ptr_index_expr(const buffer &buffer, uint_ index, const IndexExpr &expr) : m_buffer(buffer), m_index(index), m_expr(expr) { } operator T() const { BOOST_STATIC_ASSERT_MSG(boost::is_integral<IndexExpr>::value, "Index expression must be integral"); BOOST_ASSERT(m_buffer.get()); const context &context = m_buffer.get_context(); const device &device = context.get_device(); command_queue queue(context, device); return detail::read_single_value<T>(m_buffer, m_expr, queue); } const buffer &m_buffer; uint_ m_index; IndexExpr m_expr; }; template<class T> class device_ptr { public: typedef T value_type; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef std::random_access_iterator_tag iterator_category; typedef T pointer; typedef T& reference; device_ptr() : m_index(0) { } device_ptr(const buffer &buffer, size_t index = 0) : m_buffer(buffer.get(), false), m_index(index) { } device_ptr(const device_ptr<T> &other) : m_buffer(other.m_buffer.get(), false), m_index(other.m_index) { } device_ptr<T>& operator=(const device_ptr<T> &other) { if(this != &other){ m_buffer.get() = other.m_buffer.get(); m_index = other.m_index; } return this; } #ifndef BOOST_COMPUTE_NO_RVALUE_REFERENCES device_ptr(device_ptr<T>&& other) BOOST_NOEXCEPT : m_buffer(other.m_buffer.get(), false), m_index(other.m_index) { other.m_buffer.get() = 0; } device_ptr<T>& operator=(device_ptr<T>&& other) BOOST_NOEXCEPT { m_buffer.get() = other.m_buffer.get(); m_index = other.m_index; other.m_buffer.get() = 0; return this; } #endif // BOOST_COMPUTE_NO_RVALUE_REFERENCES ~device_ptr() { // set buffer to null so that its reference count will // not be decremented when its destructor is called m_buffer.get() = 0; } size_type get_index() const { return m_index; } const buffer& get_buffer() const { return m_buffer; } template<class OT> device_ptr<OT> cast() const { return device_ptr<OT>(m_buffer, m_index); } device_ptr<T> operator+(difference_type n) const { return device_ptr<T>(m_buffer, m_index + n); } device_ptr<T> operator+(const device_ptr<T> &other) const { return device_ptr<T>(m_buffer, m_index + other.m_index); } device_ptr<T>& operator+=(difference_type n) { m_index += static_cast<size_t>(n); return this; } difference_type operator-(const device_ptr<T> &other) const { return static_cast<difference_type>(m_index - other.m_index); } device_ptr<T>& operator-=(difference_type n) { m_index -= n; return this; } bool operator==(const device_ptr<T> &other) const { return m_buffer.get() == other.m_buffer.get() && m_index == other.m_index; } bool operator!=(const device_ptr<T> &other) const { return !(this == other); } template<class Expr> detail::device_ptr_index_expr<T, Expr> operator[](const Expr &expr) const { BOOST_ASSERT(m_buffer.get()); return detail::device_ptr_index_expr<T, Expr>(m_buffer, uint_(m_index), expr); } private: const buffer m_buffer; size_t m_index; }; // is_buffer_iterator specialization for device_ptr template<class Iterator> struct is_buffer_iterator< Iterator, typename boost::enable_if< boost::is_same< device_ptr<typename Iterator::value_type>, typename boost::remove_const<Iterator>::type > >::type > : public boost::true_type {}; } // end detail namespace // is_device_iterator specialization for device_ptr template<class T> struct is_device_iterator<detail::device_ptr<T> > : boost::true_type {}; } // end compute namespace } // end boost namespace #endif // BOOST_COMPUTE_DEVICE_PTR_HPP PK��iX!\)��is_contiguous_iterator.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_IS_CONTIGUOUS_ITERATOR_HPP #define BOOST_COMPUTE_DETAIL_IS_CONTIGUOUS_ITERATOR_HPP #include <vector> #include <valarray> #include <boost/config.hpp> #include <boost/type_traits.hpp> #include <boost/utility/enable_if.hpp> namespace boost { namespace compute { namespace detail { // default = false template<class Iterator, class Enable = void> struct _is_contiguous_iterator : public boost::false_type {}; // std::vector<T>::iterator = true template<class Iterator> struct _is_contiguous_iterator< Iterator, typename boost::enable_if< typename boost::is_same< Iterator, typename std::vector<typename Iterator::value_type>::iterator >::type >::type > : public boost::true_type {}; // std::vector<T>::const_iterator = true template<class Iterator> struct _is_contiguous_iterator< Iterator, typename boost::enable_if< typename boost::is_same< Iterator, typename std::vector<typename Iterator::value_type>::const_iterator >::type >::type > : public boost::true_type {}; // std::valarray<T>::iterator = true template<class Iterator> struct _is_contiguous_iterator< Iterator, typename boost::enable_if< typename boost::is_same< Iterator, typename std::valarray<typename Iterator::value_type>::iterator >::type >::type > : public boost::true_type {}; // std::valarray<T>::const_iterator = true template<class Iterator> struct _is_contiguous_iterator< Iterator, typename boost::enable_if< typename boost::is_same< Iterator, typename std::valarray<typename Iterator::value_type>::const_iterator >::type >::type > : public boost::true_type {}; // T = true template<class Iterator> struct _is_contiguous_iterator< Iterator, typename boost::enable_if< boost::is_pointer<Iterator> >::type > : public boost::true_type {}; // the is_contiguous_iterator meta-function returns true if Iterator points // to a range of contiguous values. examples of contiguous iterators are // std::vector<>::iterator and float. examples of non-contiguous iterators // are std::set<>::iterator and std::insert_iterator<>. // // the implementation consists of two phases. the first checks that value_type // for the iterator is not void. this must be done as for many containers void // is not a valid value_type (ex. std::vector<void>::iterator is not valid). // after ensuring a non-void value_type, the _is_contiguous_iterator function // is invoked. it has specializations retuning true for all (known) contiguous // iterators types and a default value of false. template<class Iterator, class Enable = void> struct is_contiguous_iterator : public _is_contiguous_iterator< typename boost::remove_cv<Iterator>::type > {}; // value_type of void = false template<class Iterator> struct is_contiguous_iterator< Iterator, typename boost::enable_if< typename boost::is_void< typename Iterator::value_type >::type >::type > : public boost::false_type {}; } // end detail namespace } // end compute namespace } // end boost namespace #endif // BOOST_COMPUTE_DETAIL_IS_CONTIGUOUS_ITERATOR_HPP PK��iX!\� 2�� work_size.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_WORK_SIZE_HPP #define BOOST_COMPUTE_DETAIL_WORK_SIZE_HPP #include <cmath> namespace boost { namespace compute { namespace detail { // Given a total number of values (count), a number of values to // process per thread (vtp), and a number of threads to execute per // block (tpb), this function returns the global work size to be // passed to clEnqueueNDRangeKernel() for a 1D algorithm. inline size_t calculate_work_size(size_t count, size_t vpt, size_t tpb) { size_t work_size = static_cast<size_t>(std::ceil(float(count) / vpt)); if(work_size % tpb != 0){ work_size += tpb - work_size % tpb; } return work_size; } } // end detail namespace } // end compute namespace } // end boost namespace #endif // BOOST_COMPUTE_DETAIL_WORK_SIZE_HPP PK��iX!\��l��buffer_value.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_BUFFER_VALUE_HPP #define BOOST_COMPUTE_DETAIL_BUFFER_VALUE_HPP #include <boost/compute/context.hpp> #include <boost/compute/command_queue.hpp> #include <boost/compute/detail/device_ptr.hpp> #include <boost/compute/detail/read_write_single_value.hpp> namespace boost { namespace compute { namespace detail { template<class T> class buffer_value { public: typedef T value_type; buffer_value() { } buffer_value(const value_type &value) : m_value(value) { } // creates a reference for the value in buffer at index (in bytes). buffer_value(const buffer &buffer, size_t index) : m_buffer(buffer.get(), false), m_index(index) { } buffer_value(const buffer_value<T> &other) : m_buffer(other.m_buffer.get(), false), m_index(other.m_index) { } ~buffer_value() { // set buffer to null so that its reference count will // not be decremented when its destructor is called m_buffer.get() = 0; } operator value_type() const { if(m_buffer.get()){ const context &context = m_buffer.get_context(); const device &device = context.get_device(); command_queue queue(context, device); return detail::read_single_value<T>(m_buffer, m_index / sizeof(T), queue); } else { return m_value; } } buffer_value<T> operator-() const { return -T(this); } bool operator<(const T &value) const { return T(this) < value; } bool operator>(const T &value) const { return T(this) > value; } bool operator<=(const T &value) const { return T(this) <= value; } bool operator>=(const T &value) const { return T(this) <= value; } bool operator==(const T &value) const { return T(this) == value; } bool operator==(const buffer_value<T> &other) const { if(m_buffer.get() != other.m_buffer.get()){ return false; } if(m_buffer.get()){ return m_index == other.m_index; } else { return m_value == other.m_value; } } bool operator!=(const T &value) const { return T(this) != value; } buffer_value<T>& operator=(const T &value) { if(m_buffer.get()){ const context &context = m_buffer.get_context(); command_queue queue(context, context.get_device()); detail::write_single_value<T>( value, m_buffer, m_index / sizeof(T), queue ).wait(); return this; } else { m_value = value; return this; } } buffer_value<T>& operator=(const buffer_value<T> &value) { return operator=(T(value)); } detail::device_ptr<T> operator&() const { return detail::device_ptr<T>(m_buffer, m_index); } buffer_value<T>& operator++() { if(m_buffer.get()){ T value = T(this); value++; this = value; } else { m_value++; } return this; } buffer_value<T> operator++(int) { buffer_value<T> result(this); ++(this); return result; } private: const buffer m_buffer; size_t m_index; value_type m_value; }; } // end detail namespace } // end compute namespace } // end boost namespace #endif // BOOST_COMPUTE_DETAIL_BUFFER_VALUE_HPP PK��iX!\._�'��global_static.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_GLOBAL_STATIC_HPP #define BOOST_COMPUTE_DETAIL_GLOBAL_STATIC_HPP #include <boost/compute/config.hpp> #ifdef BOOST_COMPUTE_THREAD_SAFE # ifdef BOOST_COMPUTE_HAVE_THREAD_LOCAL // use c++11 thread local storage # define BOOST_COMPUTE_DETAIL_GLOBAL_STATIC(type, name, ctor) \ thread_local type name ctor; # else // use thread_specific_ptr from boost.thread # include <boost/thread/tss.hpp> # define BOOST_COMPUTE_DETAIL_GLOBAL_STATIC(type, name, ctor) \ static ::boost::thread_specific_ptr< type > BOOST_PP_CAT(name, _tls_ptr_); \ if(!BOOST_PP_CAT(name, _tls_ptr_).get()){ \ BOOST_PP_CAT(name, _tls_ptr_).reset(new type ctor); \ } \ static type &name = BOOST_PP_CAT(name, _tls_ptr_); # endif #else // no thread-safety, just use static # define BOOST_COMPUTE_DETAIL_GLOBAL_STATIC(type, name, ctor) \ static type name ctor; #endif #endif // BOOST_COMPUTE_DETAIL_GLOBAL_STATIC_HPP PK��iX!\i�u\+}��+}��meta_kernel.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_META_KERNEL_HPP #define BOOST_COMPUTE_DETAIL_META_KERNEL_HPP #include <set> #include <string> #include <vector> #include <iomanip> #include <sstream> #include <utility> #include <boost/tuple/tuple.hpp> #include <boost/type_traits.hpp> #include <boost/lexical_cast.hpp> #include <boost/static_assert.hpp> #include <boost/algorithm/string/find.hpp> #include <boost/preprocessor/repetition.hpp> #include <boost/compute/kernel.hpp> #include <boost/compute/closure.hpp> #include <boost/compute/function.hpp> #include <boost/compute/functional.hpp> #include <boost/compute/type_traits.hpp> #include <boost/compute/command_queue.hpp> #include <boost/compute/image/image2d.hpp> #include <boost/compute/image/image_sampler.hpp> #include <boost/compute/memory_object.hpp> #include <boost/compute/memory/svm_ptr.hpp> #include <boost/compute/detail/device_ptr.hpp> #include <boost/compute/detail/sha1.hpp> #include <boost/compute/utility/program_cache.hpp> namespace boost { namespace compute { namespace detail { template<class T> class meta_kernel_variable { public: typedef T result_type; meta_kernel_variable(const std::string &name) : m_name(name) { } meta_kernel_variable(const meta_kernel_variable &other) : m_name(other.m_name) { } meta_kernel_variable& operator=(const meta_kernel_variable &other) { if(this != &other){ m_name = other.m_name; } return this; } ~meta_kernel_variable() { } std::string name() const { return m_name; } private: std::string m_name; }; template<class T> class meta_kernel_literal { public: typedef T result_type; meta_kernel_literal(const T &value) : m_value(value) { } meta_kernel_literal(const meta_kernel_literal &other) : m_value(other.m_value) { } meta_kernel_literal& operator=(const meta_kernel_literal &other) { if(this != &other){ m_value = other.m_value; } return this; } ~meta_kernel_literal() { } const T& value() const { return m_value; } private: T m_value; }; struct meta_kernel_stored_arg { meta_kernel_stored_arg() : m_size(0), m_value(0) { } meta_kernel_stored_arg(const meta_kernel_stored_arg &other) : m_size(0), m_value(0) { set_value(other.m_size, other.m_value); } meta_kernel_stored_arg& operator=(const meta_kernel_stored_arg &other) { if(this != &other){ set_value(other.m_size, other.m_value); } return this; } template<class T> meta_kernel_stored_arg(const T &value) : m_size(0), m_value(0) { set_value(value); } ~meta_kernel_stored_arg() { if(m_value){ std::free(m_value); } } void set_value(size_t size, const void value) { if(m_value){ std::free(m_value); } m_size = size; if(value){ m_value = std::malloc(size); std::memcpy(m_value, value, size); } else { m_value = 0; } } template<class T> void set_value(const T &value) { set_value(sizeof(T), boost::addressof(value)); } size_t m_size; void m_value; }; struct meta_kernel_buffer_info { meta_kernel_buffer_info(const buffer &buffer, const std::string &id, memory_object::address_space addr_space, size_t i) : m_mem(buffer.get()), identifier(id), address_space(addr_space), index(i) { } cl_mem m_mem; std::string identifier; memory_object::address_space address_space; size_t index; }; struct meta_kernel_svm_info { template <class T> meta_kernel_svm_info(const svm_ptr<T> ptr, const std::string &id, memory_object::address_space addr_space, size_t i) : ptr(ptr.get()), identifier(id), address_space(addr_space), index(i) { } void ptr; std::string identifier; memory_object::address_space address_space; size_t index; }; class meta_kernel; template<class Type> struct inject_type_impl { void operator()(meta_kernel &) { // default implementation does nothing } }; #define BOOST_COMPUTE_META_KERNEL_DECLARE_SCALAR_TYPE_STREAM_OPERATOR(type) \ meta_kernel& operator<<(const type &x) \ { \ m_source << x; \ return this; \ } #define BOOST_COMPUTE_META_KERNEL_DECLARE_VECTOR_TYPE_STREAM_OPERATOR(type) \ meta_kernel& operator<<(const type &x) \ { \ m_source << "(" << type_name<type>() << ")"; \ m_source << "("; \ for(size_t i = 0; i < vector_size<type>::value; i++){ \ this << lit(x[i]); \ \ if(i != vector_size<type>::value - 1){ \ m_source << ","; \ } \ } \ m_source << ")"; \ return this; \ } #define BOOST_COMPUTE_META_KERNEL_DECLARE_TYPE_STREAM_OPERATORS(type) \ BOOST_COMPUTE_META_KERNEL_DECLARE_SCALAR_TYPE_STREAM_OPERATOR(BOOST_PP_CAT(type, _)) \ BOOST_COMPUTE_META_KERNEL_DECLARE_VECTOR_TYPE_STREAM_OPERATOR(BOOST_PP_CAT(BOOST_PP_CAT(type, 2), _)) \ BOOST_COMPUTE_META_KERNEL_DECLARE_VECTOR_TYPE_STREAM_OPERATOR(BOOST_PP_CAT(BOOST_PP_CAT(type, 4), _)) \ BOOST_COMPUTE_META_KERNEL_DECLARE_VECTOR_TYPE_STREAM_OPERATOR(BOOST_PP_CAT(BOOST_PP_CAT(type, 8), _)) \ BOOST_COMPUTE_META_KERNEL_DECLARE_VECTOR_TYPE_STREAM_OPERATOR(BOOST_PP_CAT(BOOST_PP_CAT(type, 16), _)) class meta_kernel { public: template<class T> class argument { public: argument(const std::string &name, size_t index) : m_name(name), m_index(index) { } const std::string &name() const { return m_name; } size_t index() const { return m_index; } private: std::string m_name; size_t m_index; }; explicit meta_kernel(const std::string &name) : m_name(name) { } meta_kernel(const meta_kernel &other) { m_source.str(other.m_source.str()); m_options = other.m_options; } meta_kernel& operator=(const meta_kernel &other) { if(this != &other){ m_source.str(other.m_source.str()); m_options = other.m_options; } return this; } ~meta_kernel() { } std::string name() const { return m_name; } std::string source() const { std::stringstream stream; // add pragmas if(!m_pragmas.empty()){ stream << m_pragmas << "\n"; } // add macros stream << "#define boost_pair_type(t1, t2) _pair_ ## t1 ## _ ## t2 ## _t\n"; stream << "#define boost_pair_get(x, n) (n == 0 ? x.first ## x.second)\n"; stream << "#define boost_make_pair(t1, x, t2, y) (boost_pair_type(t1, t2)) { x, y }\n"; stream << "#define boost_tuple_get(x, n) (x.v ## n)\n"; // add type declaration source stream << m_type_declaration_source.str() << "\n"; // add external function source stream << m_external_function_source.str() << "\n"; // add kernel source stream << "__kernel void " << m_name << "(" << boost::join(m_args, ", ") << ")\n" << "{\n" << m_source.str() << "\n}\n"; return stream.str(); } kernel compile(const context &context, const std::string &options = std::string()) { // generate the program source std::string source = this->source(); // generate cache key std::string cache_key = "__boost_meta_kernel_" + static_cast<std::string>(detail::sha1(source)); // load program cache boost::shared_ptr<program_cache> cache = program_cache::get_global_cache(context); std::string compile_options = m_options + options; // load (or build) program from cache ::boost::compute::program program = cache->get_or_build(cache_key, compile_options, source, context); // create kernel ::boost::compute::kernel kernel = program.create_kernel(name()); // bind stored args for(size_t i = 0; i < m_stored_args.size(); i++){ const detail::meta_kernel_stored_arg &arg = m_stored_args[i]; if(arg.m_size != 0){ kernel.set_arg(i, arg.m_size, arg.m_value); } } // bind buffer args for(size_t i = 0; i < m_stored_buffers.size(); i++){ const detail::meta_kernel_buffer_info &bi = m_stored_buffers[i]; kernel.set_arg(bi.index, bi.m_mem); } // bind svm args for(size_t i = 0; i < m_stored_svm_ptrs.size(); i++){ const detail::meta_kernel_svm_info &spi = m_stored_svm_ptrs[i]; kernel.set_arg_svm_ptr(spi.index, spi.ptr); } return kernel; } template<class T> size_t add_arg(const std::string &name) { std::stringstream stream; stream << type<T>() << " " << name; // add argument to list m_args.push_back(stream.str()); // return index return m_args.size() - 1; } template<class T> size_t add_arg(memory_object::address_space address_space, const std::string &name) { return add_arg_with_qualifiers<T>(address_space_prefix(address_space), name); } template<class T> void set_arg(size_t index, const T &value) { if(index >= m_stored_args.size()){ m_stored_args.resize(index + 1); } m_stored_args[index] = detail::meta_kernel_stored_arg(value); } void set_arg(size_t index, const memory_object &mem) { set_arg<cl_mem>(index, mem.get()); } void set_arg(size_t index, const image_sampler &sampler) { set_arg<cl_sampler>(index, cl_sampler(sampler)); } template<class T> size_t add_set_arg(const std::string &name, const T &value) { size_t index = add_arg<T>(name); set_arg<T>(index, value); return index; } void add_extension_pragma(const std::string &extension, const std::string &value = "enable") { m_pragmas += "#pragma OPENCL EXTENSION " + extension + " : " + value + "\n"; } void add_extension_pragma(const std::string &extension, const std::string &value) const { return const_cast<meta_kernel >(this)->add_extension_pragma(extension, value); } template<class T> std::string type() const { std::stringstream stream; // const qualifier if(boost::is_const<T>::value){ stream << "const "; } // volatile qualifier if(boost::is_volatile<T>::value){ stream << "volatile "; } // type typedef typename boost::remove_cv< typename boost::remove_pointer<T>::type >::type Type; stream << type_name<Type>(); // pointer if(boost::is_pointer<T>::value){ stream << ""; } // inject type pragmas and/or definitions inject_type<Type>(); return stream.str(); } template<class T> std::string decl(const std::string &name) const { return type<T>() + " " + name; } template<class T, class Expr> std::string decl(const std::string &name, const Expr &init) const { meta_kernel tmp((std::string())); tmp << tmp.decl<T>(name) << " = " << init; return tmp.m_source.str(); } template<class T> detail::meta_kernel_variable<T> var(const std::string &name) const { type<T>(); return make_var<T>(name); } template<class T> detail::meta_kernel_literal<T> lit(const T &value) const { type<T>(); return detail::meta_kernel_literal<T>(value); } template<class T> detail::meta_kernel_variable<T> expr(const std::string &expr) const { type<T>(); return detail::meta_kernel_variable<T>(expr); } // define stream operators for scalar and vector types BOOST_COMPUTE_META_KERNEL_DECLARE_TYPE_STREAM_OPERATORS(char) BOOST_COMPUTE_META_KERNEL_DECLARE_TYPE_STREAM_OPERATORS(uchar) BOOST_COMPUTE_META_KERNEL_DECLARE_TYPE_STREAM_OPERATORS(short) BOOST_COMPUTE_META_KERNEL_DECLARE_TYPE_STREAM_OPERATORS(ushort) BOOST_COMPUTE_META_KERNEL_DECLARE_TYPE_STREAM_OPERATORS(int) BOOST_COMPUTE_META_KERNEL_DECLARE_TYPE_STREAM_OPERATORS(uint) BOOST_COMPUTE_META_KERNEL_DECLARE_TYPE_STREAM_OPERATORS(long) BOOST_COMPUTE_META_KERNEL_DECLARE_TYPE_STREAM_OPERATORS(ulong) BOOST_COMPUTE_META_KERNEL_DECLARE_TYPE_STREAM_OPERATORS(double) // define stream operators for float scalar and vector types meta_kernel& operator<<(const float &x) { m_source << std::showpoint << x << 'f'; return this; } BOOST_COMPUTE_META_KERNEL_DECLARE_VECTOR_TYPE_STREAM_OPERATOR(float2_) BOOST_COMPUTE_META_KERNEL_DECLARE_VECTOR_TYPE_STREAM_OPERATOR(float4_) BOOST_COMPUTE_META_KERNEL_DECLARE_VECTOR_TYPE_STREAM_OPERATOR(float8_) BOOST_COMPUTE_META_KERNEL_DECLARE_VECTOR_TYPE_STREAM_OPERATOR(float16_) // define stream operators for variable types template<class T> meta_kernel& operator<<(const meta_kernel_variable<T> &variable) { return this << variable.name(); } // define stream operators for literal types template<class T> meta_kernel& operator<<(const meta_kernel_literal<T> &literal) { return this << literal.value(); } meta_kernel& operator<<(const meta_kernel_literal<bool> &literal) { return this << (literal.value() ? "true" : "false"); } meta_kernel& operator<<(const meta_kernel_literal<char> &literal) { const char c = literal.value(); switch(c){ // control characters case '\0': return this << "'\\0'"; case '\a': return this << "'\\a'"; case '\b': return this << "'\\b'"; case '\t': return this << "'\\t'"; case '\n': return this << "'\\n'"; case '\v': return this << "'\\v'"; case '\f': return this << "'\\f'"; case '\r': return this << "'\\r'"; // characters which need escaping case '\"': case '\'': case '\?': case '\\': return this << "'\\" << c << "'"; // all other characters default: return this << "'" << c << "'"; } } meta_kernel& operator<<(const meta_kernel_literal<signed char> &literal) { return this << lit<char>(literal.value()); } meta_kernel& operator<<(const meta_kernel_literal<unsigned char> &literal) { return this << uint_(literal.value()); } // define stream operators for strings meta_kernel& operator<<(char ch) { m_source << ch; return this; } meta_kernel& operator<<(const char string) { m_source << string; return this; } meta_kernel& operator<<(const std::string &string) { m_source << string; return this; } template<class T> static detail::meta_kernel_variable<T> make_var(const std::string &name) { return detail::meta_kernel_variable<T>(name); } template<class T> static detail::meta_kernel_literal<T> make_lit(const T &value) { return detail::meta_kernel_literal<T>(value); } template<class T> static detail::meta_kernel_variable<T> make_expr(const std::string &expr) { return detail::meta_kernel_variable<T>(expr); } event exec(command_queue &queue) { return exec_1d(queue, 0, 1); } event exec_1d(command_queue &queue, size_t global_work_offset, size_t global_work_size, const wait_list &events = wait_list()) { const context &context = queue.get_context(); ::boost::compute::kernel kernel = compile(context); return queue.enqueue_1d_range_kernel( kernel, global_work_offset, global_work_size, 0, events ); } event exec_1d(command_queue &queue, size_t global_work_offset, size_t global_work_size, size_t local_work_size, const wait_list &events = wait_list()) { const context &context = queue.get_context(); ::boost::compute::kernel kernel = compile(context); return queue.enqueue_1d_range_kernel( kernel, global_work_offset, global_work_size, local_work_size, events ); } template<class T> std::string get_buffer_identifier(const buffer &buffer, const memory_object::address_space address_space = memory_object::global_memory) { // check if we've already seen buffer for(size_t i = 0; i < m_stored_buffers.size(); i++){ const detail::meta_kernel_buffer_info &bi = m_stored_buffers[i]; if(bi.m_mem == buffer.get() && bi.address_space == address_space){ return bi.identifier; } } // create a new binding std::string identifier = "_buf" + lexical_cast<std::string>(m_stored_buffers.size()); size_t index = add_arg<T >(address_space, identifier); // store new buffer info m_stored_buffers.push_back( detail::meta_kernel_buffer_info(buffer, identifier, address_space, index)); return identifier; } template<class T> std::string get_svm_identifier(const svm_ptr<T> &svm_ptr, const memory_object::address_space address_space = memory_object::global_memory) { BOOST_ASSERT( (address_space == memory_object::global_memory) \|\| (address_space == memory_object::constant_memory) ); // check if we've already seen this pointer for(size_t i = 0; i < m_stored_svm_ptrs.size(); i++){ const detail::meta_kernel_svm_info &spi = m_stored_svm_ptrs[i]; if(spi.ptr == svm_ptr.get() && spi.address_space == address_space){ return spi.identifier; } } // create a new binding std::string identifier = "_svm_ptr" + lexical_cast<std::string>(m_stored_svm_ptrs.size()); size_t index = add_arg<T >(address_space, identifier); if(m_stored_svm_ptrs.empty()) { m_options += std::string(" -cl-std=CL2.0"); } // store new svm pointer info m_stored_svm_ptrs.push_back( detail::meta_kernel_svm_info( svm_ptr, identifier, address_space, index ) ); return identifier; } std::string get_image_identifier(const char qualifiers, const image2d &image) { size_t index = add_arg_with_qualifiers<image2d>(qualifiers, "image"); set_arg(index, image); return "image"; } std::string get_sampler_identifier(bool normalized_coords, cl_addressing_mode addressing_mode, cl_filter_mode filter_mode) { (void) normalized_coords; (void) addressing_mode; (void) filter_mode; m_pragmas += "const sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE \|\n" " CLK_ADDRESS_NONE \|\n" " CLK_FILTER_NEAREST;\n"; return "sampler"; } template<class Expr> static std::string expr_to_string(const Expr &expr) { meta_kernel tmp((std::string())); tmp << expr; return tmp.m_source.str(); } template<class Predicate> detail::invoked_function<bool, boost::tuple<Predicate> > if_(Predicate pred) const { return detail::invoked_function<bool, boost::tuple<Predicate> >( "if", std::string(), boost::make_tuple(pred) ); } template<class Predicate> detail::invoked_function<bool, boost::tuple<Predicate> > else_if_(Predicate pred) const { return detail::invoked_function<bool, boost::tuple<Predicate> >( "else if", std::string(), boost::make_tuple(pred) ); } detail::meta_kernel_variable<cl_uint> get_global_id(size_t dim) const { return expr<cl_uint>("get_global_id(" + lexical_cast<std::string>(dim) + ")"); } void add_function(const std::string &name, const std::string &source) { if(m_external_function_names.count(name)){ return; } m_external_function_names.insert(name); m_external_function_source << source << "\n"; } void add_function(const std::string &name, const std::string &source, const std::map<std::string, std::string> &definitions) { typedef std::map<std::string, std::string>::const_iterator iter; std::stringstream s; // add #define's for(iter i = definitions.begin(); i != definitions.end(); i++){ s << "#define " << i->first; if(!i->second.empty()){ s << " " << i->second; } s << "\n"; } s << source << "\n"; // add #undef's for(iter i = definitions.begin(); i != definitions.end(); i++){ s << "#undef " << i->first << "\n"; } add_function(name, s.str()); } template<class Type> void add_type_declaration(const std::string &declaration) { const char name = type_name<Type>(); // check if the type has already been declared std::string source = m_type_declaration_source.str(); if(source.find(name) != std::string::npos){ return; } m_type_declaration_source << declaration; } template<class Type> void inject_type() const { inject_type_impl<Type>()(const_cast<meta_kernel &>(this)); } // the insert_function_call() method inserts a call to a function with // the given name tuple of argument values. template<class ArgTuple> void insert_function_call(const std::string &name, const ArgTuple &args) { this << name << '('; insert_function_call_args(args); this << ')'; } // the insert_function_call_args() method takes a tuple of argument values // and inserts them into the source string with a comma in-between each. // this is useful for creating function calls given a tuple of values. void insert_function_call_args(const boost::tuple<>&) { } #define BOOST_COMPUTE_META_KERNEL_INSERT_FUNCTION_ARG_TYPE(z, n, unused) \ inject_type<BOOST_PP_CAT(T, n)>(); #define BOOST_COMPUTE_META_KERNEL_STREAM_FUNCTION_ARG(z, n, unused) \ << boost::get<BOOST_PP_DEC(n)>(args) << ", " #define BOOST_COMPUTE_META_KERNEL_INSERT_FUNCTION_ARGS(z, n, unused) \ template<BOOST_PP_ENUM_PARAMS(n, class T)> \ void insert_function_call_args( \ const boost::tuple<BOOST_PP_ENUM_PARAMS(n, T)> &args \ ) \ { \ BOOST_PP_REPEAT_FROM_TO( \ 0, n, BOOST_COMPUTE_META_KERNEL_INSERT_FUNCTION_ARG_TYPE, ~ \ ) \ this \ BOOST_PP_REPEAT_FROM_TO( \ 1, n, BOOST_COMPUTE_META_KERNEL_STREAM_FUNCTION_ARG, ~ \ ) \ << boost::get<BOOST_PP_DEC(n)>(args); \ } BOOST_PP_REPEAT_FROM_TO( 1, BOOST_COMPUTE_MAX_ARITY, BOOST_COMPUTE_META_KERNEL_INSERT_FUNCTION_ARGS, ~ ) #undef BOOST_COMPUTE_META_KERNEL_INSERT_FUNCTION_ARG_TYPE #undef BOOST_COMPUTE_META_KERNEL_STREAM_FUNCTION_ARG #undef BOOST_COMPUTE_META_KERNEL_INSERT_FUNCTION_ARGS static const char* address_space_prefix(const memory_object::address_space value) { switch(value){ case memory_object::global_memory: return "__global"; case memory_object::local_memory: return "__local"; case memory_object::private_memory: return "__private"; case memory_object::constant_memory: return "__constant"; }; return 0; // unreachable } private: template<class T> size_t add_arg_with_qualifiers(const char qualifiers, const std::string &name) { size_t index = add_arg<T>(name); // update argument type declaration with qualifiers std::stringstream s; s << qualifiers << " " << m_args[index]; m_args[index] = s.str(); return index; } private: std::string m_name; std::stringstream m_source; std::stringstream m_external_function_source; std::stringstream m_type_declaration_source; std::set<std::string> m_external_function_names; std::vector<std::string> m_args; std::string m_pragmas; std::string m_options; std::vector<detail::meta_kernel_stored_arg> m_stored_args; std::vector<detail::meta_kernel_buffer_info> m_stored_buffers; std::vector<detail::meta_kernel_svm_info> m_stored_svm_ptrs; }; template<class ResultType, class ArgTuple> inline meta_kernel& operator<<(meta_kernel &kernel, const invoked_function<ResultType, ArgTuple> &expr) { if(!expr.source().empty()){ kernel.add_function(expr.name(), expr.source(), expr.definitions()); } kernel.insert_function_call(expr.name(), expr.args()); return kernel; } template<class ResultType, class ArgTuple, class CaptureTuple> inline meta_kernel& operator<<(meta_kernel &kernel, const invoked_closure<ResultType, ArgTuple, CaptureTuple> &expr) { if(!expr.source().empty()){ kernel.add_function(expr.name(), expr.source(), expr.definitions()); } kernel << expr.name() << '('; kernel.insert_function_call_args(expr.args()); kernel << ", "; kernel.insert_function_call_args(expr.capture()); kernel << ')'; return kernel; } template<class Arg1, class Arg2, class Result> inline meta_kernel& operator<<(meta_kernel &kernel, const invoked_binary_operator<Arg1, Arg2, Result> &expr) { return kernel << "((" << expr.arg1() << ")" << expr.op() << "(" << expr.arg2() << "))"; } template<class T, class IndexExpr> inline meta_kernel& operator<<(meta_kernel &kernel, const detail::device_ptr_index_expr<T, IndexExpr> &expr) { if(expr.m_index == 0){ return kernel << kernel.get_buffer_identifier<T>(expr.m_buffer) << '[' << expr.m_expr << ']'; } else { return kernel << kernel.get_buffer_identifier<T>(expr.m_buffer) << '[' << expr.m_index << "+(" << expr.m_expr << ")]"; } } template<class T1, class T2, class IndexExpr> inline meta_kernel& operator<<(meta_kernel &kernel, const detail::device_ptr_index_expr<std::pair<T1, T2>, IndexExpr> &expr) { typedef std::pair<T1, T2> T; if(expr.m_index == 0){ return kernel << kernel.get_buffer_identifier<T>(expr.m_buffer) << '[' << expr.m_expr << ']'; } else { return kernel << kernel.get_buffer_identifier<T>(expr.m_buffer) << '[' << expr.m_index << "+(" << expr.m_expr << ")]"; } } // SVM requires OpenCL 2.0 #if defined(BOOST_COMPUTE_CL_VERSION_2_0) \|\| defined(BOOST_COMPUTE_DOXYGEN_INVOKED) template<class T, class IndexExpr> inline meta_kernel& operator<<(meta_kernel &kernel, const svm_ptr_index_expr<T, IndexExpr> &expr) { return kernel << kernel.get_svm_identifier<T>(expr.m_svm_ptr) << '[' << expr.m_expr << ']'; } #endif template<class Predicate, class Arg> inline meta_kernel& operator<<(meta_kernel &kernel, const invoked_unary_negate_function<Predicate, Arg> &expr) { return kernel << "!(" << expr.pred()(expr.expr()) << ')'; } template<class Predicate, class Arg1, class Arg2> inline meta_kernel& operator<<(meta_kernel &kernel, const invoked_binary_negate_function<Predicate, Arg1, Arg2> &expr) { return kernel << "!(" << expr.pred()(expr.expr1(), expr.expr2()) << ')'; } // get<N>() for vector types template<size_t N, class Arg, class T> inline meta_kernel& operator<<(meta_kernel &kernel, const invoked_get<N, Arg, T> &expr) { BOOST_STATIC_ASSERT(N < 16); if(N < 10){ return kernel << expr.m_arg << ".s" << int_(N); } else if(N < 16){ #ifdef _MSC_VER # pragma warning(push) # pragma warning(disable: 4307) #endif return kernel << expr.m_arg << ".s" << char('a' + (N - 10)); #ifdef _MSC_VER # pragma warning(pop) #endif } return kernel; } template<class T, class Arg> inline meta_kernel& operator<<(meta_kernel &kernel, const invoked_field<T, Arg> &expr) { return kernel << expr.m_arg << "." << expr.m_field; } template<class T, class Arg> inline meta_kernel& operator<<(meta_kernel &k, const invoked_as<T, Arg> &expr) { return k << "as_" << type_name<T>() << "(" << expr.m_arg << ")"; } template<class T, class Arg> inline meta_kernel& operator<<(meta_kernel &k, const invoked_convert<T, Arg> &expr) { return k << "convert_" << type_name<T>() << "(" << expr.m_arg << ")"; } template<class T, class Arg> inline meta_kernel& operator<<(meta_kernel &k, const invoked_identity<T, Arg> &expr) { return k << expr.m_arg; } template<> struct inject_type_impl<double_> { void operator()(meta_kernel &kernel) { kernel.add_extension_pragma("cl_khr_fp64", "enable"); } }; template<class Scalar, size_t N> struct inject_type_impl<vector_type<Scalar, N> > { void operator()(meta_kernel &kernel) { kernel.inject_type<Scalar>(); } }; } // end detail namespace } // end compute namespace } // end boost namespace #endif // BOOST_COMPUTE_DETAIL_META_KERNEL_HPP PK��iX!\9)��mpl_vector_to_tuple.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_MPL_VECTOR_TO_TUPLE_HPP #define BOOST_COMPUTE_DETAIL_MPL_VECTOR_TO_TUPLE_HPP #include <boost/mpl/copy.hpp> #include <boost/mpl/vector.hpp> #include <boost/tuple/tuple.hpp> #include <boost/fusion/include/mpl.hpp> #include <boost/fusion/adapted/boost_tuple.hpp> #include <boost/preprocessor/repetition.hpp> #include <boost/compute/config.hpp> namespace boost { namespace compute { namespace detail { namespace mpl = boost::mpl; template<class Vector, size_t N> struct mpl_vector_to_tuple_impl; #define BOOST_COMPUTE_PRINT_ELEM(z, n, unused) \ typename mpl::at_c<Vector, n>::type #define BOOST_COMPUTE_VEC2TUP(z, n, unused) \ template<class Vector> \ struct mpl_vector_to_tuple_impl<Vector, n> \ { \ typedef typename \ boost::tuple< \ BOOST_PP_ENUM(n, BOOST_COMPUTE_PRINT_ELEM, ~) \ > type; \ }; BOOST_PP_REPEAT_FROM_TO(1, BOOST_COMPUTE_MAX_ARITY, BOOST_COMPUTE_VEC2TUP, ~) #undef BOOST_COMPUTE_VEC2TUP #undef BOOST_COMPUTE_PRINT_ELEM // meta-function which converts a mpl::vector to a boost::tuple template<class Vector> struct mpl_vector_to_tuple { typedef typename mpl_vector_to_tuple_impl< Vector, mpl::size<Vector>::value >::type type; }; } // end detail namespace } // end compute namespace } // end boost namespace #endif // BOOST_COMPUTE_DETAIL_MPL_VECTOR_TO_TUPLE_HPP PK��iX!\��b��nvidia_compute_capability.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_NVIDIA_COMPUTE_CAPABILITY_HPP #define BOOST_COMPUTE_DETAIL_NVIDIA_COMPUTE_CAPABILITY_HPP #include <boost/compute/device.hpp> #ifdef BOOST_COMPUTE_HAVE_HDR_CL_EXT #include <boost/compute/detail/cl_versions.hpp> #include <CL/cl_ext.h> #endif namespace boost { namespace compute { namespace detail { #ifdef CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV #define BOOST_COMPUTE_CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV #else #define BOOST_COMPUTE_CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000 #endif #ifdef CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV #define BOOST_COMPUTE_CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV #else #define BOOST_COMPUTE_CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001 #endif inline void get_nvidia_compute_capability(const device &device, int &major, int &minor) { if(!device.supports_extension("cl_nv_device_attribute_query")){ major = minor = 0; return; } major = device.get_info<uint_>(BOOST_COMPUTE_CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV); minor = device.get_info<uint_>(BOOST_COMPUTE_CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV); } inline bool check_nvidia_compute_capability(const device &device, int major, int minor) { int actual_major, actual_minor; get_nvidia_compute_capability(device, actual_major, actual_minor); return actual_major > major \|\| (actual_major == major && actual_minor >= minor); } } // end detail namespace } // end compute namespace } // end boost namespace #endif // BOOST_COMPUTE_DETAIL_NVIDIA_COMPUTE_CAPABILITY_HPP PK��iX!\��/F��is_buffer_iterator.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_IS_BUFFER_ITERATOR_HPP #define BOOST_COMPUTE_DETAIL_IS_BUFFER_ITERATOR_HPP #include <boost/config.hpp> #include <boost/type_traits.hpp> #include <boost/utility/enable_if.hpp> namespace boost { namespace compute { namespace detail { // default = false template<class Iterator, class Enable = void> struct is_buffer_iterator : public boost::false_type {}; } // end detail namespace } // end compute namespace } // end boost namespace #endif // BOOST_COMPUTE_DETAIL_IS_BUFFER_ITERATOR_HPP PK��iX!\U6� �� print_range.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_PRINT_RANGE_HPP #define BOOST_COMPUTE_DETAIL_PRINT_RANGE_HPP #include <vector> #include <iostream> #include <iterator> #include <boost/compute/algorithm/copy.hpp> #include <boost/compute/container/vector.hpp> #include <boost/compute/detail/is_buffer_iterator.hpp> #include <boost/compute/detail/iterator_range_size.hpp> namespace boost { namespace compute { namespace detail { template<class InputIterator> inline void print_range(InputIterator first, InputIterator last, command_queue &queue, typename boost::enable_if< is_buffer_iterator<InputIterator> >::type = 0) { typedef typename std::iterator_traits<InputIterator>::value_type value_type; const size_t size = iterator_range_size(first, last); // copy values to temporary vector on the host std::vector<value_type> tmp(size); ::boost::compute::copy(first, last, tmp.begin(), queue); // print values std::cout << "[ "; for(size_t i = 0; i < size; i++){ std::cout << tmp[i]; if(i != size - 1){ std::cout << ", "; } } std::cout << " ]" << std::endl; } template<class InputIterator> inline void print_range(InputIterator first, InputIterator last, command_queue &queue, typename boost::enable_if_c< !is_buffer_iterator<InputIterator>::value >::type* = 0) { typedef typename std::iterator_traits<InputIterator>::value_type value_type; const context &context = queue.get_context(); const size_t size = iterator_range_size(first, last); // copy values to temporary vector on the device ::boost::compute::vector<value_type> tmp(size, context); ::boost::compute::copy(first, last, tmp.begin(), queue); print_range(tmp.begin(), tmp.end(), queue); } } // end detail namespace } // end compute namespace } // end boost namespace #endif // BOOST_COMPUTE_DETAIL_PRINT_RANGE_HPP PK��iX!\9zrS��S��assert_cl_success.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_ASSERT_CL_SUCCESS_HPP #define BOOST_COMPUTE_DETAIL_ASSERT_CL_SUCCESS_HPP #include <boost/assert.hpp> #if defined(BOOST_DISABLE_ASSERTS) \|\| defined(NDEBUG) #define BOOST_COMPUTE_ASSERT_CL_SUCCESS(function) \ function #else #define BOOST_COMPUTE_ASSERT_CL_SUCCESS(function) \ BOOST_ASSERT(function == CL_SUCCESS) #endif #endif // BOOST_COMPUTE_DETAIL_ASSERT_CL_SUCCESS_HPP PK��iX!\��:��:��cl_versions.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2018 Jakub Szuppe <j.szuppe@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_CL_VERSION_HPP #define BOOST_COMPUTE_DETAIL_CL_VERSION_HPP #if defined(BOOST_COMPUTE_MAX_CL_VERSION) # if !defined(CL_USE_DEPRECATED_OPENCL_2_1_APIS) && BOOST_COMPUTE_MAX_CL_VERSION < 202 # define CL_USE_DEPRECATED_OPENCL_2_1_APIS # endif # if !defined(CL_USE_DEPRECATED_OPENCL_2_0_APIS) && BOOST_COMPUTE_MAX_CL_VERSION < 201 # define CL_USE_DEPRECATED_OPENCL_2_0_APIS # endif # if !defined(CL_USE_DEPRECATED_OPENCL_1_2_APIS) && BOOST_COMPUTE_MAX_CL_VERSION < 200 # define CL_USE_DEPRECATED_OPENCL_1_2_APIS # endif # if !defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS) && BOOST_COMPUTE_MAX_CL_VERSION < 102 # define CL_USE_DEPRECATED_OPENCL_1_1_APIS # endif # if !defined(CL_USE_DEPRECATED_OPENCL_1_0_APIS) && BOOST_COMPUTE_MAX_CL_VERSION < 101 # define CL_USE_DEPRECATED_OPENCL_1_0_APIS # endif #endif #if defined(BOOST_COMPUTE_MAX_CL_VERSION) && !defined(CL_TARGET_OPENCL_VERSION) # if BOOST_COMPUTE_MAX_CL_VERSION == 201 # define CL_TARGET_OPENCL_VERSION 210 # elif BOOST_COMPUTE_MAX_CL_VERSION == 200 # define CL_TARGET_OPENCL_VERSION 200 # elif BOOST_COMPUTE_MAX_CL_VERSION == 102 # define CL_TARGET_OPENCL_VERSION 120 # elif BOOST_COMPUTE_MAX_CL_VERSION == 101 # define CL_TARGET_OPENCL_VERSION 110 # elif BOOST_COMPUTE_MAX_CL_VERSION == 100 # define CL_TARGET_OPENCL_VERSION 100 # else # define CL_TARGET_OPENCL_VERSION 220 # endif #endif #if defined(BOOST_COMPUTE_MAX_CL_VERSION) && defined(CL_TARGET_OPENCL_VERSION) # if BOOST_COMPUTE_MAX_CL_VERSION == 202 && CL_TARGET_OPENCL_VERSION != 220 # error "Boost.Compute: CL_TARGET_OPENCL_VERSION definition does not match BOOST_COMPUTE_MAX_CL_VERSION" # elif BOOST_COMPUTE_MAX_CL_VERSION == 201 && CL_TARGET_OPENCL_VERSION != 210 # error "Boost.Compute: CL_TARGET_OPENCL_VERSION definition does not match BOOST_COMPUTE_MAX_CL_VERSION" # elif BOOST_COMPUTE_MAX_CL_VERSION == 200 && CL_TARGET_OPENCL_VERSION != 200 # error "Boost.Compute: CL_TARGET_OPENCL_VERSION definition does not match BOOST_COMPUTE_MAX_CL_VERSION" # elif BOOST_COMPUTE_MAX_CL_VERSION == 102 && CL_TARGET_OPENCL_VERSION != 120 # error "Boost.Compute: CL_TARGET_OPENCL_VERSION definition does not match BOOST_COMPUTE_MAX_CL_VERSION" # elif BOOST_COMPUTE_MAX_CL_VERSION == 101 && CL_TARGET_OPENCL_VERSION != 110 # error "Boost.Compute: CL_TARGET_OPENCL_VERSION definition does not match BOOST_COMPUTE_MAX_CL_VERSION" # elif BOOST_COMPUTE_MAX_CL_VERSION == 100 && CL_TARGET_OPENCL_VERSION != 100 # error "Boost.Compute: CL_TARGET_OPENCL_VERSION definition does not match BOOST_COMPUTE_MAX_CL_VERSION" # endif #endif #endif // BOOST_COMPUTE_DETAIL_CL_VERSION_HPP PK��iX!\�R�� getenv.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_GETENV_HPP #define BOOST_COMPUTE_DETAIL_GETENV_HPP #include <cstdlib> namespace boost { namespace compute { namespace detail { inline const char getenv(const char env_var) { #ifdef _MSC_VER # pragma warning(push) # pragma warning(disable: 4996) #endif return std::getenv(env_var); #ifdef _MSC_VER # pragma warning(pop) #endif } } // end detail namespace } // end compute namespace } // end boost namespace #endif // BOOST_COMPUTE_DETAIL_GETENV_HPP PK��iX!\�g�� read_write_single_value.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_READ_WRITE_SINGLE_VALUE_HPP #define BOOST_COMPUTE_DETAIL_READ_WRITE_SINGLE_VALUE_HPP #include <boost/throw_exception.hpp> #include <boost/compute/buffer.hpp> #include <boost/compute/event.hpp> #include <boost/compute/exception.hpp> #include <boost/compute/command_queue.hpp> namespace boost { namespace compute { namespace detail { // reads and returns a single value at index in the buffer template<class T> inline T read_single_value(const buffer &buffer, size_t index, command_queue &queue) { BOOST_ASSERT(index < buffer.size() / sizeof(T)); BOOST_ASSERT(buffer.get_context() == queue.get_context()); T value; queue.enqueue_read_buffer(buffer, sizeof(T) index, sizeof(T), &value); return value; } // reads and returns a the first value in the buffer template<class T> inline T read_single_value(const buffer &buffer, command_queue &queue) { return read_single_value<T>(buffer, 0, queue); } // writes a single value at index to the buffer template<class T> inline event write_single_value(const T &value, const buffer &buffer, size_t index, command_queue &queue) { BOOST_ASSERT(index < buffer.size() / sizeof(T)); BOOST_ASSERT(buffer.get_context() == queue.get_context()); return queue.enqueue_write_buffer(buffer, index * sizeof(T), sizeof(T), &value); } // writes value to the first location in buffer template<class T> inline void write_single_value(const T &value, const buffer &buffer, command_queue &queue) { write_single_value<T>(value, buffer, 0, queue); } } // end detail namespace } // end compute namespace } // end boost namespace #endif // BOOST_COMPUTE_DETAIL_READ_WRITE_SINGLE_VALUE_HPP PK��iX!\�P��literal.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_LITERAL_HPP #define BOOST_COMPUTE_DETAIL_LITERAL_HPP #include <iomanip> #include <limits> #include <sstream> #include <boost/type_traits/is_same.hpp> #include <boost/compute/types/fundamental.hpp> namespace boost { namespace compute { namespace detail { template<class T> std::string make_literal(T x) { std::stringstream s; s << std::setprecision( #ifndef BOOST_NO_CXX11_NUMERIC_LIMITS std::numeric_limits<T>::max_digits10 #else // We don't have max_digits10, so add 3 other digits (this is what is required for // float, and is one more than required for double). 3 + std::numeric_limits<T>::digits10 #endif ) << std::scientific << x; if(boost::is_same<T, float>::value \|\| boost::is_same<T, float_>::value){ s << "f"; } return s.str(); } } // end detail namespace } // end compute namespace } // end boost namespace #endif // BOOST_COMPUTE_DETAIL_LITERAL_HPP PK��iX!\��W��parameter_cache.hppnu��[��//---------------------------------------------------------------------------// // Copyright (c) 2013-2015 Kyle Lutz <kyle.r.lutz@gmail.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 // // See http://boostorg.github.com/compute for more information. //---------------------------------------------------------------------------// #ifndef BOOST_COMPUTE_DETAIL_PARAMETER_CACHE_HPP #define BOOST_COMPUTE_DETAIL_PARAMETER_CACHE_HPP #include <algorithm> #include <string> #include <boost/shared_ptr.hpp> #include <boost/make_shared.hpp> #include <boost/noncopyable.hpp> #include <boost/compute/config.hpp> #include <boost/compute/device.hpp> #include <boost/compute/detail/global_static.hpp> #include <boost/compute/version.hpp> #ifdef BOOST_COMPUTE_USE_OFFLINE_CACHE #include <cstdio> #include <boost/algorithm/string/trim.hpp> #include <boost/compute/detail/path.hpp> #include <boost/property_tree/ptree.hpp> #include <boost/property_tree/json_parser.hpp> #endif // BOOST_COMPUTE_USE_OFFLINE_CACHE namespace boost { namespace compute { namespace detail { class parameter_cache : boost::noncopyable { public: parameter_cache(const device &device) : m_dirty(false), m_device_name(device.name()) { #ifdef BOOST_COMPUTE_USE_OFFLINE_CACHE // get offline cache file name (e.g. /home/user/.boost_compute/tune/device.json) m_file_name = make_file_name(); // load parameters from offline cache file (if it exists) if(boost::filesystem::exists(m_file_name)){ read_from_disk(); } #endif // BOOST_COMPUTE_USE_OFFLINE_CACHE } ~parameter_cache() { #ifdef BOOST_COMPUTE_USE_OFFLINE_CACHE write_to_disk(); #endif // BOOST_COMPUTE_USE_OFFLINE_CACHE } void set(const std::string &object, const std::string &parameter, uint_ value) { m_cache[std::make_pair(object, parameter)] = value; // set the dirty flag to true. this will cause the updated parameters // to be stored to disk. m_dirty = true; } uint_ get(const std::string &object, const std::string &parameter, uint_ default_value) { std::map<std::pair<std::string, std::string>, uint_>::iterator iter = m_cache.find(std::make_pair(object, parameter)); if(iter != m_cache.end()){ return iter->second; } else { return default_value; } } static boost::shared_ptr<parameter_cache> get_global_cache(const device &device) { // device name -> parameter cache typedef std::map<std::string, boost::shared_ptr<parameter_cache> > cache_map; BOOST_COMPUTE_DETAIL_GLOBAL_STATIC(cache_map, caches, ((std::less<std::string>()))); cache_map::iterator iter = caches.find(device.name()); if(iter == caches.end()){ boost::shared_ptr<parameter_cache> cache = boost::make_shared<parameter_cache>(device); caches.insert(iter, std::make_pair(device.name(), cache)); return cache; } else { return iter->second; } } private: #ifdef BOOST_COMPUTE_USE_OFFLINE_CACHE // returns a string containing a cannoical device name static std::string cannonical_device_name(std::string name) { boost::algorithm::trim(name); std::replace(name.begin(), name.end(), ' ', '_'); std::replace(name.begin(), name.end(), '(', '_'); std::replace(name.begin(), name.end(), ')', '_'); return name; } // returns the boost.compute version string static std::string version_string() { char buf[32]; // snprintf is in Visual Studio since Visual Studio 2015 (_MSC_VER == 1900) #if defined (_MSC_VER) && _MSC_VER < 1900 #define DETAIL_SNPRINTF sprintf_s #else #define DETAIL_SNPRINTF std::snprintf #endif DETAIL_SNPRINTF(buf, sizeof(buf), "%d.%d.%d", BOOST_COMPUTE_VERSION_MAJOR, BOOST_COMPUTE_VERSION_MINOR, BOOST_COMPUTE_VERSION_PATCH); #undef DETAIL_SNPRINTF return buf; } // returns the file path for the cached parameters std::string make_file_name() const { return detail::parameter_cache_path(true) + cannonical_device_name(m_device_name) + ".json"; } // store current parameters to disk void write_to_disk() { BOOST_ASSERT(!m_file_name.empty()); if(m_dirty){ // save current parameters to disk boost::property_tree::ptree pt; pt.put("header.device", m_device_name); pt.put("header.version", version_string()); typedef std::map<std::pair<std::string, std::string>, uint_> map_type; for(map_type::const_iterator iter = m_cache.begin(); iter != m_cache.end(); ++iter){ const std::pair<std::string, std::string> &key = iter->first; pt.add(key.first + "." + key.second, iter->second); } write_json(m_file_name, pt); m_dirty = false; } } // load stored parameters from disk void read_from_disk() { BOOST_ASSERT(!m_file_name.empty()); m_cache.clear(); boost::property_tree::ptree pt; try { read_json(m_file_name, pt); } catch(boost::property_tree::json_parser::json_parser_error&){ // no saved cache file, ignore return; } std::string stored_device; try { stored_device = pt.get<std::string>("header.device"); } catch(boost::property_tree::ptree_bad_path&){ return; } std::string stored_version; try { stored_version = pt.get<std::string>("header.version"); } catch(boost::property_tree::ptree_bad_path&){ return; } if(stored_device == m_device_name && stored_version == version_string()){ typedef boost::property_tree::ptree::const_iterator pt_iter; for(pt_iter iter = pt.begin(); iter != pt.end(); ++iter){ if(iter->first == "header"){ // skip header continue; } boost::property_tree::ptree child_pt = pt.get_child(iter->first); for(pt_iter child_iter = child_pt.begin(); child_iter != child_pt.end(); ++child_iter){ set(iter->first, child_iter->first, boost::lexical_cast<uint_>(child_iter->second.data())); } } } m_dirty = false; } #endif // BOOST_COMPUTE_USE_OFFLINE_CACHE private: bool m_dirty; std::string m_device_name; std::string m_file_name; std::map<std::pair<std::string, std::string>, uint_> m_cache; }; } // end detail namespace } // end compute namespace } // end boost namespace #endif // BOOST_COMPUTE_DETAIL_PARAMETER_CACHE_HPP PK��h!\p� �� gcc_x86_fenced_block.hppnu��[��// // detail/gcc_x86_fenced_block.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_GCC_X86_FENCED_BLOCK_HPP #define BOOST_ASIO_DETAIL_GCC_X86_FENCED_BLOCK_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(__GNUC__) && (defined(__i386__) \|\| defined(__x86_64__)) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class gcc_x86_fenced_block : private noncopyable { public: enum half_t { half }; enum full_t { full }; // Constructor for a half fenced block. explicit gcc_x86_fenced_block(half_t) { } // Constructor for a full fenced block. explicit gcc_x86_fenced_block(full_t) { lbarrier(); } // Destructor. ~gcc_x86_fenced_block() { sbarrier(); } private: static int barrier() { int r = 0, m = 1; __asm__ __volatile__ ( "xchgl %0, %1" : "=r"(r), "=m"(m) : "0"(1), "m"(m) : "memory", "cc"); return r; } static void lbarrier() { #if defined(__SSE2__) # if (__GNUC__ >= 4) && !defined(__INTEL_COMPILER) && !defined(__ICL) __builtin_ia32_lfence(); # else // (__GNUC__ >= 4) && !defined(__INTEL_COMPILER) && !defined(__ICL) __asm__ __volatile__ ("lfence" ::: "memory"); # endif // (__GNUC__ >= 4) && !defined(__INTEL_COMPILER) && !defined(__ICL) #else // defined(__SSE2__) barrier(); #endif // defined(__SSE2__) } static void sbarrier() { #if defined(__SSE2__) # if (__GNUC__ >= 4) && !defined(__INTEL_COMPILER) && !defined(__ICL) __builtin_ia32_sfence(); # else // (__GNUC__ >= 4) && !defined(__INTEL_COMPILER) && !defined(__ICL) __asm__ __volatile__ ("sfence" ::: "memory"); # endif // (__GNUC__ >= 4) && !defined(__INTEL_COMPILER) && !defined(__ICL) #else // defined(__SSE2__) barrier(); #endif // defined(__SSE2__) } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(__GNUC__) && (defined(__i386__) \|\| defined(__x86_64__)) #endif // BOOST_ASIO_DETAIL_GCC_X86_FENCED_BLOCK_HPP PK��h!\4~��&��&��wrapped_handler.hppnu��[��// // detail/wrapped_handler.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WRAPPED_HANDLER_HPP #define BOOST_ASIO_DETAIL_WRAPPED_HANDLER_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_cont_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { struct is_continuation_delegated { template <typename Dispatcher, typename Handler> bool operator()(Dispatcher&, Handler& handler) const { return boost_asio_handler_cont_helpers::is_continuation(handler); } }; struct is_continuation_if_running { template <typename Dispatcher, typename Handler> bool operator()(Dispatcher& dispatcher, Handler&) const { return dispatcher.running_in_this_thread(); } }; template <typename Dispatcher, typename Handler, typename IsContinuation = is_continuation_delegated> class wrapped_handler { public: typedef void result_type; wrapped_handler(Dispatcher dispatcher, Handler& handler) : dispatcher_(dispatcher), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)) { } #if defined(BOOST_ASIO_HAS_MOVE) wrapped_handler(const wrapped_handler& other) : dispatcher_(other.dispatcher_), handler_(other.handler_) { } wrapped_handler(wrapped_handler&& other) : dispatcher_(other.dispatcher_), handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_)) { } #endif // defined(BOOST_ASIO_HAS_MOVE) void operator()() { dispatcher_.dispatch(BOOST_ASIO_MOVE_CAST(Handler)(handler_)); } void operator()() const { dispatcher_.dispatch(handler_); } template <typename Arg1> void operator()(const Arg1& arg1) { dispatcher_.dispatch(detail::bind_handler(handler_, arg1)); } template <typename Arg1> void operator()(const Arg1& arg1) const { dispatcher_.dispatch(detail::bind_handler(handler_, arg1)); } template <typename Arg1, typename Arg2> void operator()(const Arg1& arg1, const Arg2& arg2) { dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2)); } template <typename Arg1, typename Arg2> void operator()(const Arg1& arg1, const Arg2& arg2) const { dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2)); } template <typename Arg1, typename Arg2, typename Arg3> void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3) { dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2, arg3)); } template <typename Arg1, typename Arg2, typename Arg3> void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3) const { dispatcher_.dispatch(detail::bind_handler(handler_, arg1, arg2, arg3)); } template <typename Arg1, typename Arg2, typename Arg3, typename Arg4> void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4) { dispatcher_.dispatch( detail::bind_handler(handler_, arg1, arg2, arg3, arg4)); } template <typename Arg1, typename Arg2, typename Arg3, typename Arg4> void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4) const { dispatcher_.dispatch( detail::bind_handler(handler_, arg1, arg2, arg3, arg4)); } template <typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5> void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5) { dispatcher_.dispatch( detail::bind_handler(handler_, arg1, arg2, arg3, arg4, arg5)); } template <typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5> void operator()(const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5) const { dispatcher_.dispatch( detail::bind_handler(handler_, arg1, arg2, arg3, arg4, arg5)); } //private: Dispatcher dispatcher_; Handler handler_; }; template <typename Handler, typename Context> class rewrapped_handler { public: explicit rewrapped_handler(Handler& handler, const Context& context) : context_(context), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)) { } explicit rewrapped_handler(const Handler& handler, const Context& context) : context_(context), handler_(handler) { } #if defined(BOOST_ASIO_HAS_MOVE) rewrapped_handler(const rewrapped_handler& other) : context_(other.context_), handler_(other.handler_) { } rewrapped_handler(rewrapped_handler&& other) : context_(BOOST_ASIO_MOVE_CAST(Context)(other.context_)), handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_)) { } #endif // defined(BOOST_ASIO_HAS_MOVE) void operator()() { handler_(); } void operator()() const { handler_(); } //private: Context context_; Handler handler_; }; template <typename Dispatcher, typename Handler, typename IsContinuation> inline asio_handler_allocate_is_deprecated asio_handler_allocate(std::size_t size, wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler) { #if defined(BOOST_ASIO_NO_DEPRECATED) boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_); return asio_handler_allocate_is_no_longer_used(); #else // defined(BOOST_ASIO_NO_DEPRECATED) return boost_asio_handler_alloc_helpers::allocate( size, this_handler->handler_); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Dispatcher, typename Handler, typename IsContinuation> inline asio_handler_deallocate_is_deprecated asio_handler_deallocate(void* pointer, std::size_t size, wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler) { boost_asio_handler_alloc_helpers::deallocate( pointer, size, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_deallocate_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Dispatcher, typename Handler, typename IsContinuation> inline bool asio_handler_is_continuation( wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler) { return IsContinuation()(this_handler->dispatcher_, this_handler->handler_); } template <typename Function, typename Dispatcher, typename Handler, typename IsContinuation> inline asio_handler_invoke_is_deprecated asio_handler_invoke(Function& function, wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler) { this_handler->dispatcher_.dispatch( rewrapped_handler<Function, Handler>( function, this_handler->handler_)); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Function, typename Dispatcher, typename Handler, typename IsContinuation> inline asio_handler_invoke_is_deprecated asio_handler_invoke(const Function& function, wrapped_handler<Dispatcher, Handler, IsContinuation>* this_handler) { this_handler->dispatcher_.dispatch( rewrapped_handler<Function, Handler>( function, this_handler->handler_)); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Handler, typename Context> inline asio_handler_allocate_is_deprecated asio_handler_allocate(std::size_t size, rewrapped_handler<Handler, Context>* this_handler) { #if defined(BOOST_ASIO_NO_DEPRECATED) boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_); return asio_handler_allocate_is_no_longer_used(); #else // defined(BOOST_ASIO_NO_DEPRECATED) return boost_asio_handler_alloc_helpers::allocate( size, this_handler->handler_); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Handler, typename Context> inline asio_handler_deallocate_is_deprecated asio_handler_deallocate(void* pointer, std::size_t size, rewrapped_handler<Handler, Context>* this_handler) { boost_asio_handler_alloc_helpers::deallocate( pointer, size, this_handler->context_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_deallocate_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Dispatcher, typename Context> inline bool asio_handler_is_continuation( rewrapped_handler<Dispatcher, Context>* this_handler) { return boost_asio_handler_cont_helpers::is_continuation( this_handler->context_); } template <typename Function, typename Handler, typename Context> inline asio_handler_invoke_is_deprecated asio_handler_invoke(Function& function, rewrapped_handler<Handler, Context>* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->context_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Function, typename Handler, typename Context> inline asio_handler_invoke_is_deprecated asio_handler_invoke(const Function& function, rewrapped_handler<Handler, Context>* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->context_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_WRAPPED_HANDLER_HPP PK��h!\��/��base_from_completion_cond.hppnu��[��// // detail/base_from_completion_cond.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_BASE_FROM_COMPLETION_COND_HPP #define BOOST_ASIO_DETAIL_BASE_FROM_COMPLETION_COND_HPP #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/completion_condition.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename CompletionCondition> class base_from_completion_cond { protected: explicit base_from_completion_cond(CompletionCondition& completion_condition) : completion_condition_( BOOST_ASIO_MOVE_CAST(CompletionCondition)(completion_condition)) { } std::size_t check_for_completion( const boost::system::error_code& ec, std::size_t total_transferred) { return detail::adapt_completion_condition_result( completion_condition_(ec, total_transferred)); } private: CompletionCondition completion_condition_; }; template <> class base_from_completion_cond<transfer_all_t> { protected: explicit base_from_completion_cond(transfer_all_t) { } static std::size_t check_for_completion( const boost::system::error_code& ec, std::size_t total_transferred) { return transfer_all_t()(ec, total_transferred); } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_BASE_FROM_COMPLETION_COND_HPP PK��h!\��ȏ�$��$��epoll_reactor.hppnu��[��// // detail/epoll_reactor.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_EPOLL_REACTOR_HPP #define BOOST_ASIO_DETAIL_EPOLL_REACTOR_HPP #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_HAS_EPOLL) #include <boost/asio/detail/atomic_count.hpp> #include <boost/asio/detail/conditionally_enabled_mutex.hpp> #include <boost/asio/detail/limits.hpp> #include <boost/asio/detail/object_pool.hpp> #include <boost/asio/detail/op_queue.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/select_interrupter.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/timer_queue_base.hpp> #include <boost/asio/detail/timer_queue_set.hpp> #include <boost/asio/detail/wait_op.hpp> #include <boost/asio/execution_context.hpp> #if defined(BOOST_ASIO_HAS_TIMERFD) # include <sys/timerfd.h> #endif // defined(BOOST_ASIO_HAS_TIMERFD) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class epoll_reactor : public execution_context_service_base<epoll_reactor> { private: // The mutex type used by this reactor. typedef conditionally_enabled_mutex mutex; public: enum op_types { read_op = 0, write_op = 1, connect_op = 1, except_op = 2, max_ops = 3 }; // Per-descriptor queues. class descriptor_state : operation { friend class epoll_reactor; friend class object_pool_access; descriptor_state* next_; descriptor_state* prev_; mutex mutex_; epoll_reactor* reactor_; int descriptor_; uint32_t registered_events_; op_queue<reactor_op> op_queue_[max_ops]; bool try_speculative_[max_ops]; bool shutdown_; BOOST_ASIO_DECL descriptor_state(bool locking); void set_ready_events(uint32_t events) { task_result_ = events; } void add_ready_events(uint32_t events) { task_result_ \|= events; } BOOST_ASIO_DECL operation* perform_io(uint32_t events); BOOST_ASIO_DECL static void do_complete( void* owner, operation* base, const boost::system::error_code& ec, std::size_t bytes_transferred); }; // Per-descriptor data. typedef descriptor_state* per_descriptor_data; // Constructor. BOOST_ASIO_DECL epoll_reactor(boost::asio::execution_context& ctx); // Destructor. BOOST_ASIO_DECL ~epoll_reactor(); // Destroy all user-defined handler objects owned by the service. BOOST_ASIO_DECL void shutdown(); // Recreate internal descriptors following a fork. BOOST_ASIO_DECL void notify_fork( boost::asio::execution_context::fork_event fork_ev); // Initialise the task. BOOST_ASIO_DECL void init_task(); // Register a socket with the reactor. Returns 0 on success, system error // code on failure. BOOST_ASIO_DECL int register_descriptor(socket_type descriptor, per_descriptor_data& descriptor_data); // Register a descriptor with an associated single operation. Returns 0 on // success, system error code on failure. BOOST_ASIO_DECL int register_internal_descriptor( int op_type, socket_type descriptor, per_descriptor_data& descriptor_data, reactor_op* op); // Move descriptor registration from one descriptor_data object to another. BOOST_ASIO_DECL void move_descriptor(socket_type descriptor, per_descriptor_data& target_descriptor_data, per_descriptor_data& source_descriptor_data); // Post a reactor operation for immediate completion. void post_immediate_completion(reactor_op* op, bool is_continuation) { scheduler_.post_immediate_completion(op, is_continuation); } // Start a new operation. The reactor operation will be performed when the // given descriptor is flagged as ready, or an error has occurred. BOOST_ASIO_DECL void start_op(int op_type, socket_type descriptor, per_descriptor_data& descriptor_data, reactor_op* op, bool is_continuation, bool allow_speculative); // Cancel all operations associated with the given descriptor. The // handlers associated with the descriptor will be invoked with the // operation_aborted error. BOOST_ASIO_DECL void cancel_ops(socket_type descriptor, per_descriptor_data& descriptor_data); // Cancel any operations that are running against the descriptor and remove // its registration from the reactor. The reactor resources associated with // the descriptor must be released by calling cleanup_descriptor_data. BOOST_ASIO_DECL void deregister_descriptor(socket_type descriptor, per_descriptor_data& descriptor_data, bool closing); // Remove the descriptor's registration from the reactor. The reactor // resources associated with the descriptor must be released by calling // cleanup_descriptor_data. BOOST_ASIO_DECL void deregister_internal_descriptor( socket_type descriptor, per_descriptor_data& descriptor_data); // Perform any post-deregistration cleanup tasks associated with the // descriptor data. BOOST_ASIO_DECL void cleanup_descriptor_data( per_descriptor_data& descriptor_data); // Add a new timer queue to the reactor. template <typename Time_Traits> void add_timer_queue(timer_queue<Time_Traits>& timer_queue); // Remove a timer queue from the reactor. template <typename Time_Traits> void remove_timer_queue(timer_queue<Time_Traits>& timer_queue); // Schedule a new operation in the given timer queue to expire at the // specified absolute time. template <typename Time_Traits> void schedule_timer(timer_queue<Time_Traits>& queue, const typename Time_Traits::time_type& time, typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op); // Cancel the timer operations associated with the given token. Returns the // number of operations that have been posted or dispatched. template <typename Time_Traits> std::size_t cancel_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& timer, std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)()); // Move the timer operations associated with the given timer. template <typename Time_Traits> void move_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& target, typename timer_queue<Time_Traits>::per_timer_data& source); // Run epoll once until interrupted or events are ready to be dispatched. BOOST_ASIO_DECL void run(long usec, op_queue<operation>& ops); // Interrupt the select loop. BOOST_ASIO_DECL void interrupt(); private: // The hint to pass to epoll_create to size its data structures. enum { epoll_size = 20000 }; // Create the epoll file descriptor. Throws an exception if the descriptor // cannot be created. BOOST_ASIO_DECL static int do_epoll_create(); // Create the timerfd file descriptor. Does not throw. BOOST_ASIO_DECL static int do_timerfd_create(); // Allocate a new descriptor state object. BOOST_ASIO_DECL descriptor_state* allocate_descriptor_state(); // Free an existing descriptor state object. BOOST_ASIO_DECL void free_descriptor_state(descriptor_state* s); // Helper function to add a new timer queue. BOOST_ASIO_DECL void do_add_timer_queue(timer_queue_base& queue); // Helper function to remove a timer queue. BOOST_ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue); // Called to recalculate and update the timeout. BOOST_ASIO_DECL void update_timeout(); // Get the timeout value for the epoll_wait call. The timeout value is // returned as a number of milliseconds. A return value of -1 indicates // that epoll_wait should block indefinitely. BOOST_ASIO_DECL int get_timeout(int msec); #if defined(BOOST_ASIO_HAS_TIMERFD) // Get the timeout value for the timer descriptor. The return value is the // flag argument to be used when calling timerfd_settime. BOOST_ASIO_DECL int get_timeout(itimerspec& ts); #endif // defined(BOOST_ASIO_HAS_TIMERFD) // The scheduler implementation used to post completions. scheduler& scheduler_; // Mutex to protect access to internal data. mutex mutex_; // The interrupter is used to break a blocking epoll_wait call. select_interrupter interrupter_; // The epoll file descriptor. int epoll_fd_; // The timer file descriptor. int timer_fd_; // The timer queues. timer_queue_set timer_queues_; // Whether the service has been shut down. bool shutdown_; // Mutex to protect access to the registered descriptors. mutex registered_descriptors_mutex_; // Keep track of all registered descriptors. object_pool<descriptor_state> registered_descriptors_; // Helper class to do post-perform_io cleanup. struct perform_io_cleanup_on_block_exit; friend struct perform_io_cleanup_on_block_exit; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #include <boost/asio/detail/impl/epoll_reactor.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/epoll_reactor.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_HAS_EPOLL) #endif // BOOST_ASIO_DETAIL_EPOLL_REACTOR_HPP PK��h!\�$w��posix_fd_set_adapter.hppnu��[��// // detail/posix_fd_set_adapter.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_POSIX_FD_SET_ADAPTER_HPP #define BOOST_ASIO_DETAIL_POSIX_FD_SET_ADAPTER_HPP #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_WINDOWS) \ && !defined(__CYGWIN__) \ && !defined(BOOST_ASIO_WINDOWS_RUNTIME) #include <cstring> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/reactor_op_queue.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { // Adapts the FD_SET type to meet the Descriptor_Set concept's requirements. class posix_fd_set_adapter : noncopyable { public: posix_fd_set_adapter() : max_descriptor_(invalid_socket) { using namespace std; // Needed for memset on Solaris. FD_ZERO(&fd_set_); } void reset() { using namespace std; // Needed for memset on Solaris. FD_ZERO(&fd_set_); } bool set(socket_type descriptor) { if (descriptor < (socket_type)FD_SETSIZE) { if (max_descriptor_ == invalid_socket \|\| descriptor > max_descriptor_) max_descriptor_ = descriptor; FD_SET(descriptor, &fd_set_); return true; } return false; } void set(reactor_op_queue<socket_type>& operations, op_queue<operation>& ops) { reactor_op_queue<socket_type>::iterator i = operations.begin(); while (i != operations.end()) { reactor_op_queue<socket_type>::iterator op_iter = i++; if (!set(op_iter->first)) { boost::system::error_code ec(error::fd_set_failure); operations.cancel_operations(op_iter, ops, ec); } } } bool is_set(socket_type descriptor) const { return FD_ISSET(descriptor, &fd_set_) != 0; } operator fd_set() { return &fd_set_; } socket_type max_descriptor() const { return max_descriptor_; } void perform(reactor_op_queue<socket_type>& operations, op_queue<operation>& ops) const { reactor_op_queue<socket_type>::iterator i = operations.begin(); while (i != operations.end()) { reactor_op_queue<socket_type>::iterator op_iter = i++; if (is_set(op_iter->first)) operations.perform_operations(op_iter, ops); } } private: mutable fd_set fd_set_; socket_type max_descriptor_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // !defined(BOOST_ASIO_WINDOWS) // && !defined(__CYGWIN__) // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_POSIX_FD_SET_ADAPTER_HPP PK��h!\��(��(�� win_mutex.hppnu��[��// // detail/win_mutex.hpp // ~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_MUTEX_HPP #define BOOST_ASIO_DETAIL_WIN_MUTEX_HPP #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_WINDOWS) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/scoped_lock.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class win_mutex : private noncopyable { public: typedef boost::asio::detail::scoped_lock<win_mutex> scoped_lock; // Constructor. BOOST_ASIO_DECL win_mutex(); // Destructor. ~win_mutex() { ::DeleteCriticalSection(&crit_section_); } // Lock the mutex. void lock() { ::EnterCriticalSection(&crit_section_); } // Unlock the mutex. void unlock() { ::LeaveCriticalSection(&crit_section_); } private: // Initialisation must be performed in a separate function to the constructor // since the compiler does not support the use of structured exceptions and // C++ exceptions in the same function. BOOST_ASIO_DECL int do_init(); ::CRITICAL_SECTION crit_section_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/win_mutex.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_WINDOWS) #endif // BOOST_ASIO_DETAIL_WIN_MUTEX_HPP PK��h!\F�mg�C��C��null_socket_service.hppnu��[��// // detail/null_socket_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_NULL_SOCKET_SERVICE_HPP #define BOOST_ASIO_DETAIL_NULL_SOCKET_SERVICE_HPP #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_WINDOWS_RUNTIME) #include <boost/asio/buffer.hpp> #include <boost/asio/error.hpp> #include <boost/asio/execution_context.hpp> #include <boost/asio/post.hpp> #include <boost/asio/socket_base.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Protocol> class null_socket_service : public execution_context_service_base<null_socket_service<Protocol> > { public: // The protocol type. typedef Protocol protocol_type; // The endpoint type. typedef typename Protocol::endpoint endpoint_type; // The native type of a socket. typedef int native_handle_type; // The implementation type of the socket. struct implementation_type { }; // Constructor. null_socket_service(execution_context& context) : execution_context_service_base<null_socket_service<Protocol> >(context) { } // Destroy all user-defined handler objects owned by the service. void shutdown() { } // Construct a new socket implementation. void construct(implementation_type&) { } // Move-construct a new socket implementation. void move_construct(implementation_type&, implementation_type&) { } // Move-assign from another socket implementation. void move_assign(implementation_type&, null_socket_service&, implementation_type&) { } // Move-construct a new socket implementation from another protocol type. template <typename Protocol1> void converting_move_construct(implementation_type&, null_socket_service<Protocol1>&, typename null_socket_service<Protocol1>::implementation_type&) { } // Destroy a socket implementation. void destroy(implementation_type&) { } // Open a new socket implementation. boost::system::error_code open(implementation_type&, const protocol_type&, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return ec; } // Assign a native socket to a socket implementation. boost::system::error_code assign(implementation_type&, const protocol_type&, const native_handle_type&, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return ec; } // Determine whether the socket is open. bool is_open(const implementation_type&) const { return false; } // Destroy a socket implementation. boost::system::error_code close(implementation_type&, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return ec; } // Release ownership of the socket. native_handle_type release(implementation_type&, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return 0; } // Get the native socket representation. native_handle_type native_handle(implementation_type&) { return 0; } // Cancel all operations associated with the socket. boost::system::error_code cancel(implementation_type&, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return ec; } // Determine whether the socket is at the out-of-band data mark. bool at_mark(const implementation_type&, boost::system::error_code& ec) const { ec = boost::asio::error::operation_not_supported; return false; } // Determine the number of bytes available for reading. std::size_t available(const implementation_type&, boost::system::error_code& ec) const { ec = boost::asio::error::operation_not_supported; return 0; } // Place the socket into the state where it will listen for new connections. boost::system::error_code listen(implementation_type&, int, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return ec; } // Perform an IO control command on the socket. template <typename IO_Control_Command> boost::system::error_code io_control(implementation_type&, IO_Control_Command&, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return ec; } // Gets the non-blocking mode of the socket. bool non_blocking(const implementation_type&) const { return false; } // Sets the non-blocking mode of the socket. boost::system::error_code non_blocking(implementation_type&, bool, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return ec; } // Gets the non-blocking mode of the native socket implementation. bool native_non_blocking(const implementation_type&) const { return false; } // Sets the non-blocking mode of the native socket implementation. boost::system::error_code native_non_blocking(implementation_type&, bool, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return ec; } // Disable sends or receives on the socket. boost::system::error_code shutdown(implementation_type&, socket_base::shutdown_type, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return ec; } // Bind the socket to the specified local endpoint. boost::system::error_code bind(implementation_type&, const endpoint_type&, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return ec; } // Set a socket option. template <typename Option> boost::system::error_code set_option(implementation_type&, const Option&, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return ec; } // Set a socket option. template <typename Option> boost::system::error_code get_option(const implementation_type&, Option&, boost::system::error_code& ec) const { ec = boost::asio::error::operation_not_supported; return ec; } // Get the local endpoint. endpoint_type local_endpoint(const implementation_type&, boost::system::error_code& ec) const { ec = boost::asio::error::operation_not_supported; return endpoint_type(); } // Get the remote endpoint. endpoint_type remote_endpoint(const implementation_type&, boost::system::error_code& ec) const { ec = boost::asio::error::operation_not_supported; return endpoint_type(); } // Send the given data to the peer. template <typename ConstBufferSequence> std::size_t send(implementation_type&, const ConstBufferSequence&, socket_base::message_flags, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return 0; } // Wait until data can be sent without blocking. std::size_t send(implementation_type&, const null_buffers&, socket_base::message_flags, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return 0; } // Start an asynchronous send. The data being sent must be valid for the // lifetime of the asynchronous operation. template <typename ConstBufferSequence, typename Handler, typename IoExecutor> void async_send(implementation_type&, const ConstBufferSequence&, socket_base::message_flags, Handler& handler, const IoExecutor& io_ex) { boost::system::error_code ec = boost::asio::error::operation_not_supported; const std::size_t bytes_transferred = 0; boost::asio::post(io_ex, detail::bind_handler( handler, ec, bytes_transferred)); } // Start an asynchronous wait until data can be sent without blocking. template <typename Handler, typename IoExecutor> void async_send(implementation_type&, const null_buffers&, socket_base::message_flags, Handler& handler, const IoExecutor& io_ex) { boost::system::error_code ec = boost::asio::error::operation_not_supported; const std::size_t bytes_transferred = 0; boost::asio::post(io_ex, detail::bind_handler( handler, ec, bytes_transferred)); } // Receive some data from the peer. Returns the number of bytes received. template <typename MutableBufferSequence> std::size_t receive(implementation_type&, const MutableBufferSequence&, socket_base::message_flags, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return 0; } // Wait until data can be received without blocking. std::size_t receive(implementation_type&, const null_buffers&, socket_base::message_flags, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return 0; } // Start an asynchronous receive. The buffer for the data being received // must be valid for the lifetime of the asynchronous operation. template <typename MutableBufferSequence, typename Handler, typename IoExecutor> void async_receive(implementation_type&, const MutableBufferSequence&, socket_base::message_flags, Handler& handler, const IoExecutor& io_ex) { boost::system::error_code ec = boost::asio::error::operation_not_supported; const std::size_t bytes_transferred = 0; boost::asio::post(io_ex, detail::bind_handler( handler, ec, bytes_transferred)); } // Wait until data can be received without blocking. template <typename Handler, typename IoExecutor> void async_receive(implementation_type&, const null_buffers&, socket_base::message_flags, Handler& handler, const IoExecutor& io_ex) { boost::system::error_code ec = boost::asio::error::operation_not_supported; const std::size_t bytes_transferred = 0; boost::asio::post(io_ex, detail::bind_handler( handler, ec, bytes_transferred)); } // Receive some data with associated flags. Returns the number of bytes // received. template <typename MutableBufferSequence> std::size_t receive_with_flags(implementation_type&, const MutableBufferSequence&, socket_base::message_flags, socket_base::message_flags&, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return 0; } // Wait until data can be received without blocking. std::size_t receive_with_flags(implementation_type&, const null_buffers&, socket_base::message_flags, socket_base::message_flags&, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return 0; } // Start an asynchronous receive. The buffer for the data being received // must be valid for the lifetime of the asynchronous operation. template <typename MutableBufferSequence, typename Handler, typename IoExecutor> void async_receive_with_flags(implementation_type&, const MutableBufferSequence&, socket_base::message_flags, socket_base::message_flags&, Handler& handler, const IoExecutor& io_ex) { boost::system::error_code ec = boost::asio::error::operation_not_supported; const std::size_t bytes_transferred = 0; boost::asio::post(io_ex, detail::bind_handler( handler, ec, bytes_transferred)); } // Wait until data can be received without blocking. template <typename Handler, typename IoExecutor> void async_receive_with_flags(implementation_type&, const null_buffers&, socket_base::message_flags, socket_base::message_flags&, Handler& handler, const IoExecutor& io_ex) { boost::system::error_code ec = boost::asio::error::operation_not_supported; const std::size_t bytes_transferred = 0; boost::asio::post(io_ex, detail::bind_handler( handler, ec, bytes_transferred)); } // Send a datagram to the specified endpoint. Returns the number of bytes // sent. template <typename ConstBufferSequence> std::size_t send_to(implementation_type&, const ConstBufferSequence&, const endpoint_type&, socket_base::message_flags, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return 0; } // Wait until data can be sent without blocking. std::size_t send_to(implementation_type&, const null_buffers&, const endpoint_type&, socket_base::message_flags, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return 0; } // Start an asynchronous send. The data being sent must be valid for the // lifetime of the asynchronous operation. template <typename ConstBufferSequence, typename Handler, typename IoExecutor> void async_send_to(implementation_type&, const ConstBufferSequence&, const endpoint_type&, socket_base::message_flags, Handler& handler) { boost::system::error_code ec = boost::asio::error::operation_not_supported; const std::size_t bytes_transferred = 0; boost::asio::post(io_ex, detail::bind_handler( handler, ec, bytes_transferred)); } // Start an asynchronous wait until data can be sent without blocking. template <typename Handler, typename IoExecutor> void async_send_to(implementation_type&, const null_buffers&, const endpoint_type&, socket_base::message_flags, Handler& handler, const IoExecutor& io_ex) { boost::system::error_code ec = boost::asio::error::operation_not_supported; const std::size_t bytes_transferred = 0; boost::asio::post(io_ex, detail::bind_handler( handler, ec, bytes_transferred)); } // Receive a datagram with the endpoint of the sender. Returns the number of // bytes received. template <typename MutableBufferSequence> std::size_t receive_from(implementation_type&, const MutableBufferSequence&, endpoint_type&, socket_base::message_flags, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return 0; } // Wait until data can be received without blocking. std::size_t receive_from(implementation_type&, const null_buffers&, endpoint_type&, socket_base::message_flags, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return 0; } // Start an asynchronous receive. The buffer for the data being received and // the sender_endpoint object must both be valid for the lifetime of the // asynchronous operation. template <typename MutableBufferSequence, typename Handler, typename IoExecutor> void async_receive_from(implementation_type&, const MutableBufferSequence&, endpoint_type&, socket_base::message_flags, Handler& handler, const IoExecutor& io_ex) { boost::system::error_code ec = boost::asio::error::operation_not_supported; const std::size_t bytes_transferred = 0; boost::asio::post(io_ex, detail::bind_handler( handler, ec, bytes_transferred)); } // Wait until data can be received without blocking. template <typename Handler, typename IoExecutor> void async_receive_from(implementation_type&, const null_buffers&, endpoint_type&, socket_base::message_flags, Handler& handler, const IoExecutor& io_ex) { boost::system::error_code ec = boost::asio::error::operation_not_supported; const std::size_t bytes_transferred = 0; boost::asio::post(io_ex, detail::bind_handler( handler, ec, bytes_transferred)); } // Accept a new connection. template <typename Socket> boost::system::error_code accept(implementation_type&, Socket&, endpoint_type, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return ec; } // Start an asynchronous accept. The peer and peer_endpoint objects // must be valid until the accept's handler is invoked. template <typename Socket, typename Handler, typename IoExecutor> void async_accept(implementation_type&, Socket&, endpoint_type, Handler& handler, const IoExecutor& io_ex) { boost::system::error_code ec = boost::asio::error::operation_not_supported; boost::asio::post(io_ex, detail::bind_handler(handler, ec)); } // Connect the socket to the specified endpoint. boost::system::error_code connect(implementation_type&, const endpoint_type&, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return ec; } // Start an asynchronous connect. template <typename Handler, typename IoExecutor> void async_connect(implementation_type&, const endpoint_type&, Handler& handler, const IoExecutor& io_ex) { boost::system::error_code ec = boost::asio::error::operation_not_supported; boost::asio::post(io_ex, detail::bind_handler(handler, ec)); } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_NULL_SOCKET_SERVICE_HPP PK��h!\�q��posix_static_mutex.hppnu��[��// // detail/posix_static_mutex.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_POSIX_STATIC_MUTEX_HPP #define BOOST_ASIO_DETAIL_POSIX_STATIC_MUTEX_HPP #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_HAS_PTHREADS) #include <pthread.h> #include <boost/asio/detail/scoped_lock.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { struct posix_static_mutex { typedef boost::asio::detail::scoped_lock<posix_static_mutex> scoped_lock; // Initialise the mutex. void init() { // Nothing to do. } // Lock the mutex. void lock() { (void)::pthread_mutex_lock(&mutex_); // Ignore EINVAL. } // Unlock the mutex. void unlock() { (void)::pthread_mutex_unlock(&mutex_); // Ignore EINVAL. } ::pthread_mutex_t mutex_; }; #define BOOST_ASIO_POSIX_STATIC_MUTEX_INIT { PTHREAD_MUTEX_INITIALIZER } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_PTHREADS) #endif // BOOST_ASIO_DETAIL_POSIX_STATIC_MUTEX_HPP PK��h!\��winrt_resolve_op.hppnu��[��// // detail/winrt_resolve_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WINRT_RESOLVE_OP_HPP #define BOOST_ASIO_DETAIL_WINRT_RESOLVE_OP_HPP #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_WINDOWS_RUNTIME) #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/winrt_async_op.hpp> #include <boost/asio/ip/basic_resolver_results.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Protocol, typename Handler, typename IoExecutor> class winrt_resolve_op : public winrt_async_op< Windows::Foundation::Collections::IVectorView< Windows::Networking::EndpointPair^>^> { public: BOOST_ASIO_DEFINE_HANDLER_PTR(winrt_resolve_op); typedef typename Protocol::endpoint endpoint_type; typedef boost::asio::ip::basic_resolver_query<Protocol> query_type; typedef boost::asio::ip::basic_resolver_results<Protocol> results_type; winrt_resolve_op(const query_type& query, Handler& handler, const IoExecutor& io_ex) : winrt_async_op< Windows::Foundation::Collections::IVectorView< Windows::Networking::EndpointPair^>^>( &winrt_resolve_op::do_complete), query_(query), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static void do_complete(void owner, operation* base, const boost::system::error_code&, std::size_t) { // Take ownership of the operation object. winrt_resolve_op* o(static_cast<winrt_resolve_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); results_type results = results_type(); if (!o->ec_) { try { results = results_type::create(o->result_, o->query_.hints(), o->query_.host_name(), o->query_.service_name()); } catch (Platform::Exception^ e) { o->ec_ = boost::system::error_code(e->HResult, boost::system::system_category()); } } // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, results_type> handler(o->handler_, o->ec_, results); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "...")); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: query_type query_; Handler handler_; handler_work<Handler, IoExecutor> executor_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_WINRT_RESOLVE_OP_HPP PK��h!\��>��winrt_resolver_service.hppnu��[��// // detail/winrt_resolver_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WINRT_RESOLVER_SERVICE_HPP #define BOOST_ASIO_DETAIL_WINRT_RESOLVER_SERVICE_HPP #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_WINDOWS_RUNTIME) #include <boost/asio/ip/basic_resolver_query.hpp> #include <boost/asio/ip/basic_resolver_results.hpp> #include <boost/asio/post.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/detail/winrt_async_manager.hpp> #include <boost/asio/detail/winrt_resolve_op.hpp> #include <boost/asio/detail/winrt_utils.hpp> #if defined(BOOST_ASIO_HAS_IOCP) # include <boost/asio/detail/win_iocp_io_context.hpp> #else // defined(BOOST_ASIO_HAS_IOCP) # include <boost/asio/detail/scheduler.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Protocol> class winrt_resolver_service : public execution_context_service_base<winrt_resolver_service<Protocol> > { public: // The implementation type of the resolver. A cancellation token is used to // indicate to the asynchronous operation that the operation has been // cancelled. typedef socket_ops::shared_cancel_token_type implementation_type; // The endpoint type. typedef typename Protocol::endpoint endpoint_type; // The query type. typedef boost::asio::ip::basic_resolver_query<Protocol> query_type; // The results type. typedef boost::asio::ip::basic_resolver_results<Protocol> results_type; // Constructor. winrt_resolver_service(execution_context& context) : execution_context_service_base< winrt_resolver_service<Protocol> >(context), scheduler_(use_service<scheduler_impl>(context)), async_manager_(use_service<winrt_async_manager>(context)) { } // Destructor. ~winrt_resolver_service() { } // Destroy all user-defined handler objects owned by the service. void shutdown() { } // Perform any fork-related housekeeping. void notify_fork(execution_context::fork_event) { } // Construct a new resolver implementation. void construct(implementation_type&) { } // Move-construct a new resolver implementation. void move_construct(implementation_type&, implementation_type&) { } // Move-assign from another resolver implementation. void move_assign(implementation_type&, winrt_resolver_service&, implementation_type&) { } // Destroy a resolver implementation. void destroy(implementation_type&) { } // Cancel pending asynchronous operations. void cancel(implementation_type&) { } // Resolve a query to a list of entries. results_type resolve(implementation_type&, const query_type& query, boost::system::error_code& ec) { try { using namespace Windows::Networking::Sockets; auto endpoint_pairs = async_manager_.sync( DatagramSocket::GetEndpointPairsAsync( winrt_utils::host_name(query.host_name()), winrt_utils::string(query.service_name())), ec); if (ec) return results_type(); return results_type::create( endpoint_pairs, query.hints(), query.host_name(), query.service_name()); } catch (Platform::Exception^ e) { ec = boost::system::error_code(e->HResult, boost::system::system_category()); return results_type(); } } // Asynchronously resolve a query to a list of entries. template <typename Handler, typename IoExecutor> void async_resolve(implementation_type& impl, const query_type& query, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef winrt_resolve_op<Protocol, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(query, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((scheduler_.context(), p.p, "resolver", &impl, 0, "async_resolve")); (void)impl; try { using namespace Windows::Networking::Sockets; async_manager_.async(DatagramSocket::GetEndpointPairsAsync( winrt_utils::host_name(query.host_name()), winrt_utils::string(query.service_name())), p.p); p.v = p.p = 0; } catch (Platform::Exception^ e) { p.p->ec_ = boost::system::error_code( e->HResult, boost::system::system_category()); scheduler_.post_immediate_completion(p.p, is_continuation); p.v = p.p = 0; } } // Resolve an endpoint to a list of entries. results_type resolve(implementation_type&, const endpoint_type&, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return results_type(); } // Asynchronously resolve an endpoint to a list of entries. template <typename Handler, typename IoExecutor> void async_resolve(implementation_type&, const endpoint_type&, Handler& handler, const IoExecutor& io_ex) { boost::system::error_code ec = boost::asio::error::operation_not_supported; const results_type results; boost::asio::post(io_ex, detail::bind_handler(handler, ec, results)); } private: // The scheduler implementation used for delivering completions. #if defined(BOOST_ASIO_HAS_IOCP) typedef class win_iocp_io_context scheduler_impl; #else typedef class scheduler scheduler_impl; #endif scheduler_impl& scheduler_; winrt_async_manager& async_manager_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_WINRT_RESOLVER_SERVICE_HPP PK��h!\[��wait_op.hppnu��[��// // detail/wait_op.hpp // ~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WAIT_OP_HPP #define BOOST_ASIO_DETAIL_WAIT_OP_HPP #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/detail/operation.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class wait_op : public operation { public: // The error code to be passed to the completion handler. boost::system::error_code ec_; protected: wait_op(func_type func) : operation(func) { } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_WAIT_OP_HPP PK��h!\"g��[��[��null_signal_blocker.hppnu��[��// // detail/null_signal_blocker.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_NULL_SIGNAL_BLOCKER_HPP #define BOOST_ASIO_DETAIL_NULL_SIGNAL_BLOCKER_HPP #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_HAS_THREADS) \ \|\| defined(BOOST_ASIO_WINDOWS) \ \|\| defined(BOOST_ASIO_WINDOWS_RUNTIME) \ \|\| defined(__CYGWIN__) \ \|\| defined(__SYMBIAN32__) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class null_signal_blocker : private noncopyable { public: // Constructor blocks all signals for the calling thread. null_signal_blocker() { } // Destructor restores the previous signal mask. ~null_signal_blocker() { } // Block all signals for the calling thread. void block() { } // Restore the previous signal mask. void unblock() { } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // !defined(BOOST_ASIO_HAS_THREADS) // \|\| defined(BOOST_ASIO_WINDOWS) // \|\| defined(BOOST_ASIO_WINDOWS_RUNTIME) // \|\| defined(__CYGWIN__) // \|\| defined(__SYMBIAN32__) #endif // BOOST_ASIO_DETAIL_NULL_SIGNAL_BLOCKER_HPP PK��h!\S@IɅ��timer_scheduler.hppnu��[��// // detail/timer_scheduler.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_TIMER_SCHEDULER_HPP #define BOOST_ASIO_DETAIL_TIMER_SCHEDULER_HPP #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/detail/timer_scheduler_fwd.hpp> #if defined(BOOST_ASIO_WINDOWS_RUNTIME) # include <boost/asio/detail/winrt_timer_scheduler.hpp> #elif defined(BOOST_ASIO_HAS_IOCP) # include <boost/asio/detail/win_iocp_io_context.hpp> #elif defined(BOOST_ASIO_HAS_EPOLL) # include <boost/asio/detail/epoll_reactor.hpp> #elif defined(BOOST_ASIO_HAS_KQUEUE) # include <boost/asio/detail/kqueue_reactor.hpp> #elif defined(BOOST_ASIO_HAS_DEV_POLL) # include <boost/asio/detail/dev_poll_reactor.hpp> #else # include <boost/asio/detail/select_reactor.hpp> #endif #endif // BOOST_ASIO_DETAIL_TIMER_SCHEDULER_HPP PK��h!\��gr��r��bind_handler.hppnu��[��// // detail/bind_handler.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_BIND_HANDLER_HPP #define BOOST_ASIO_DETAIL_BIND_HANDLER_HPP #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/associated_allocator.hpp> #include <boost/asio/associated_executor.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_cont_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/type_traits.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Handler, typename Arg1> class binder1 { public: template <typename T> binder1(int, BOOST_ASIO_MOVE_ARG(T) handler, const Arg1& arg1) : handler_(BOOST_ASIO_MOVE_CAST(T)(handler)), arg1_(arg1) { } binder1(Handler& handler, const Arg1& arg1) : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), arg1_(arg1) { } #if defined(BOOST_ASIO_HAS_MOVE) binder1(const binder1& other) : handler_(other.handler_), arg1_(other.arg1_) { } binder1(binder1&& other) : handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_)), arg1_(BOOST_ASIO_MOVE_CAST(Arg1)(other.arg1_)) { } #endif // defined(BOOST_ASIO_HAS_MOVE) void operator()() { handler_(static_cast<const Arg1&>(arg1_)); } void operator()() const { handler_(arg1_); } //private: Handler handler_; Arg1 arg1_; }; template <typename Handler, typename Arg1> inline asio_handler_allocate_is_deprecated asio_handler_allocate(std::size_t size, binder1<Handler, Arg1> this_handler) { #if defined(BOOST_ASIO_NO_DEPRECATED) boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_); return asio_handler_allocate_is_no_longer_used(); #else // defined(BOOST_ASIO_NO_DEPRECATED) return boost_asio_handler_alloc_helpers::allocate( size, this_handler->handler_); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Handler, typename Arg1> inline asio_handler_deallocate_is_deprecated asio_handler_deallocate(void* pointer, std::size_t size, binder1<Handler, Arg1>* this_handler) { boost_asio_handler_alloc_helpers::deallocate( pointer, size, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_deallocate_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Handler, typename Arg1> inline bool asio_handler_is_continuation( binder1<Handler, Arg1>* this_handler) { return boost_asio_handler_cont_helpers::is_continuation( this_handler->handler_); } template <typename Function, typename Handler, typename Arg1> inline asio_handler_invoke_is_deprecated asio_handler_invoke(Function& function, binder1<Handler, Arg1>* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Function, typename Handler, typename Arg1> inline asio_handler_invoke_is_deprecated asio_handler_invoke(const Function& function, binder1<Handler, Arg1>* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Handler, typename Arg1> inline binder1<typename decay<Handler>::type, Arg1> bind_handler( BOOST_ASIO_MOVE_ARG(Handler) handler, const Arg1& arg1) { return binder1<typename decay<Handler>::type, Arg1>(0, BOOST_ASIO_MOVE_CAST(Handler)(handler), arg1); } template <typename Handler, typename Arg1, typename Arg2> class binder2 { public: template <typename T> binder2(int, BOOST_ASIO_MOVE_ARG(T) handler, const Arg1& arg1, const Arg2& arg2) : handler_(BOOST_ASIO_MOVE_CAST(T)(handler)), arg1_(arg1), arg2_(arg2) { } binder2(Handler& handler, const Arg1& arg1, const Arg2& arg2) : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), arg1_(arg1), arg2_(arg2) { } #if defined(BOOST_ASIO_HAS_MOVE) binder2(const binder2& other) : handler_(other.handler_), arg1_(other.arg1_), arg2_(other.arg2_) { } binder2(binder2&& other) : handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_)), arg1_(BOOST_ASIO_MOVE_CAST(Arg1)(other.arg1_)), arg2_(BOOST_ASIO_MOVE_CAST(Arg2)(other.arg2_)) { } #endif // defined(BOOST_ASIO_HAS_MOVE) void operator()() { handler_(static_cast<const Arg1&>(arg1_), static_cast<const Arg2&>(arg2_)); } void operator()() const { handler_(arg1_, arg2_); } //private: Handler handler_; Arg1 arg1_; Arg2 arg2_; }; template <typename Handler, typename Arg1, typename Arg2> inline asio_handler_allocate_is_deprecated asio_handler_allocate(std::size_t size, binder2<Handler, Arg1, Arg2>* this_handler) { #if defined(BOOST_ASIO_NO_DEPRECATED) boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_); return asio_handler_allocate_is_no_longer_used(); #else // defined(BOOST_ASIO_NO_DEPRECATED) return boost_asio_handler_alloc_helpers::allocate( size, this_handler->handler_); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Handler, typename Arg1, typename Arg2> inline asio_handler_deallocate_is_deprecated asio_handler_deallocate(void* pointer, std::size_t size, binder2<Handler, Arg1, Arg2>* this_handler) { boost_asio_handler_alloc_helpers::deallocate( pointer, size, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_deallocate_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Handler, typename Arg1, typename Arg2> inline bool asio_handler_is_continuation( binder2<Handler, Arg1, Arg2>* this_handler) { return boost_asio_handler_cont_helpers::is_continuation( this_handler->handler_); } template <typename Function, typename Handler, typename Arg1, typename Arg2> inline asio_handler_invoke_is_deprecated asio_handler_invoke(Function& function, binder2<Handler, Arg1, Arg2>* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Function, typename Handler, typename Arg1, typename Arg2> inline asio_handler_invoke_is_deprecated asio_handler_invoke(const Function& function, binder2<Handler, Arg1, Arg2>* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Handler, typename Arg1, typename Arg2> inline binder2<typename decay<Handler>::type, Arg1, Arg2> bind_handler( BOOST_ASIO_MOVE_ARG(Handler) handler, const Arg1& arg1, const Arg2& arg2) { return binder2<typename decay<Handler>::type, Arg1, Arg2>(0, BOOST_ASIO_MOVE_CAST(Handler)(handler), arg1, arg2); } template <typename Handler, typename Arg1, typename Arg2, typename Arg3> class binder3 { public: template <typename T> binder3(int, BOOST_ASIO_MOVE_ARG(T) handler, const Arg1& arg1, const Arg2& arg2, const Arg3& arg3) : handler_(BOOST_ASIO_MOVE_CAST(T)(handler)), arg1_(arg1), arg2_(arg2), arg3_(arg3) { } binder3(Handler& handler, const Arg1& arg1, const Arg2& arg2, const Arg3& arg3) : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), arg1_(arg1), arg2_(arg2), arg3_(arg3) { } #if defined(BOOST_ASIO_HAS_MOVE) binder3(const binder3& other) : handler_(other.handler_), arg1_(other.arg1_), arg2_(other.arg2_), arg3_(other.arg3_) { } binder3(binder3&& other) : handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_)), arg1_(BOOST_ASIO_MOVE_CAST(Arg1)(other.arg1_)), arg2_(BOOST_ASIO_MOVE_CAST(Arg2)(other.arg2_)), arg3_(BOOST_ASIO_MOVE_CAST(Arg3)(other.arg3_)) { } #endif // defined(BOOST_ASIO_HAS_MOVE) void operator()() { handler_(static_cast<const Arg1&>(arg1_), static_cast<const Arg2&>(arg2_), static_cast<const Arg3&>(arg3_)); } void operator()() const { handler_(arg1_, arg2_, arg3_); } //private: Handler handler_; Arg1 arg1_; Arg2 arg2_; Arg3 arg3_; }; template <typename Handler, typename Arg1, typename Arg2, typename Arg3> inline asio_handler_allocate_is_deprecated asio_handler_allocate(std::size_t size, binder3<Handler, Arg1, Arg2, Arg3>* this_handler) { #if defined(BOOST_ASIO_NO_DEPRECATED) boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_); return asio_handler_allocate_is_no_longer_used(); #else // defined(BOOST_ASIO_NO_DEPRECATED) return boost_asio_handler_alloc_helpers::allocate( size, this_handler->handler_); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Handler, typename Arg1, typename Arg2, typename Arg3> inline asio_handler_deallocate_is_deprecated asio_handler_deallocate(void* pointer, std::size_t size, binder3<Handler, Arg1, Arg2, Arg3>* this_handler) { boost_asio_handler_alloc_helpers::deallocate( pointer, size, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_deallocate_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Handler, typename Arg1, typename Arg2, typename Arg3> inline bool asio_handler_is_continuation( binder3<Handler, Arg1, Arg2, Arg3>* this_handler) { return boost_asio_handler_cont_helpers::is_continuation( this_handler->handler_); } template <typename Function, typename Handler, typename Arg1, typename Arg2, typename Arg3> inline asio_handler_invoke_is_deprecated asio_handler_invoke(Function& function, binder3<Handler, Arg1, Arg2, Arg3>* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Function, typename Handler, typename Arg1, typename Arg2, typename Arg3> inline asio_handler_invoke_is_deprecated asio_handler_invoke(const Function& function, binder3<Handler, Arg1, Arg2, Arg3>* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Handler, typename Arg1, typename Arg2, typename Arg3> inline binder3<typename decay<Handler>::type, Arg1, Arg2, Arg3> bind_handler( BOOST_ASIO_MOVE_ARG(Handler) handler, const Arg1& arg1, const Arg2& arg2, const Arg3& arg3) { return binder3<typename decay<Handler>::type, Arg1, Arg2, Arg3>(0, BOOST_ASIO_MOVE_CAST(Handler)(handler), arg1, arg2, arg3); } template <typename Handler, typename Arg1, typename Arg2, typename Arg3, typename Arg4> class binder4 { public: template <typename T> binder4(int, BOOST_ASIO_MOVE_ARG(T) handler, const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4) : handler_(BOOST_ASIO_MOVE_CAST(T)(handler)), arg1_(arg1), arg2_(arg2), arg3_(arg3), arg4_(arg4) { } binder4(Handler& handler, const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4) : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), arg1_(arg1), arg2_(arg2), arg3_(arg3), arg4_(arg4) { } #if defined(BOOST_ASIO_HAS_MOVE) binder4(const binder4& other) : handler_(other.handler_), arg1_(other.arg1_), arg2_(other.arg2_), arg3_(other.arg3_), arg4_(other.arg4_) { } binder4(binder4&& other) : handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_)), arg1_(BOOST_ASIO_MOVE_CAST(Arg1)(other.arg1_)), arg2_(BOOST_ASIO_MOVE_CAST(Arg2)(other.arg2_)), arg3_(BOOST_ASIO_MOVE_CAST(Arg3)(other.arg3_)), arg4_(BOOST_ASIO_MOVE_CAST(Arg4)(other.arg4_)) { } #endif // defined(BOOST_ASIO_HAS_MOVE) void operator()() { handler_(static_cast<const Arg1&>(arg1_), static_cast<const Arg2&>(arg2_), static_cast<const Arg3&>(arg3_), static_cast<const Arg4&>(arg4_)); } void operator()() const { handler_(arg1_, arg2_, arg3_, arg4_); } //private: Handler handler_; Arg1 arg1_; Arg2 arg2_; Arg3 arg3_; Arg4 arg4_; }; template <typename Handler, typename Arg1, typename Arg2, typename Arg3, typename Arg4> inline asio_handler_allocate_is_deprecated asio_handler_allocate(std::size_t size, binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler) { #if defined(BOOST_ASIO_NO_DEPRECATED) boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_); return asio_handler_allocate_is_no_longer_used(); #else // defined(BOOST_ASIO_NO_DEPRECATED) return boost_asio_handler_alloc_helpers::allocate( size, this_handler->handler_); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Handler, typename Arg1, typename Arg2, typename Arg3, typename Arg4> inline asio_handler_deallocate_is_deprecated asio_handler_deallocate(void* pointer, std::size_t size, binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler) { boost_asio_handler_alloc_helpers::deallocate( pointer, size, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_deallocate_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Handler, typename Arg1, typename Arg2, typename Arg3, typename Arg4> inline bool asio_handler_is_continuation( binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler) { return boost_asio_handler_cont_helpers::is_continuation( this_handler->handler_); } template <typename Function, typename Handler, typename Arg1, typename Arg2, typename Arg3, typename Arg4> inline asio_handler_invoke_is_deprecated asio_handler_invoke(Function& function, binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Function, typename Handler, typename Arg1, typename Arg2, typename Arg3, typename Arg4> inline asio_handler_invoke_is_deprecated asio_handler_invoke(const Function& function, binder4<Handler, Arg1, Arg2, Arg3, Arg4>* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Handler, typename Arg1, typename Arg2, typename Arg3, typename Arg4> inline binder4<typename decay<Handler>::type, Arg1, Arg2, Arg3, Arg4> bind_handler(BOOST_ASIO_MOVE_ARG(Handler) handler, const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4) { return binder4<typename decay<Handler>::type, Arg1, Arg2, Arg3, Arg4>(0, BOOST_ASIO_MOVE_CAST(Handler)(handler), arg1, arg2, arg3, arg4); } template <typename Handler, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5> class binder5 { public: template <typename T> binder5(int, BOOST_ASIO_MOVE_ARG(T) handler, const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5) : handler_(BOOST_ASIO_MOVE_CAST(T)(handler)), arg1_(arg1), arg2_(arg2), arg3_(arg3), arg4_(arg4), arg5_(arg5) { } binder5(Handler& handler, const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5) : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), arg1_(arg1), arg2_(arg2), arg3_(arg3), arg4_(arg4), arg5_(arg5) { } #if defined(BOOST_ASIO_HAS_MOVE) binder5(const binder5& other) : handler_(other.handler_), arg1_(other.arg1_), arg2_(other.arg2_), arg3_(other.arg3_), arg4_(other.arg4_), arg5_(other.arg5_) { } binder5(binder5&& other) : handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_)), arg1_(BOOST_ASIO_MOVE_CAST(Arg1)(other.arg1_)), arg2_(BOOST_ASIO_MOVE_CAST(Arg2)(other.arg2_)), arg3_(BOOST_ASIO_MOVE_CAST(Arg3)(other.arg3_)), arg4_(BOOST_ASIO_MOVE_CAST(Arg4)(other.arg4_)), arg5_(BOOST_ASIO_MOVE_CAST(Arg5)(other.arg5_)) { } #endif // defined(BOOST_ASIO_HAS_MOVE) void operator()() { handler_(static_cast<const Arg1&>(arg1_), static_cast<const Arg2&>(arg2_), static_cast<const Arg3&>(arg3_), static_cast<const Arg4&>(arg4_), static_cast<const Arg5&>(arg5_)); } void operator()() const { handler_(arg1_, arg2_, arg3_, arg4_, arg5_); } //private: Handler handler_; Arg1 arg1_; Arg2 arg2_; Arg3 arg3_; Arg4 arg4_; Arg5 arg5_; }; template <typename Handler, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5> inline asio_handler_allocate_is_deprecated asio_handler_allocate(std::size_t size, binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler) { #if defined(BOOST_ASIO_NO_DEPRECATED) boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_); return asio_handler_allocate_is_no_longer_used(); #else // defined(BOOST_ASIO_NO_DEPRECATED) return boost_asio_handler_alloc_helpers::allocate( size, this_handler->handler_); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Handler, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5> inline asio_handler_deallocate_is_deprecated asio_handler_deallocate(void* pointer, std::size_t size, binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler) { boost_asio_handler_alloc_helpers::deallocate( pointer, size, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_deallocate_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Handler, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5> inline bool asio_handler_is_continuation( binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler) { return boost_asio_handler_cont_helpers::is_continuation( this_handler->handler_); } template <typename Function, typename Handler, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5> inline asio_handler_invoke_is_deprecated asio_handler_invoke(Function& function, binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Function, typename Handler, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5> inline asio_handler_invoke_is_deprecated asio_handler_invoke(const Function& function, binder5<Handler, Arg1, Arg2, Arg3, Arg4, Arg5>* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Handler, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5> inline binder5<typename decay<Handler>::type, Arg1, Arg2, Arg3, Arg4, Arg5> bind_handler(BOOST_ASIO_MOVE_ARG(Handler) handler, const Arg1& arg1, const Arg2& arg2, const Arg3& arg3, const Arg4& arg4, const Arg5& arg5) { return binder5<typename decay<Handler>::type, Arg1, Arg2, Arg3, Arg4, Arg5>(0, BOOST_ASIO_MOVE_CAST(Handler)(handler), arg1, arg2, arg3, arg4, arg5); } #if defined(BOOST_ASIO_HAS_MOVE) template <typename Handler, typename Arg1> class move_binder1 { public: move_binder1(int, BOOST_ASIO_MOVE_ARG(Handler) handler, BOOST_ASIO_MOVE_ARG(Arg1) arg1) : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), arg1_(BOOST_ASIO_MOVE_CAST(Arg1)(arg1)) { } move_binder1(move_binder1&& other) : handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_)), arg1_(BOOST_ASIO_MOVE_CAST(Arg1)(other.arg1_)) { } void operator()() { handler_(BOOST_ASIO_MOVE_CAST(Arg1)(arg1_)); } //private: Handler handler_; Arg1 arg1_; }; template <typename Handler, typename Arg1> inline asio_handler_allocate_is_deprecated asio_handler_allocate(std::size_t size, move_binder1<Handler, Arg1>* this_handler) { #if defined(BOOST_ASIO_NO_DEPRECATED) boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_); return asio_handler_allocate_is_no_longer_used(); #else // defined(BOOST_ASIO_NO_DEPRECATED) return boost_asio_handler_alloc_helpers::allocate( size, this_handler->handler_); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Handler, typename Arg1> inline asio_handler_deallocate_is_deprecated asio_handler_deallocate(void* pointer, std::size_t size, move_binder1<Handler, Arg1>* this_handler) { boost_asio_handler_alloc_helpers::deallocate( pointer, size, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_deallocate_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Handler, typename Arg1> inline bool asio_handler_is_continuation( move_binder1<Handler, Arg1>* this_handler) { return boost_asio_handler_cont_helpers::is_continuation( this_handler->handler_); } template <typename Function, typename Handler, typename Arg1> inline asio_handler_invoke_is_deprecated asio_handler_invoke(BOOST_ASIO_MOVE_ARG(Function) function, move_binder1<Handler, Arg1>* this_handler) { boost_asio_handler_invoke_helpers::invoke( BOOST_ASIO_MOVE_CAST(Function)(function), this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Handler, typename Arg1, typename Arg2> class move_binder2 { public: move_binder2(int, BOOST_ASIO_MOVE_ARG(Handler) handler, const Arg1& arg1, BOOST_ASIO_MOVE_ARG(Arg2) arg2) : handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), arg1_(arg1), arg2_(BOOST_ASIO_MOVE_CAST(Arg2)(arg2)) { } move_binder2(move_binder2&& other) : handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_)), arg1_(BOOST_ASIO_MOVE_CAST(Arg1)(other.arg1_)), arg2_(BOOST_ASIO_MOVE_CAST(Arg2)(other.arg2_)) { } void operator()() { handler_(static_cast<const Arg1&>(arg1_), BOOST_ASIO_MOVE_CAST(Arg2)(arg2_)); } //private: Handler handler_; Arg1 arg1_; Arg2 arg2_; }; template <typename Handler, typename Arg1, typename Arg2> inline asio_handler_allocate_is_deprecated asio_handler_allocate(std::size_t size, move_binder2<Handler, Arg1, Arg2>* this_handler) { #if defined(BOOST_ASIO_NO_DEPRECATED) boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_); return asio_handler_allocate_is_no_longer_used(); #else // defined(BOOST_ASIO_NO_DEPRECATED) return boost_asio_handler_alloc_helpers::allocate( size, this_handler->handler_); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Handler, typename Arg1, typename Arg2> inline asio_handler_deallocate_is_deprecated asio_handler_deallocate(void* pointer, std::size_t size, move_binder2<Handler, Arg1, Arg2>* this_handler) { boost_asio_handler_alloc_helpers::deallocate( pointer, size, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_deallocate_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template <typename Handler, typename Arg1, typename Arg2> inline bool asio_handler_is_continuation( move_binder2<Handler, Arg1, Arg2>* this_handler) { return boost_asio_handler_cont_helpers::is_continuation( this_handler->handler_); } template <typename Function, typename Handler, typename Arg1, typename Arg2> inline asio_handler_invoke_is_deprecated asio_handler_invoke(BOOST_ASIO_MOVE_ARG(Function) function, move_binder2<Handler, Arg1, Arg2>* this_handler) { boost_asio_handler_invoke_helpers::invoke( BOOST_ASIO_MOVE_CAST(Function)(function), this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } #endif // defined(BOOST_ASIO_HAS_MOVE) } // namespace detail template <typename Handler, typename Arg1, typename Allocator> struct associated_allocator<detail::binder1<Handler, Arg1>, Allocator> { typedef typename associated_allocator<Handler, Allocator>::type type; static type get(const detail::binder1<Handler, Arg1>& h, const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT { return associated_allocator<Handler, Allocator>::get(h.handler_, a); } }; template <typename Handler, typename Arg1, typename Arg2, typename Allocator> struct associated_allocator<detail::binder2<Handler, Arg1, Arg2>, Allocator> { typedef typename associated_allocator<Handler, Allocator>::type type; static type get(const detail::binder2<Handler, Arg1, Arg2>& h, const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT { return associated_allocator<Handler, Allocator>::get(h.handler_, a); } }; template <typename Handler, typename Arg1, typename Executor> struct associated_executor<detail::binder1<Handler, Arg1>, Executor> : detail::associated_executor_forwarding_base<Handler, Executor> { typedef typename associated_executor<Handler, Executor>::type type; static type get(const detail::binder1<Handler, Arg1>& h, const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT { return associated_executor<Handler, Executor>::get(h.handler_, ex); } }; template <typename Handler, typename Arg1, typename Arg2, typename Executor> struct associated_executor<detail::binder2<Handler, Arg1, Arg2>, Executor> : detail::associated_executor_forwarding_base<Handler, Executor> { typedef typename associated_executor<Handler, Executor>::type type; static type get(const detail::binder2<Handler, Arg1, Arg2>& h, const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT { return associated_executor<Handler, Executor>::get(h.handler_, ex); } }; #if defined(BOOST_ASIO_HAS_MOVE) template <typename Handler, typename Arg1, typename Allocator> struct associated_allocator<detail::move_binder1<Handler, Arg1>, Allocator> { typedef typename associated_allocator<Handler, Allocator>::type type; static type get(const detail::move_binder1<Handler, Arg1>& h, const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT { return associated_allocator<Handler, Allocator>::get(h.handler_, a); } }; template <typename Handler, typename Arg1, typename Arg2, typename Allocator> struct associated_allocator< detail::move_binder2<Handler, Arg1, Arg2>, Allocator> { typedef typename associated_allocator<Handler, Allocator>::type type; static type get(const detail::move_binder2<Handler, Arg1, Arg2>& h, const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT { return associated_allocator<Handler, Allocator>::get(h.handler_, a); } }; template <typename Handler, typename Arg1, typename Executor> struct associated_executor<detail::move_binder1<Handler, Arg1>, Executor> : detail::associated_executor_forwarding_base<Handler, Executor> { typedef typename associated_executor<Handler, Executor>::type type; static type get(const detail::move_binder1<Handler, Arg1>& h, const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT { return associated_executor<Handler, Executor>::get(h.handler_, ex); } }; template <typename Handler, typename Arg1, typename Arg2, typename Executor> struct associated_executor<detail::move_binder2<Handler, Arg1, Arg2>, Executor> : detail::associated_executor_forwarding_base<Handler, Executor> { typedef typename associated_executor<Handler, Executor>::type type; static type get(const detail::move_binder2<Handler, Arg1, Arg2>& h, const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT { return associated_executor<Handler, Executor>::get(h.handler_, ex); } }; #endif // defined(BOOST_ASIO_HAS_MOVE) } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_BIND_HANDLER_HPP PK��h!\Վ2C��scoped_lock.hppnu��[��// // detail/scoped_lock.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_SCOPED_LOCK_HPP #define BOOST_ASIO_DETAIL_SCOPED_LOCK_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { // Helper class to lock and unlock a mutex automatically. template <typename Mutex> class scoped_lock : private noncopyable { public: // Tag type used to distinguish constructors. enum adopt_lock_t { adopt_lock }; // Constructor adopts a lock that is already held. scoped_lock(Mutex& m, adopt_lock_t) : mutex_(m), locked_(true) { } // Constructor acquires the lock. explicit scoped_lock(Mutex& m) : mutex_(m) { mutex_.lock(); locked_ = true; } // Destructor releases the lock. ~scoped_lock() { if (locked_) mutex_.unlock(); } // Explicitly acquire the lock. void lock() { if (!locked_) { mutex_.lock(); locked_ = true; } } // Explicitly release the lock. void unlock() { if (locked_) { mutex_.unlock(); locked_ = false; } } // Test whether the lock is held. bool locked() const { return locked_; } // Get the underlying mutex. Mutex& mutex() { return mutex_; } private: // The underlying mutex. Mutex& mutex_; // Whether the mutex is currently locked or unlocked. bool locked_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_SCOPED_LOCK_HPP PK��h!\z+$&��&��string_view.hppnu��[��// // detail/string_view.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_STRING_VIEW_HPP #define BOOST_ASIO_DETAIL_STRING_VIEW_HPP #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_HAS_STRING_VIEW) #if defined(BOOST_ASIO_HAS_STD_STRING_VIEW) # include <string_view> #elif defined(BOOST_ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW) # include <experimental/string_view> #else // defined(BOOST_ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW) # error BOOST_ASIO_HAS_STRING_VIEW is set but no string_view is available #endif // defined(BOOST_ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW) namespace boost { namespace asio { #if defined(BOOST_ASIO_HAS_STD_STRING_VIEW) using std::basic_string_view; using std::string_view; #elif defined(BOOST_ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW) using std::experimental::basic_string_view; using std::experimental::string_view; #endif // defined(BOOST_ASIO_HAS_STD_EXPERIMENTAL_STRING_VIEW) } // namespace asio } // namespace boost # define BOOST_ASIO_STRING_VIEW_PARAM boost::asio::string_view #else // defined(BOOST_ASIO_HAS_STRING_VIEW) # define BOOST_ASIO_STRING_VIEW_PARAM const std::string& #endif // defined(BOOST_ASIO_HAS_STRING_VIEW) #endif // BOOST_ASIO_DETAIL_STRING_VIEW_HPP PK��h!\�����win_iocp_socket_recvfrom_op.hppnu��[��// // detail/win_iocp_socket_recvfrom_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_IOCP_SOCKET_RECVFROM_OP_HPP #define BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_RECVFROM_OP_HPP #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_HAS_IOCP) #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/operation.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename MutableBufferSequence, typename Endpoint, typename Handler, typename IoExecutor> class win_iocp_socket_recvfrom_op : public operation { public: BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_recvfrom_op); win_iocp_socket_recvfrom_op(Endpoint& endpoint, socket_ops::weak_cancel_token_type cancel_token, const MutableBufferSequence& buffers, Handler& handler, const IoExecutor& io_ex) : operation(&win_iocp_socket_recvfrom_op::do_complete), endpoint_(endpoint), endpoint_size_(static_cast<int>(endpoint.capacity())), cancel_token_(cancel_token), buffers_(buffers), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } int& endpoint_size() { return endpoint_size_; } static void do_complete(void* owner, operation* base, const boost::system::error_code& result_ec, std::size_t bytes_transferred) { boost::system::error_code ec(result_ec); // Take ownership of the operation object. win_iocp_socket_recvfrom_op* o( static_cast<win_iocp_socket_recvfrom_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) // Check whether buffers are still valid. if (owner) { buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence>::validate(o->buffers_); } #endif // defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) socket_ops::complete_iocp_recvfrom(o->cancel_token_, ec); // Record the size of the endpoint returned by the operation. o->endpoint_.resize(o->endpoint_size_); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, ec, bytes_transferred); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: Endpoint& endpoint_; int endpoint_size_; socket_ops::weak_cancel_token_type cancel_token_; MutableBufferSequence buffers_; Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #endif // BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_RECVFROM_OP_HPP PK��h!\Z�/��call_stack.hppnu��[��// // detail/call_stack.hpp // ~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_CALL_STACK_HPP #define BOOST_ASIO_DETAIL_CALL_STACK_HPP #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/detail/noncopyable.hpp> #include <boost/asio/detail/tss_ptr.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { // Helper class to determine whether or not the current thread is inside an // invocation of io_context::run() for a specified io_context object. template <typename Key, typename Value = unsigned char> class call_stack { public: // Context class automatically pushes the key/value pair on to the stack. class context : private noncopyable { public: // Push the key on to the stack. explicit context(Key* k) : key_(k), next_(call_stack<Key, Value>::top_) { value_ = reinterpret_cast<unsigned char>(this); call_stack<Key, Value>::top_ = this; } // Push the key/value pair on to the stack. context(Key k, Value& v) : key_(k), value_(&v), next_(call_stack<Key, Value>::top_) { call_stack<Key, Value>::top_ = this; } // Pop the key/value pair from the stack. ~context() { call_stack<Key, Value>::top_ = next_; } // Find the next context with the same key. Value* next_by_key() const { context* elem = next_; while (elem) { if (elem->key_ == key_) return elem->value_; elem = elem->next_; } return 0; } private: friend class call_stack<Key, Value>; // The key associated with the context. Key* key_; // The value associated with the context. Value* value_; // The next element in the stack. context* next_; }; friend class context; // Determine whether the specified owner is on the stack. Returns address of // key if present, 0 otherwise. static Value* contains(Key* k) { context* elem = top_; while (elem) { if (elem->key_ == k) return elem->value_; elem = elem->next_; } return 0; } // Obtain the value at the top of the stack. static Value* top() { context* elem = top_; return elem ? elem->value_ : 0; } private: // The top of the stack of calls for the current thread. static tss_ptr<context> top_; }; template <typename Key, typename Value> tss_ptr<typename call_stack<Key, Value>::context> call_stack<Key, Value>::top_; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_CALL_STACK_HPP PK��h!\�a��op_queue.hppnu��[��// // detail/op_queue.hpp // ~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_OP_QUEUE_HPP #define BOOST_ASIO_DETAIL_OP_QUEUE_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Operation> class op_queue; class op_queue_access { public: template <typename Operation> static Operation* next(Operation* o) { return static_cast<Operation>(o->next_); } template <typename Operation1, typename Operation2> static void next(Operation1& o1, Operation2* o2) { o1->next_ = o2; } template <typename Operation> static void destroy(Operation* o) { o->destroy(); } template <typename Operation> static Operation& front(op_queue<Operation>& q) { return q.front_; } template <typename Operation> static Operation& back(op_queue<Operation>& q) { return q.back_; } }; template <typename Operation> class op_queue : private noncopyable { public: // Constructor. op_queue() : front_(0), back_(0) { } // Destructor destroys all operations. ~op_queue() { while (Operation* op = front_) { pop(); op_queue_access::destroy(op); } } // Get the operation at the front of the queue. Operation* front() { return front_; } // Pop an operation from the front of the queue. void pop() { if (front_) { Operation* tmp = front_; front_ = op_queue_access::next(front_); if (front_ == 0) back_ = 0; op_queue_access::next(tmp, static_cast<Operation>(0)); } } // Push an operation on to the back of the queue. void push(Operation h) { op_queue_access::next(h, static_cast<Operation>(0)); if (back_) { op_queue_access::next(back_, h); back_ = h; } else { front_ = back_ = h; } } // Push all operations from another queue on to the back of the queue. The // source queue may contain operations of a derived type. template <typename OtherOperation> void push(op_queue<OtherOperation>& q) { if (Operation other_front = op_queue_access::front(q)) { if (back_) op_queue_access::next(back_, other_front); else front_ = other_front; back_ = op_queue_access::back(q); op_queue_access::front(q) = 0; op_queue_access::back(q) = 0; } } // Whether the queue is empty. bool empty() const { return front_ == 0; } // Test whether an operation is already enqueued. bool is_enqueued(Operation* o) const { return op_queue_access::next(o) != 0 \|\| back_ == o; } private: friend class op_queue_access; // The front of the queue. Operation* front_; // The back of the queue. Operation* back_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_OP_QUEUE_HPP PK��h!\�8��strand_executor_service.hppnu��[��// // detail/strand_executor_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_STRAND_EXECUTOR_SERVICE_HPP #define BOOST_ASIO_DETAIL_STRAND_EXECUTOR_SERVICE_HPP #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/detail/atomic_count.hpp> #include <boost/asio/detail/executor_op.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/mutex.hpp> #include <boost/asio/detail/op_queue.hpp> #include <boost/asio/detail/scheduler_operation.hpp> #include <boost/asio/detail/scoped_ptr.hpp> #include <boost/asio/detail/type_traits.hpp> #include <boost/asio/execution.hpp> #include <boost/asio/execution_context.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { // Default service implementation for a strand. class strand_executor_service : public execution_context_service_base<strand_executor_service> { public: // The underlying implementation of a strand. class strand_impl { public: BOOST_ASIO_DECL ~strand_impl(); private: friend class strand_executor_service; // Mutex to protect access to internal data. mutex* mutex_; // Indicates whether the strand is currently "locked" by a handler. This // means that there is a handler upcall in progress, or that the strand // itself has been scheduled in order to invoke some pending handlers. bool locked_; // Indicates that the strand has been shut down and will accept no further // handlers. bool shutdown_; // The handlers that are waiting on the strand but should not be run until // after the next time the strand is scheduled. This queue must only be // modified while the mutex is locked. op_queue<scheduler_operation> waiting_queue_; // The handlers that are ready to be run. Logically speaking, these are the // handlers that hold the strand's lock. The ready queue is only modified // from within the strand and so may be accessed without locking the mutex. op_queue<scheduler_operation> ready_queue_; // Pointers to adjacent handle implementations in linked list. strand_impl* next_; strand_impl* prev_; // The strand service in where the implementation is held. strand_executor_service* service_; }; typedef shared_ptr<strand_impl> implementation_type; // Construct a new strand service for the specified context. BOOST_ASIO_DECL explicit strand_executor_service(execution_context& context); // Destroy all user-defined handler objects owned by the service. BOOST_ASIO_DECL void shutdown(); // Create a new strand_executor implementation. BOOST_ASIO_DECL implementation_type create_implementation(); // Request invocation of the given function. template <typename Executor, typename Function> static void execute(const implementation_type& impl, Executor& ex, BOOST_ASIO_MOVE_ARG(Function) function, typename enable_if< can_query<Executor, execution::allocator_t<void> >::value >::type* = 0); // Request invocation of the given function. template <typename Executor, typename Function> static void execute(const implementation_type& impl, Executor& ex, BOOST_ASIO_MOVE_ARG(Function) function, typename enable_if< !can_query<Executor, execution::allocator_t<void> >::value >::type* = 0); // Request invocation of the given function. template <typename Executor, typename Function, typename Allocator> static void dispatch(const implementation_type& impl, Executor& ex, BOOST_ASIO_MOVE_ARG(Function) function, const Allocator& a); // Request invocation of the given function and return immediately. template <typename Executor, typename Function, typename Allocator> static void post(const implementation_type& impl, Executor& ex, BOOST_ASIO_MOVE_ARG(Function) function, const Allocator& a); // Request invocation of the given function and return immediately. template <typename Executor, typename Function, typename Allocator> static void defer(const implementation_type& impl, Executor& ex, BOOST_ASIO_MOVE_ARG(Function) function, const Allocator& a); // Determine whether the strand is running in the current thread. BOOST_ASIO_DECL static bool running_in_this_thread( const implementation_type& impl); private: friend class strand_impl; template <typename F, typename Allocator> class allocator_binder; template <typename Executor, typename = void> class invoker; // Adds a function to the strand. Returns true if it acquires the lock. BOOST_ASIO_DECL static bool enqueue(const implementation_type& impl, scheduler_operation* op); // Helper function to request invocation of the given function. template <typename Executor, typename Function, typename Allocator> static void do_execute(const implementation_type& impl, Executor& ex, BOOST_ASIO_MOVE_ARG(Function) function, const Allocator& a); // Mutex to protect access to the service-wide state. mutex mutex_; // Number of mutexes shared between all strand objects. enum { num_mutexes = 193 }; // Pool of mutexes. scoped_ptr<mutex> mutexes_[num_mutexes]; // Extra value used when hashing to prevent recycled memory locations from // getting the same mutex. std::size_t salt_; // The head of a linked list of all implementations. strand_impl* impl_list_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #include <boost/asio/detail/impl/strand_executor_service.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/strand_executor_service.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // BOOST_ASIO_DETAIL_STRAND_EXECUTOR_SERVICE_HPP PK��h!\A�s�t��t��win_iocp_handle_read_op.hppnu��[��// // detail/win_iocp_handle_read_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.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_DETAIL_WIN_IOCP_HANDLE_READ_OP_HPP #define BOOST_ASIO_DETAIL_WIN_IOCP_HANDLE_READ_OP_HPP #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_HAS_IOCP) #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/operation.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename MutableBufferSequence, typename Handler, typename IoExecutor> class win_iocp_handle_read_op : public operation { public: BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_handle_read_op); win_iocp_handle_read_op(const MutableBufferSequence& buffers, Handler& handler, const IoExecutor& io_ex) : operation(&win_iocp_handle_read_op::do_complete), buffers_(buffers), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static void do_complete(void* owner, operation* base, const boost::system::error_code& result_ec, std::size_t bytes_transferred) { boost::system::error_code ec(result_ec); // Take ownership of the operation object. win_iocp_handle_read_op* o(static_cast<win_iocp_handle_read_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) if (owner) { // Check whether buffers are still valid. buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence>::validate(o->buffers_); } #endif // defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) // Map non-portable errors to their portable counterparts. if (ec.value() == ERROR_HANDLE_EOF) ec = boost::asio::error::eof; // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, ec, bytes_transferred); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: MutableBufferSequence buffers_; Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #endif // BOOST_ASIO_DETAIL_WIN_IOCP_HANDLE_READ_OP_HPP PK��h!\�ݢ�'��'��win_iocp_socket_accept_op.hppnu��[��// // detail/win_iocp_socket_accept_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_IOCP_SOCKET_ACCEPT_OP_HPP #define BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_ACCEPT_OP_HPP #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_HAS_IOCP) #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/operation.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/detail/win_iocp_socket_service_base.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Socket, typename Protocol, typename Handler, typename IoExecutor> class win_iocp_socket_accept_op : public operation { public: BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_accept_op); win_iocp_socket_accept_op(win_iocp_socket_service_base& socket_service, socket_type socket, Socket& peer, const Protocol& protocol, typename Protocol::endpoint* peer_endpoint, bool enable_connection_aborted, Handler& handler, const IoExecutor& io_ex) : operation(&win_iocp_socket_accept_op::do_complete), socket_service_(socket_service), socket_(socket), peer_(peer), protocol_(protocol), peer_endpoint_(peer_endpoint), enable_connection_aborted_(enable_connection_aborted), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } socket_holder& new_socket() { return new_socket_; } void* output_buffer() { return output_buffer_; } DWORD address_length() { return sizeof(sockaddr_storage_type) + 16; } static void do_complete(void* owner, operation* base, const boost::system::error_code& result_ec, std::size_t /bytes_transferred/) { boost::system::error_code ec(result_ec); // Take ownership of the operation object. win_iocp_socket_accept_op* o(static_cast<win_iocp_socket_accept_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; if (owner) { typename Protocol::endpoint peer_endpoint; std::size_t addr_len = peer_endpoint.capacity(); socket_ops::complete_iocp_accept(o->socket_, o->output_buffer(), o->address_length(), peer_endpoint.data(), &addr_len, o->new_socket_.get(), ec); // Restart the accept operation if we got the connection_aborted error // and the enable_connection_aborted socket option is not set. if (ec == boost::asio::error::connection_aborted && !o->enable_connection_aborted_) { o->reset(); o->socket_service_.restart_accept_op(o->socket_, o->new_socket_, o->protocol_.family(), o->protocol_.type(), o->protocol_.protocol(), o->output_buffer(), o->address_length(), o); p.v = p.p = 0; return; } // If the socket was successfully accepted, transfer ownership of the // socket to the peer object. if (!ec) { o->peer_.assign(o->protocol_, typename Socket::native_handle_type( o->new_socket_.get(), peer_endpoint), ec); if (!ec) o->new_socket_.release(); } // Pass endpoint back to caller. if (o->peer_endpoint_) o->peer_endpoint_ = peer_endpoint; } BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder1<Handler, boost::system::error_code> handler(o->handler_, ec); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: win_iocp_socket_service_base& socket_service_; socket_type socket_; socket_holder new_socket_; Socket& peer_; Protocol protocol_; typename Protocol::endpoint peer_endpoint_; unsigned char output_buffer_[(sizeof(sockaddr_storage_type) + 16) * 2]; bool enable_connection_aborted_; Handler handler_; handler_work<Handler, IoExecutor> work_; }; #if defined(BOOST_ASIO_HAS_MOVE) template <typename Protocol, typename PeerIoExecutor, typename Handler, typename IoExecutor> class win_iocp_socket_move_accept_op : public operation { public: BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_move_accept_op); win_iocp_socket_move_accept_op( win_iocp_socket_service_base& socket_service, socket_type socket, const Protocol& protocol, const PeerIoExecutor& peer_io_ex, typename Protocol::endpoint* peer_endpoint, bool enable_connection_aborted, Handler& handler, const IoExecutor& io_ex) : operation(&win_iocp_socket_move_accept_op::do_complete), socket_service_(socket_service), socket_(socket), peer_(peer_io_ex), protocol_(protocol), peer_endpoint_(peer_endpoint), enable_connection_aborted_(enable_connection_aborted), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } socket_holder& new_socket() { return new_socket_; } void* output_buffer() { return output_buffer_; } DWORD address_length() { return sizeof(sockaddr_storage_type) + 16; } static void do_complete(void* owner, operation* base, const boost::system::error_code& result_ec, std::size_t /bytes_transferred/) { boost::system::error_code ec(result_ec); // Take ownership of the operation object. win_iocp_socket_move_accept_op* o( static_cast<win_iocp_socket_move_accept_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; if (owner) { typename Protocol::endpoint peer_endpoint; std::size_t addr_len = peer_endpoint.capacity(); socket_ops::complete_iocp_accept(o->socket_, o->output_buffer(), o->address_length(), peer_endpoint.data(), &addr_len, o->new_socket_.get(), ec); // Restart the accept operation if we got the connection_aborted error // and the enable_connection_aborted socket option is not set. if (ec == boost::asio::error::connection_aborted && !o->enable_connection_aborted_) { o->reset(); o->socket_service_.restart_accept_op(o->socket_, o->new_socket_, o->protocol_.family(), o->protocol_.type(), o->protocol_.protocol(), o->output_buffer(), o->address_length(), o); p.v = p.p = 0; return; } // If the socket was successfully accepted, transfer ownership of the // socket to the peer object. if (!ec) { o->peer_.assign(o->protocol_, typename Protocol::socket::native_handle_type( o->new_socket_.get(), peer_endpoint), ec); if (!ec) o->new_socket_.release(); } // Pass endpoint back to caller. if (o->peer_endpoint_) o->peer_endpoint_ = peer_endpoint; } BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::move_binder2<Handler, boost::system::error_code, peer_socket_type> handler(0, BOOST_ASIO_MOVE_CAST(Handler)(o->handler_), ec, BOOST_ASIO_MOVE_CAST(peer_socket_type)(o->peer_)); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "...")); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: typedef typename Protocol::socket::template rebind_executor<PeerIoExecutor>::other peer_socket_type; win_iocp_socket_service_base& socket_service_; socket_type socket_; socket_holder new_socket_; peer_socket_type peer_; Protocol protocol_; typename Protocol::endpoint peer_endpoint_; unsigned char output_buffer_[(sizeof(sockaddr_storage_type) + 16) * 2]; bool enable_connection_aborted_; Handler handler_; handler_work<Handler, IoExecutor> work_; }; #endif // defined(BOOST_ASIO_HAS_MOVE) } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #endif // BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_ACCEPT_OP_HPP PK��h!\ ��functional.hppnu��[��// // detail/functional.hpp // ~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_FUNCTIONAL_HPP #define BOOST_ASIO_DETAIL_FUNCTIONAL_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <functional> #if !defined(BOOST_ASIO_HAS_STD_FUNCTION) # include <boost/function.hpp> #endif // !defined(BOOST_ASIO_HAS_STD_FUNCTION) namespace boost { namespace asio { namespace detail { #if defined(BOOST_ASIO_HAS_STD_FUNCTION) using std::function; #else // defined(BOOST_ASIO_HAS_STD_FUNCTION) using boost::function; #endif // defined(BOOST_ASIO_HAS_STD_FUNCTION) } // namespace detail } // namespace asio } // namespace boost #endif // BOOST_ASIO_DETAIL_FUNCTIONAL_HPP PK��h!\��I�.��.��signal_init.hppnu��[��// // detail/signal_init.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_SIGNAL_INIT_HPP #define BOOST_ASIO_DETAIL_SIGNAL_INIT_HPP #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_WINDOWS) && !defined(__CYGWIN__) #include <csignal> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <int Signal = SIGPIPE> class signal_init { public: // Constructor. signal_init() { std::signal(Signal, SIG_IGN); } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_SIGNAL_INIT_HPP PK��h!\�i�e��resolver_service.hppnu��[��// // detail/resolver_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_RESOLVER_SERVICE_HPP #define BOOST_ASIO_DETAIL_RESOLVER_SERVICE_HPP #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_WINDOWS_RUNTIME) #include <boost/asio/ip/basic_resolver_query.hpp> #include <boost/asio/ip/basic_resolver_results.hpp> #include <boost/asio/detail/concurrency_hint.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/resolve_endpoint_op.hpp> #include <boost/asio/detail/resolve_query_op.hpp> #include <boost/asio/detail/resolver_service_base.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Protocol> class resolver_service : public execution_context_service_base<resolver_service<Protocol> >, public resolver_service_base { public: // The implementation type of the resolver. A cancellation token is used to // indicate to the background thread that the operation has been cancelled. typedef socket_ops::shared_cancel_token_type implementation_type; // The endpoint type. typedef typename Protocol::endpoint endpoint_type; // The query type. typedef boost::asio::ip::basic_resolver_query<Protocol> query_type; // The results type. typedef boost::asio::ip::basic_resolver_results<Protocol> results_type; // Constructor. resolver_service(execution_context& context) : execution_context_service_base<resolver_service<Protocol> >(context), resolver_service_base(context) { } // Destroy all user-defined handler objects owned by the service. void shutdown() { this->base_shutdown(); } // Perform any fork-related housekeeping. void notify_fork(execution_context::fork_event fork_ev) { this->base_notify_fork(fork_ev); } // Resolve a query to a list of entries. results_type resolve(implementation_type&, const query_type& qry, boost::system::error_code& ec) { boost::asio::detail::addrinfo_type* address_info = 0; socket_ops::getaddrinfo(qry.host_name().c_str(), qry.service_name().c_str(), qry.hints(), &address_info, ec); auto_addrinfo auto_address_info(address_info); return ec ? results_type() : results_type::create( address_info, qry.host_name(), qry.service_name()); } // Asynchronously resolve a query to a list of entries. template <typename Handler, typename IoExecutor> void async_resolve(implementation_type& impl, const query_type& qry, Handler& handler, const IoExecutor& io_ex) { // Allocate and construct an operation to wrap the handler. typedef resolve_query_op<Protocol, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(impl, qry, scheduler_, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((scheduler_.context(), p.p, "resolver", &impl, 0, "async_resolve")); start_resolve_op(p.p); p.v = p.p = 0; } // Resolve an endpoint to a list of entries. results_type resolve(implementation_type&, const endpoint_type& endpoint, boost::system::error_code& ec) { char host_name[NI_MAXHOST]; char service_name[NI_MAXSERV]; socket_ops::sync_getnameinfo(endpoint.data(), endpoint.size(), host_name, NI_MAXHOST, service_name, NI_MAXSERV, endpoint.protocol().type(), ec); return ec ? results_type() : results_type::create( endpoint, host_name, service_name); } // Asynchronously resolve an endpoint to a list of entries. template <typename Handler, typename IoExecutor> void async_resolve(implementation_type& impl, const endpoint_type& endpoint, Handler& handler, const IoExecutor& io_ex) { // Allocate and construct an operation to wrap the handler. typedef resolve_endpoint_op<Protocol, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(impl, endpoint, scheduler_, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((scheduler_.context(), p.p, "resolver", &impl, 0, "async_resolve")); start_resolve_op(p.p); p.v = p.p = 0; } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_RESOLVER_SERVICE_HPP PK��h!\x�2<�� std_event.hppnu��[��// // detail/std_event.hpp // ~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_STD_EVENT_HPP #define BOOST_ASIO_DETAIL_STD_EVENT_HPP #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_HAS_STD_MUTEX_AND_CONDVAR) #include <chrono> #include <condition_variable> #include <boost/asio/detail/assert.hpp> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class std_event : private noncopyable { public: // Constructor. std_event() : state_(0) { } // Destructor. ~std_event() { } // Signal the event. (Retained for backward compatibility.) template <typename Lock> void signal(Lock& lock) { this->signal_all(lock); } // Signal all waiters. template <typename Lock> void signal_all(Lock& lock) { BOOST_ASIO_ASSERT(lock.locked()); (void)lock; state_ \|= 1; cond_.notify_all(); } // Unlock the mutex and signal one waiter. template <typename Lock> void unlock_and_signal_one(Lock& lock) { BOOST_ASIO_ASSERT(lock.locked()); state_ \|= 1; bool have_waiters = (state_ > 1); lock.unlock(); if (have_waiters) cond_.notify_one(); } // Unlock the mutex and signal one waiter who may destroy us. template <typename Lock> void unlock_and_signal_one_for_destruction(Lock& lock) { BOOST_ASIO_ASSERT(lock.locked()); state_ \|= 1; bool have_waiters = (state_ > 1); if (have_waiters) cond_.notify_one(); lock.unlock(); } // If there's a waiter, unlock the mutex and signal it. template <typename Lock> bool maybe_unlock_and_signal_one(Lock& lock) { BOOST_ASIO_ASSERT(lock.locked()); state_ \|= 1; if (state_ > 1) { lock.unlock(); cond_.notify_one(); return true; } return false; } // Reset the event. template <typename Lock> void clear(Lock& lock) { BOOST_ASIO_ASSERT(lock.locked()); (void)lock; state_ &= ~std::size_t(1); } // Wait for the event to become signalled. template <typename Lock> void wait(Lock& lock) { BOOST_ASIO_ASSERT(lock.locked()); unique_lock_adapter u_lock(lock); while ((state_ & 1) == 0) { waiter w(state_); cond_.wait(u_lock.unique_lock_); } } // Timed wait for the event to become signalled. template <typename Lock> bool wait_for_usec(Lock& lock, long usec) { BOOST_ASIO_ASSERT(lock.locked()); unique_lock_adapter u_lock(lock); if ((state_ & 1) == 0) { waiter w(state_); cond_.wait_for(u_lock.unique_lock_, std::chrono::microseconds(usec)); } return (state_ & 1) != 0; } private: // Helper class to temporarily adapt a scoped_lock into a unique_lock so that // it can be passed to std::condition_variable::wait(). struct unique_lock_adapter { template <typename Lock> explicit unique_lock_adapter(Lock& lock) : unique_lock_(lock.mutex().mutex_, std::adopt_lock) { } ~unique_lock_adapter() { unique_lock_.release(); } std::unique_lock<std::mutex> unique_lock_; }; // Helper to increment and decrement the state to track outstanding waiters. class waiter { public: explicit waiter(std::size_t& state) : state_(state) { state_ += 2; } ~waiter() { state_ -= 2; } private: std::size_t& state_; }; std::condition_variable cond_; std::size_t state_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) #endif // BOOST_ASIO_DETAIL_STD_EVENT_HPP PK��h!\��win_iocp_thread_info.hppnu��[��// // detail/win_iocp_thread_info.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_IOCP_THREAD_INFO_HPP #define BOOST_ASIO_DETAIL_WIN_IOCP_THREAD_INFO_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/thread_info_base.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { struct win_iocp_thread_info : public thread_info_base { }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_WIN_IOCP_THREAD_INFO_HPP PK��h!\��noncopyable.hppnu��[��// // detail/noncopyable.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_NONCOPYABLE_HPP #define BOOST_ASIO_DETAIL_NONCOPYABLE_HPP #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/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class noncopyable { protected: noncopyable() {} ~noncopyable() {} private: noncopyable(const noncopyable&); const noncopyable& operator=(const noncopyable&); }; } // namespace detail using boost::asio::detail::noncopyable; } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_NONCOPYABLE_HPP PK��h!\�z�X��winrt_timer_scheduler.hppnu��[��// // detail/winrt_timer_scheduler.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WINRT_TIMER_SCHEDULER_HPP #define BOOST_ASIO_DETAIL_WINRT_TIMER_SCHEDULER_HPP #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_WINDOWS_RUNTIME) #include <cstddef> #include <boost/asio/detail/event.hpp> #include <boost/asio/detail/limits.hpp> #include <boost/asio/detail/mutex.hpp> #include <boost/asio/detail/op_queue.hpp> #include <boost/asio/detail/thread.hpp> #include <boost/asio/detail/timer_queue_base.hpp> #include <boost/asio/detail/timer_queue_set.hpp> #include <boost/asio/detail/wait_op.hpp> #include <boost/asio/execution_context.hpp> #if defined(BOOST_ASIO_HAS_IOCP) # include <boost/asio/detail/win_iocp_io_context.hpp> #else // defined(BOOST_ASIO_HAS_IOCP) # include <boost/asio/detail/scheduler.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #if defined(BOOST_ASIO_HAS_IOCP) # include <boost/asio/detail/thread.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class winrt_timer_scheduler : public execution_context_service_base<winrt_timer_scheduler> { public: // Constructor. BOOST_ASIO_DECL winrt_timer_scheduler(execution_context& context); // Destructor. BOOST_ASIO_DECL ~winrt_timer_scheduler(); // Destroy all user-defined handler objects owned by the service. BOOST_ASIO_DECL void shutdown(); // Recreate internal descriptors following a fork. BOOST_ASIO_DECL void notify_fork(execution_context::fork_event fork_ev); // Initialise the task. No effect as this class uses its own thread. BOOST_ASIO_DECL void init_task(); // Add a new timer queue to the reactor. template <typename Time_Traits> void add_timer_queue(timer_queue<Time_Traits>& queue); // Remove a timer queue from the reactor. template <typename Time_Traits> void remove_timer_queue(timer_queue<Time_Traits>& queue); // Schedule a new operation in the given timer queue to expire at the // specified absolute time. template <typename Time_Traits> void schedule_timer(timer_queue<Time_Traits>& queue, const typename Time_Traits::time_type& time, typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op); // Cancel the timer operations associated with the given token. Returns the // number of operations that have been posted or dispatched. template <typename Time_Traits> std::size_t cancel_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& timer, std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)()); // Move the timer operations associated with the given timer. template <typename Time_Traits> void move_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& to, typename timer_queue<Time_Traits>::per_timer_data& from); private: // Run the select loop in the thread. BOOST_ASIO_DECL void run_thread(); // Entry point for the select loop thread. BOOST_ASIO_DECL static void call_run_thread(winrt_timer_scheduler* reactor); // Helper function to add a new timer queue. BOOST_ASIO_DECL void do_add_timer_queue(timer_queue_base& queue); // Helper function to remove a timer queue. BOOST_ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue); // The scheduler implementation used to post completions. #if defined(BOOST_ASIO_HAS_IOCP) typedef class win_iocp_io_context scheduler_impl; #else typedef class scheduler scheduler_impl; #endif scheduler_impl& scheduler_; // Mutex used to protect internal variables. boost::asio::detail::mutex mutex_; // Event used to wake up background thread. boost::asio::detail::event event_; // The timer queues. timer_queue_set timer_queues_; // The background thread that is waiting for timers to expire. boost::asio::detail::thread* thread_; // Does the background thread need to stop. bool stop_thread_; // Whether the service has been shut down. bool shutdown_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #include <boost/asio/detail/impl/winrt_timer_scheduler.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/winrt_timer_scheduler.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_WINRT_TIMER_SCHEDULER_HPP PK��h!\w?��null_mutex.hppnu��[��// // detail/null_mutex.hpp // ~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_NULL_MUTEX_HPP #define BOOST_ASIO_DETAIL_NULL_MUTEX_HPP #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_HAS_THREADS) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/scoped_lock.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class null_mutex : private noncopyable { public: typedef boost::asio::detail::scoped_lock<null_mutex> scoped_lock; // Constructor. null_mutex() { } // Destructor. ~null_mutex() { } // Lock the mutex. void lock() { } // Unlock the mutex. void unlock() { } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // !defined(BOOST_ASIO_HAS_THREADS) #endif // BOOST_ASIO_DETAIL_NULL_MUTEX_HPP PK��h!\gO�)� �� hash_map.hppnu��[��// // detail/hash_map.hpp // ~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_HASH_MAP_HPP #define BOOST_ASIO_DETAIL_HASH_MAP_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <list> #include <utility> #include <boost/asio/detail/assert.hpp> #include <boost/asio/detail/noncopyable.hpp> #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) # include <boost/asio/detail/socket_types.hpp> #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { inline std::size_t calculate_hash_value(int i) { return static_cast<std::size_t>(i); } inline std::size_t calculate_hash_value(void* p) { return reinterpret_cast<std::size_t>(p) + (reinterpret_cast<std::size_t>(p) >> 3); } #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) inline std::size_t calculate_hash_value(SOCKET s) { return static_cast<std::size_t>(s); } #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) // Note: assumes K and V are POD types. template <typename K, typename V> class hash_map : private noncopyable { public: // The type of a value in the map. typedef std::pair<K, V> value_type; // The type of a non-const iterator over the hash map. typedef typename std::list<value_type>::iterator iterator; // The type of a const iterator over the hash map. typedef typename std::list<value_type>::const_iterator const_iterator; // Constructor. hash_map() : size_(0), buckets_(0), num_buckets_(0) { } // Destructor. ~hash_map() { delete[] buckets_; } // Get an iterator for the beginning of the map. iterator begin() { return values_.begin(); } // Get an iterator for the beginning of the map. const_iterator begin() const { return values_.begin(); } // Get an iterator for the end of the map. iterator end() { return values_.end(); } // Get an iterator for the end of the map. const_iterator end() const { return values_.end(); } // Check whether the map is empty. bool empty() const { return values_.empty(); } // Find an entry in the map. iterator find(const K& k) { if (num_buckets_) { size_t bucket = calculate_hash_value(k) % num_buckets_; iterator it = buckets_[bucket].first; if (it == values_.end()) return values_.end(); iterator end_it = buckets_[bucket].last; ++end_it; while (it != end_it) { if (it->first == k) return it; ++it; } } return values_.end(); } // Find an entry in the map. const_iterator find(const K& k) const { if (num_buckets_) { size_t bucket = calculate_hash_value(k) % num_buckets_; const_iterator it = buckets_[bucket].first; if (it == values_.end()) return it; const_iterator end_it = buckets_[bucket].last; ++end_it; while (it != end_it) { if (it->first == k) return it; ++it; } } return values_.end(); } // Insert a new entry into the map. std::pair<iterator, bool> insert(const value_type& v) { if (size_ + 1 >= num_buckets_) rehash(hash_size(size_ + 1)); size_t bucket = calculate_hash_value(v.first) % num_buckets_; iterator it = buckets_[bucket].first; if (it == values_.end()) { buckets_[bucket].first = buckets_[bucket].last = values_insert(values_.end(), v); ++size_; return std::pair<iterator, bool>(buckets_[bucket].last, true); } iterator end_it = buckets_[bucket].last; ++end_it; while (it != end_it) { if (it->first == v.first) return std::pair<iterator, bool>(it, false); ++it; } buckets_[bucket].last = values_insert(end_it, v); ++size_; return std::pair<iterator, bool>(buckets_[bucket].last, true); } // Erase an entry from the map. void erase(iterator it) { BOOST_ASIO_ASSERT(it != values_.end()); BOOST_ASIO_ASSERT(num_buckets_ != 0); size_t bucket = calculate_hash_value(it->first) % num_buckets_; bool is_first = (it == buckets_[bucket].first); bool is_last = (it == buckets_[bucket].last); if (is_first && is_last) buckets_[bucket].first = buckets_[bucket].last = values_.end(); else if (is_first) ++buckets_[bucket].first; else if (is_last) --buckets_[bucket].last; values_erase(it); --size_; } // Erase a key from the map. void erase(const K& k) { iterator it = find(k); if (it != values_.end()) erase(it); } // Remove all entries from the map. void clear() { // Clear the values. values_.clear(); size_ = 0; // Initialise all buckets to empty. iterator end_it = values_.end(); for (size_t i = 0; i < num_buckets_; ++i) buckets_[i].first = buckets_[i].last = end_it; } private: // Calculate the hash size for the specified number of elements. static std::size_t hash_size(std::size_t num_elems) { static std::size_t sizes[] = { #if defined(BOOST_ASIO_HASH_MAP_BUCKETS) BOOST_ASIO_HASH_MAP_BUCKETS #else // BOOST_ASIO_HASH_MAP_BUCKETS 3, 13, 23, 53, 97, 193, 389, 769, 1543, 3079, 6151, 12289, 24593, 49157, 98317, 196613, 393241, 786433, 1572869, 3145739, 6291469, 12582917, 25165843 #endif // BOOST_ASIO_HASH_MAP_BUCKETS }; const std::size_t nth_size = sizeof(sizes) / sizeof(std::size_t) - 1; for (std::size_t i = 0; i < nth_size; ++i) if (num_elems < sizes[i]) return sizes[i]; return sizes[nth_size]; } // Re-initialise the hash from the values already contained in the list. void rehash(std::size_t num_buckets) { if (num_buckets == num_buckets_) return; BOOST_ASIO_ASSERT(num_buckets != 0); iterator end_iter = values_.end(); // Update number of buckets and initialise all buckets to empty. bucket_type* tmp = new bucket_type[num_buckets]; delete[] buckets_; buckets_ = tmp; num_buckets_ = num_buckets; for (std::size_t i = 0; i < num_buckets_; ++i) buckets_[i].first = buckets_[i].last = end_iter; // Put all values back into the hash. iterator iter = values_.begin(); while (iter != end_iter) { std::size_t bucket = calculate_hash_value(iter->first) % num_buckets_; if (buckets_[bucket].last == end_iter) { buckets_[bucket].first = buckets_[bucket].last = iter++; } else if (++buckets_[bucket].last == iter) { ++iter; } else { values_.splice(buckets_[bucket].last, values_, iter++); --buckets_[bucket].last; } } } // Insert an element into the values list by splicing from the spares list, // if a spare is available, and otherwise by inserting a new element. iterator values_insert(iterator it, const value_type& v) { if (spares_.empty()) { return values_.insert(it, v); } else { spares_.front() = v; values_.splice(it, spares_, spares_.begin()); return --it; } } // Erase an element from the values list by splicing it to the spares list. void values_erase(iterator it) { it = value_type(); spares_.splice(spares_.begin(), values_, it); } // The number of elements in the hash. std::size_t size_; // The list of all values in the hash map. std::list<value_type> values_; // The list of spare nodes waiting to be recycled. Assumes that POD types only // are stored in the hash map. std::list<value_type> spares_; // The type for a bucket in the hash table. struct bucket_type { iterator first; iterator last; }; // The buckets in the hash. bucket_type buckets_; // The number of buckets in the hash. std::size_t num_buckets_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_HASH_MAP_HPP PK��h!\Ո��- ��- ��executor_op.hppnu��[��// // detail/executor_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_EXECUTOR_OP_HPP #define BOOST_ASIO_DETAIL_EXECUTOR_OP_HPP #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/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/scheduler_operation.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Handler, typename Alloc, typename Operation = scheduler_operation> class executor_op : public Operation { public: BOOST_ASIO_DEFINE_HANDLER_ALLOCATOR_PTR(executor_op); template <typename H> executor_op(BOOST_ASIO_MOVE_ARG(H) h, const Alloc& allocator) : Operation(&executor_op::do_complete), handler_(BOOST_ASIO_MOVE_CAST(H)(h)), allocator_(allocator) { } static void do_complete(void* owner, Operation* base, const boost::system::error_code& /ec/, std::size_t /bytes_transferred/) { // Take ownership of the handler object. executor_op* o(static_cast<executor_op>(base)); Alloc allocator(o->allocator_); ptr p = { detail::addressof(allocator), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. Handler handler(BOOST_ASIO_MOVE_CAST(Handler)(o->handler_)); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN(()); boost_asio_handler_invoke_helpers::invoke(handler, handler); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: Handler handler_; Alloc allocator_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_EXECUTOR_OP_HPP PK��h!\�[#`��win_thread.hppnu��[��// // detail/win_thread.hpp // ~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_THREAD_HPP #define BOOST_ASIO_DETAIL_WIN_THREAD_HPP #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_WINDOWS) \ && !defined(BOOST_ASIO_WINDOWS_APP) \ && !defined(UNDER_CE) #include <cstddef> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { BOOST_ASIO_DECL unsigned int __stdcall win_thread_function(void* arg); #if defined(WINVER) && (WINVER < 0x0500) BOOST_ASIO_DECL void __stdcall apc_function(ULONG data); #else BOOST_ASIO_DECL void __stdcall apc_function(ULONG_PTR data); #endif template <typename T> class win_thread_base { public: static bool terminate_threads() { return ::InterlockedExchangeAdd(&terminate_threads_, 0) != 0; } static void set_terminate_threads(bool b) { ::InterlockedExchange(&terminate_threads_, b ? 1 : 0); } private: static long terminate_threads_; }; template <typename T> long win_thread_base<T>::terminate_threads_ = 0; class win_thread : private noncopyable, public win_thread_base<win_thread> { public: // Constructor. template <typename Function> win_thread(Function f, unsigned int stack_size = 0) : thread_(0), exit_event_(0) { start_thread(new func<Function>(f), stack_size); } // Destructor. BOOST_ASIO_DECL ~win_thread(); // Wait for the thread to exit. BOOST_ASIO_DECL void join(); // Get number of CPUs. BOOST_ASIO_DECL static std::size_t hardware_concurrency(); private: friend BOOST_ASIO_DECL unsigned int __stdcall win_thread_function(void* arg); #if defined(WINVER) && (WINVER < 0x0500) friend BOOST_ASIO_DECL void __stdcall apc_function(ULONG); #else friend BOOST_ASIO_DECL void __stdcall apc_function(ULONG_PTR); #endif class func_base { public: virtual ~func_base() {} virtual void run() = 0; ::HANDLE entry_event_; ::HANDLE exit_event_; }; struct auto_func_base_ptr { func_base* ptr; ~auto_func_base_ptr() { delete ptr; } }; template <typename Function> class func : public func_base { public: func(Function f) : f_(f) { } virtual void run() { f_(); } private: Function f_; }; BOOST_ASIO_DECL void start_thread(func_base* arg, unsigned int stack_size); ::HANDLE thread_; ::HANDLE exit_event_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/win_thread.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_WINDOWS) // && !defined(BOOST_ASIO_WINDOWS_APP) // && !defined(UNDER_CE) #endif // BOOST_ASIO_DETAIL_WIN_THREAD_HPP PK��h!\�R`��gcc_arm_fenced_block.hppnu��[��// // detail/gcc_arm_fenced_block.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_GCC_ARM_FENCED_BLOCK_HPP #define BOOST_ASIO_DETAIL_GCC_ARM_FENCED_BLOCK_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(__GNUC__) && defined(__arm__) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class gcc_arm_fenced_block : private noncopyable { public: enum half_t { half }; enum full_t { full }; // Constructor for a half fenced block. explicit gcc_arm_fenced_block(half_t) { } // Constructor for a full fenced block. explicit gcc_arm_fenced_block(full_t) { barrier(); } // Destructor. ~gcc_arm_fenced_block() { barrier(); } private: static void barrier() { #if defined(__ARM_ARCH_4__) \ \|\| defined(__ARM_ARCH_4T__) \ \|\| defined(__ARM_ARCH_5__) \ \|\| defined(__ARM_ARCH_5E__) \ \|\| defined(__ARM_ARCH_5T__) \ \|\| defined(__ARM_ARCH_5TE__) \ \|\| defined(__ARM_ARCH_5TEJ__) \ \|\| defined(__ARM_ARCH_6__) \ \|\| defined(__ARM_ARCH_6J__) \ \|\| defined(__ARM_ARCH_6K__) \ \|\| defined(__ARM_ARCH_6Z__) \ \|\| defined(__ARM_ARCH_6ZK__) \ \|\| defined(__ARM_ARCH_6T2__) # if defined(__thumb__) // This is just a placeholder and almost certainly not sufficient. __asm__ __volatile__ ("" : : : "memory"); # else // defined(__thumb__) int a = 0, b = 0; __asm__ __volatile__ ("swp %0, %1, [%2]" : "=&r"(a) : "r"(1), "r"(&b) : "memory", "cc"); # endif // defined(__thumb__) #else // ARMv7 and later. __asm__ __volatile__ ("dmb" : : : "memory"); #endif } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(__GNUC__) && defined(__arm__) #endif // BOOST_ASIO_DETAIL_GCC_ARM_FENCED_BLOCK_HPP PK��h!\fGS�$��$��impl/select_reactor.ippnu��[��// // detail/impl/select_reactor.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_SELECT_REACTOR_IPP #define BOOST_ASIO_DETAIL_IMPL_SELECT_REACTOR_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_HAS_IOCP) \ \|\| (!defined(BOOST_ASIO_HAS_DEV_POLL) \ && !defined(BOOST_ASIO_HAS_EPOLL) \ && !defined(BOOST_ASIO_HAS_KQUEUE) \ && !defined(BOOST_ASIO_WINDOWS_RUNTIME)) #include <boost/asio/detail/fd_set_adapter.hpp> #include <boost/asio/detail/select_reactor.hpp> #include <boost/asio/detail/signal_blocker.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { #if defined(BOOST_ASIO_HAS_IOCP) class select_reactor::thread_function { public: explicit thread_function(select_reactor* r) : this_(r) { } void operator()() { this_->run_thread(); } private: select_reactor* this_; }; #endif // defined(BOOST_ASIO_HAS_IOCP) select_reactor::select_reactor(boost::asio::execution_context& ctx) : execution_context_service_base<select_reactor>(ctx), scheduler_(use_service<scheduler_type>(ctx)), mutex_(), interrupter_(), #if defined(BOOST_ASIO_HAS_IOCP) stop_thread_(false), thread_(0), #endif // defined(BOOST_ASIO_HAS_IOCP) shutdown_(false) { #if defined(BOOST_ASIO_HAS_IOCP) boost::asio::detail::signal_blocker sb; thread_ = new boost::asio::detail::thread(thread_function(this)); #endif // defined(BOOST_ASIO_HAS_IOCP) } select_reactor::~select_reactor() { shutdown(); } void select_reactor::shutdown() { boost::asio::detail::mutex::scoped_lock lock(mutex_); shutdown_ = true; #if defined(BOOST_ASIO_HAS_IOCP) stop_thread_ = true; if (thread_) interrupter_.interrupt(); #endif // defined(BOOST_ASIO_HAS_IOCP) lock.unlock(); #if defined(BOOST_ASIO_HAS_IOCP) if (thread_) { thread_->join(); delete thread_; thread_ = 0; } #endif // defined(BOOST_ASIO_HAS_IOCP) op_queue<operation> ops; for (int i = 0; i < max_ops; ++i) op_queue_[i].get_all_operations(ops); timer_queues_.get_all_timers(ops); scheduler_.abandon_operations(ops); } void select_reactor::notify_fork( boost::asio::execution_context::fork_event fork_ev) { if (fork_ev == boost::asio::execution_context::fork_child) interrupter_.recreate(); } void select_reactor::init_task() { scheduler_.init_task(); } int select_reactor::register_descriptor(socket_type, select_reactor::per_descriptor_data&) { return 0; } int select_reactor::register_internal_descriptor( int op_type, socket_type descriptor, select_reactor::per_descriptor_data&, reactor_op* op) { boost::asio::detail::mutex::scoped_lock lock(mutex_); op_queue_[op_type].enqueue_operation(descriptor, op); interrupter_.interrupt(); return 0; } void select_reactor::move_descriptor(socket_type, select_reactor::per_descriptor_data&, select_reactor::per_descriptor_data&) { } void select_reactor::start_op(int op_type, socket_type descriptor, select_reactor::per_descriptor_data&, reactor_op* op, bool is_continuation, bool) { boost::asio::detail::mutex::scoped_lock lock(mutex_); if (shutdown_) { post_immediate_completion(op, is_continuation); return; } bool first = op_queue_[op_type].enqueue_operation(descriptor, op); scheduler_.work_started(); if (first) interrupter_.interrupt(); } void select_reactor::cancel_ops(socket_type descriptor, select_reactor::per_descriptor_data&) { boost::asio::detail::mutex::scoped_lock lock(mutex_); cancel_ops_unlocked(descriptor, boost::asio::error::operation_aborted); } void select_reactor::deregister_descriptor(socket_type descriptor, select_reactor::per_descriptor_data&, bool) { boost::asio::detail::mutex::scoped_lock lock(mutex_); cancel_ops_unlocked(descriptor, boost::asio::error::operation_aborted); } void select_reactor::deregister_internal_descriptor( socket_type descriptor, select_reactor::per_descriptor_data&) { boost::asio::detail::mutex::scoped_lock lock(mutex_); op_queue<operation> ops; for (int i = 0; i < max_ops; ++i) op_queue_[i].cancel_operations(descriptor, ops); } void select_reactor::cleanup_descriptor_data( select_reactor::per_descriptor_data&) { } void select_reactor::run(long usec, op_queue<operation>& ops) { boost::asio::detail::mutex::scoped_lock lock(mutex_); #if defined(BOOST_ASIO_HAS_IOCP) // Check if the thread is supposed to stop. if (stop_thread_) return; #endif // defined(BOOST_ASIO_HAS_IOCP) // Set up the descriptor sets. for (int i = 0; i < max_select_ops; ++i) fd_sets_[i].reset(); fd_sets_[read_op].set(interrupter_.read_descriptor()); socket_type max_fd = 0; bool have_work_to_do = !timer_queues_.all_empty(); for (int i = 0; i < max_select_ops; ++i) { have_work_to_do = have_work_to_do \|\| !op_queue_[i].empty(); fd_sets_[i].set(op_queue_[i], ops); if (fd_sets_[i].max_descriptor() > max_fd) max_fd = fd_sets_[i].max_descriptor(); } #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) // Connection operations on Windows use both except and write fd_sets. have_work_to_do = have_work_to_do \|\| !op_queue_[connect_op].empty(); fd_sets_[write_op].set(op_queue_[connect_op], ops); if (fd_sets_[write_op].max_descriptor() > max_fd) max_fd = fd_sets_[write_op].max_descriptor(); fd_sets_[except_op].set(op_queue_[connect_op], ops); if (fd_sets_[except_op].max_descriptor() > max_fd) max_fd = fd_sets_[except_op].max_descriptor(); #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) // We can return immediately if there's no work to do and the reactor is // not supposed to block. if (!usec && !have_work_to_do) return; // Determine how long to block while waiting for events. timeval tv_buf = { 0, 0 }; timeval* tv = usec ? get_timeout(usec, tv_buf) : &tv_buf; lock.unlock(); // Block on the select call until descriptors become ready. boost::system::error_code ec; int retval = socket_ops::select(static_cast<int>(max_fd + 1), fd_sets_[read_op], fd_sets_[write_op], fd_sets_[except_op], tv, ec); // Reset the interrupter. if (retval > 0 && fd_sets_[read_op].is_set(interrupter_.read_descriptor())) { if (!interrupter_.reset()) { lock.lock(); interrupter_.recreate(); } --retval; } lock.lock(); // Dispatch all ready operations. if (retval > 0) { #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) // Connection operations on Windows use both except and write fd_sets. fd_sets_[except_op].perform(op_queue_[connect_op], ops); fd_sets_[write_op].perform(op_queue_[connect_op], ops); #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) // Exception operations must be processed first to ensure that any // out-of-band data is read before normal data. for (int i = max_select_ops - 1; i >= 0; --i) fd_sets_[i].perform(op_queue_[i], ops); } timer_queues_.get_ready_timers(ops); } void select_reactor::interrupt() { interrupter_.interrupt(); } #if defined(BOOST_ASIO_HAS_IOCP) void select_reactor::run_thread() { boost::asio::detail::mutex::scoped_lock lock(mutex_); while (!stop_thread_) { lock.unlock(); op_queue<operation> ops; run(true, ops); scheduler_.post_deferred_completions(ops); lock.lock(); } } #endif // defined(BOOST_ASIO_HAS_IOCP) void select_reactor::do_add_timer_queue(timer_queue_base& queue) { mutex::scoped_lock lock(mutex_); timer_queues_.insert(&queue); } void select_reactor::do_remove_timer_queue(timer_queue_base& queue) { mutex::scoped_lock lock(mutex_); timer_queues_.erase(&queue); } timeval* select_reactor::get_timeout(long usec, timeval& tv) { // By default we will wait no longer than 5 minutes. This will ensure that // any changes to the system clock are detected after no longer than this. const long max_usec = 5 * 60 * 1000 * 1000; usec = timer_queues_.wait_duration_usec( (usec < 0 \|\| max_usec < usec) ? max_usec : usec); tv.tv_sec = usec / 1000000; tv.tv_usec = usec % 1000000; return &tv; } void select_reactor::cancel_ops_unlocked(socket_type descriptor, const boost::system::error_code& ec) { bool need_interrupt = false; op_queue<operation> ops; for (int i = 0; i < max_ops; ++i) need_interrupt = op_queue_[i].cancel_operations( descriptor, ops, ec) \|\| need_interrupt; scheduler_.post_deferred_completions(ops); if (need_interrupt) interrupter_.interrupt(); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) // \|\| (!defined(BOOST_ASIO_HAS_DEV_POLL) // && !defined(BOOST_ASIO_HAS_EPOLL) // && !defined(BOOST_ASIO_HAS_KQUEUE)) // && !defined(BOOST_ASIO_WINDOWS_RUNTIME)) #endif // BOOST_ASIO_DETAIL_IMPL_SELECT_REACTOR_IPP PK��h!\�<��3��3��impl/resolver_service_base.ippnu��[��// // detail/impl/resolver_service_base.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_RESOLVER_SERVICE_BASE_IPP #define BOOST_ASIO_DETAIL_IMPL_RESOLVER_SERVICE_BASE_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/detail/resolver_service_base.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class resolver_service_base::work_scheduler_runner { public: work_scheduler_runner(scheduler_impl& work_scheduler) : work_scheduler_(work_scheduler) { } void operator()() { boost::system::error_code ec; work_scheduler_.run(ec); } private: scheduler_impl& work_scheduler_; }; resolver_service_base::resolver_service_base(execution_context& context) : scheduler_(boost::asio::use_service<scheduler_impl>(context)), work_scheduler_(new scheduler_impl(context, -1, false)), work_thread_(0) { work_scheduler_->work_started(); } resolver_service_base::~resolver_service_base() { base_shutdown(); } void resolver_service_base::base_shutdown() { if (work_scheduler_.get()) { work_scheduler_->work_finished(); work_scheduler_->stop(); if (work_thread_.get()) { work_thread_->join(); work_thread_.reset(); } work_scheduler_.reset(); } } void resolver_service_base::base_notify_fork( execution_context::fork_event fork_ev) { if (work_thread_.get()) { if (fork_ev == execution_context::fork_prepare) { work_scheduler_->stop(); work_thread_->join(); work_thread_.reset(); } } else if (fork_ev != execution_context::fork_prepare) { work_scheduler_->restart(); } } void resolver_service_base::construct( resolver_service_base::implementation_type& impl) { impl.reset(static_cast<void>(0), socket_ops::noop_deleter()); } void resolver_service_base::destroy( resolver_service_base::implementation_type& impl) { BOOST_ASIO_HANDLER_OPERATION((scheduler_.context(), "resolver", &impl, 0, "cancel")); impl.reset(); } void resolver_service_base::move_construct(implementation_type& impl, implementation_type& other_impl) { impl = BOOST_ASIO_MOVE_CAST(implementation_type)(other_impl); } void resolver_service_base::move_assign(implementation_type& impl, resolver_service_base&, implementation_type& other_impl) { destroy(impl); impl = BOOST_ASIO_MOVE_CAST(implementation_type)(other_impl); } void resolver_service_base::cancel( resolver_service_base::implementation_type& impl) { BOOST_ASIO_HANDLER_OPERATION((scheduler_.context(), "resolver", &impl, 0, "cancel")); impl.reset(static_cast<void>(0), socket_ops::noop_deleter()); } void resolver_service_base::start_resolve_op(resolve_op* op) { if (BOOST_ASIO_CONCURRENCY_HINT_IS_LOCKING(SCHEDULER, scheduler_.concurrency_hint())) { start_work_thread(); scheduler_.work_started(); work_scheduler_->post_immediate_completion(op, false); } else { op->ec_ = boost::asio::error::operation_not_supported; scheduler_.post_immediate_completion(op, false); } } void resolver_service_base::start_work_thread() { boost::asio::detail::mutex::scoped_lock lock(mutex_); if (!work_thread_.get()) { work_thread_.reset(new boost::asio::detail::thread( work_scheduler_runner(work_scheduler_))); } } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_IMPL_RESOLVER_SERVICE_BASE_IPP PK��h!\�5G� �� impl/epoll_reactor.hppnu��[��// // detail/impl/epoll_reactor.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_EPOLL_REACTOR_HPP #define BOOST_ASIO_DETAIL_IMPL_EPOLL_REACTOR_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #if defined(BOOST_ASIO_HAS_EPOLL) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Time_Traits> void epoll_reactor::add_timer_queue(timer_queue<Time_Traits>& queue) { do_add_timer_queue(queue); } template <typename Time_Traits> void epoll_reactor::remove_timer_queue(timer_queue<Time_Traits>& queue) { do_remove_timer_queue(queue); } template <typename Time_Traits> void epoll_reactor::schedule_timer(timer_queue<Time_Traits>& queue, const typename Time_Traits::time_type& time, typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op op) { mutex::scoped_lock lock(mutex_); if (shutdown_) { scheduler_.post_immediate_completion(op, false); return; } bool earliest = queue.enqueue_timer(time, timer, op); scheduler_.work_started(); if (earliest) update_timeout(); } template <typename Time_Traits> std::size_t epoll_reactor::cancel_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& timer, std::size_t max_cancelled) { mutex::scoped_lock lock(mutex_); op_queue<operation> ops; std::size_t n = queue.cancel_timer(timer, ops, max_cancelled); lock.unlock(); scheduler_.post_deferred_completions(ops); return n; } template <typename Time_Traits> void epoll_reactor::move_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& target, typename timer_queue<Time_Traits>::per_timer_data& source) { mutex::scoped_lock lock(mutex_); op_queue<operation> ops; queue.cancel_timer(target, ops); queue.move_timer(target, source); lock.unlock(); scheduler_.post_deferred_completions(ops); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_EPOLL) #endif // BOOST_ASIO_DETAIL_IMPL_EPOLL_REACTOR_HPP PK��h!\��o��:��:��impl/descriptor_ops.ippnu��[��// // detail/impl/descriptor_ops.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_DESCRIPTOR_OPS_IPP #define BOOST_ASIO_DETAIL_IMPL_DESCRIPTOR_OPS_IPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <cerrno> #include <boost/asio/detail/descriptor_ops.hpp> #include <boost/asio/error.hpp> #if !defined(BOOST_ASIO_WINDOWS) \ && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ && !defined(__CYGWIN__) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { namespace descriptor_ops { int open(const char* path, int flags, boost::system::error_code& ec) { int result = ::open(path, flags); get_last_error(ec, result < 0); return result; } int close(int d, state_type& state, boost::system::error_code& ec) { int result = 0; if (d != -1) { result = ::close(d); get_last_error(ec, result < 0); if (result != 0 && (ec == boost::asio::error::would_block \|\| ec == boost::asio::error::try_again)) { // According to UNIX Network Programming Vol. 1, it is possible for // close() to fail with EWOULDBLOCK under certain circumstances. What // isn't clear is the state of the descriptor after this error. The one // current OS where this behaviour is seen, Windows, says that the socket // remains open. Therefore we'll put the descriptor back into blocking // mode and have another attempt at closing it. #if defined(__SYMBIAN32__) \|\| defined(__EMSCRIPTEN__) int flags = ::fcntl(d, F_GETFL, 0); if (flags >= 0) ::fcntl(d, F_SETFL, flags & ~O_NONBLOCK); #else // defined(__SYMBIAN32__) \|\| defined(__EMSCRIPTEN__) ioctl_arg_type arg = 0; ::ioctl(d, FIONBIO, &arg); #endif // defined(__SYMBIAN32__) \|\| defined(__EMSCRIPTEN__) state &= ~non_blocking; result = ::close(d); get_last_error(ec, result < 0); } } return result; } bool set_user_non_blocking(int d, state_type& state, bool value, boost::system::error_code& ec) { if (d == -1) { ec = boost::asio::error::bad_descriptor; return false; } #if defined(__SYMBIAN32__) \|\| defined(__EMSCRIPTEN__) int result = ::fcntl(d, F_GETFL, 0); get_last_error(ec, result < 0); if (result >= 0) { int flag = (value ? (result \| O_NONBLOCK) : (result & ~O_NONBLOCK)); result = ::fcntl(d, F_SETFL, flag); get_last_error(ec, result < 0); } #else // defined(__SYMBIAN32__) \|\| defined(__EMSCRIPTEN__) ioctl_arg_type arg = (value ? 1 : 0); int result = ::ioctl(d, FIONBIO, &arg); get_last_error(ec, result < 0); #endif // defined(__SYMBIAN32__) \|\| defined(__EMSCRIPTEN__) if (result >= 0) { if (value) state \|= user_set_non_blocking; else { // Clearing the user-set non-blocking mode always overrides any // internally-set non-blocking flag. Any subsequent asynchronous // operations will need to re-enable non-blocking I/O. state &= ~(user_set_non_blocking \| internal_non_blocking); } return true; } return false; } bool set_internal_non_blocking(int d, state_type& state, bool value, boost::system::error_code& ec) { if (d == -1) { ec = boost::asio::error::bad_descriptor; return false; } if (!value && (state & user_set_non_blocking)) { // It does not make sense to clear the internal non-blocking flag if the // user still wants non-blocking behaviour. Return an error and let the // caller figure out whether to update the user-set non-blocking flag. ec = boost::asio::error::invalid_argument; return false; } #if defined(__SYMBIAN32__) \|\| defined(__EMSCRIPTEN__) int result = ::fcntl(d, F_GETFL, 0); get_last_error(ec, result < 0); if (result >= 0) { int flag = (value ? (result \| O_NONBLOCK) : (result & ~O_NONBLOCK)); result = ::fcntl(d, F_SETFL, flag); get_last_error(ec, result < 0); } #else // defined(__SYMBIAN32__) \|\| defined(__EMSCRIPTEN__) ioctl_arg_type arg = (value ? 1 : 0); int result = ::ioctl(d, FIONBIO, &arg); get_last_error(ec, result < 0); #endif // defined(__SYMBIAN32__) \|\| defined(__EMSCRIPTEN__) if (result >= 0) { if (value) state \|= internal_non_blocking; else state &= ~internal_non_blocking; return true; } return false; } std::size_t sync_read(int d, state_type state, buf* bufs, std::size_t count, bool all_empty, boost::system::error_code& ec) { if (d == -1) { ec = boost::asio::error::bad_descriptor; return 0; } // A request to read 0 bytes on a stream is a no-op. if (all_empty) { ec.assign(0, ec.category()); return 0; } // Read some data. for (;;) { // Try to complete the operation without blocking. signed_size_type bytes = ::readv(d, bufs, static_cast<int>(count)); get_last_error(ec, bytes < 0); // Check if operation succeeded. if (bytes > 0) return bytes; // Check for EOF. if (bytes == 0) { ec = boost::asio::error::eof; return 0; } // Operation failed. if ((state & user_set_non_blocking) \|\| (ec != boost::asio::error::would_block && ec != boost::asio::error::try_again)) return 0; // Wait for descriptor to become ready. if (descriptor_ops::poll_read(d, 0, ec) < 0) return 0; } } std::size_t sync_read1(int d, state_type state, void* data, std::size_t size, boost::system::error_code& ec) { if (d == -1) { ec = boost::asio::error::bad_descriptor; return 0; } // A request to read 0 bytes on a stream is a no-op. if (size == 0) { ec.assign(0, ec.category()); return 0; } // Read some data. for (;;) { // Try to complete the operation without blocking. signed_size_type bytes = ::read(d, data, size); get_last_error(ec, bytes < 0); // Check if operation succeeded. if (bytes > 0) return bytes; // Check for EOF. if (bytes == 0) { ec = boost::asio::error::eof; return 0; } // Operation failed. if ((state & user_set_non_blocking) \|\| (ec != boost::asio::error::would_block && ec != boost::asio::error::try_again)) return 0; // Wait for descriptor to become ready. if (descriptor_ops::poll_read(d, 0, ec) < 0) return 0; } } bool non_blocking_read(int d, buf* bufs, std::size_t count, boost::system::error_code& ec, std::size_t& bytes_transferred) { for (;;) { // Read some data. signed_size_type bytes = ::readv(d, bufs, static_cast<int>(count)); get_last_error(ec, bytes < 0); // Check for end of stream. if (bytes == 0) { ec = boost::asio::error::eof; return true; } // Check if operation succeeded. if (bytes > 0) { bytes_transferred = bytes; return true; } // Retry operation if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block \|\| ec == boost::asio::error::try_again) return false; // Operation failed. bytes_transferred = 0; return true; } } bool non_blocking_read1(int d, void* data, std::size_t size, boost::system::error_code& ec, std::size_t& bytes_transferred) { for (;;) { // Read some data. signed_size_type bytes = ::read(d, data, size); get_last_error(ec, bytes < 0); // Check for end of stream. if (bytes == 0) { ec = boost::asio::error::eof; return true; } // Check if operation succeeded. if (bytes > 0) { bytes_transferred = bytes; return true; } // Retry operation if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block \|\| ec == boost::asio::error::try_again) return false; // Operation failed. bytes_transferred = 0; return true; } } std::size_t sync_write(int d, state_type state, const buf* bufs, std::size_t count, bool all_empty, boost::system::error_code& ec) { if (d == -1) { ec = boost::asio::error::bad_descriptor; return 0; } // A request to write 0 bytes on a stream is a no-op. if (all_empty) { ec.assign(0, ec.category()); return 0; } // Write some data. for (;;) { // Try to complete the operation without blocking. signed_size_type bytes = ::writev(d, bufs, static_cast<int>(count)); get_last_error(ec, bytes < 0); // Check if operation succeeded. if (bytes > 0) return bytes; // Operation failed. if ((state & user_set_non_blocking) \|\| (ec != boost::asio::error::would_block && ec != boost::asio::error::try_again)) return 0; // Wait for descriptor to become ready. if (descriptor_ops::poll_write(d, 0, ec) < 0) return 0; } } std::size_t sync_write1(int d, state_type state, const void* data, std::size_t size, boost::system::error_code& ec) { if (d == -1) { ec = boost::asio::error::bad_descriptor; return 0; } // A request to write 0 bytes on a stream is a no-op. if (size == 0) { ec.assign(0, ec.category()); return 0; } // Write some data. for (;;) { // Try to complete the operation without blocking. signed_size_type bytes = ::write(d, data, size); get_last_error(ec, bytes < 0); // Check if operation succeeded. if (bytes > 0) return bytes; // Operation failed. if ((state & user_set_non_blocking) \|\| (ec != boost::asio::error::would_block && ec != boost::asio::error::try_again)) return 0; // Wait for descriptor to become ready. if (descriptor_ops::poll_write(d, 0, ec) < 0) return 0; } } bool non_blocking_write(int d, const buf* bufs, std::size_t count, boost::system::error_code& ec, std::size_t& bytes_transferred) { for (;;) { // Write some data. signed_size_type bytes = ::writev(d, bufs, static_cast<int>(count)); get_last_error(ec, bytes < 0); // Check if operation succeeded. if (bytes >= 0) { bytes_transferred = bytes; return true; } // Retry operation if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block \|\| ec == boost::asio::error::try_again) return false; // Operation failed. bytes_transferred = 0; return true; } } bool non_blocking_write1(int d, const void* data, std::size_t size, boost::system::error_code& ec, std::size_t& bytes_transferred) { for (;;) { // Write some data. signed_size_type bytes = ::write(d, data, size); get_last_error(ec, bytes < 0); // Check if operation succeeded. if (bytes >= 0) { bytes_transferred = bytes; return true; } // Retry operation if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block \|\| ec == boost::asio::error::try_again) return false; // Operation failed. bytes_transferred = 0; return true; } } int ioctl(int d, state_type& state, long cmd, ioctl_arg_type* arg, boost::system::error_code& ec) { if (d == -1) { ec = boost::asio::error::bad_descriptor; return -1; } int result = ::ioctl(d, cmd, arg); get_last_error(ec, result < 0); if (result >= 0) { // When updating the non-blocking mode we always perform the ioctl syscall, // even if the flags would otherwise indicate that the descriptor is // already in the correct state. This ensures that the underlying // descriptor is put into the state that has been requested by the user. If // the ioctl syscall was successful then we need to update the flags to // match. if (cmd == static_cast<long>(FIONBIO)) { if (arg) { state \|= user_set_non_blocking; } else { // Clearing the non-blocking mode always overrides any internally-set // non-blocking flag. Any subsequent asynchronous operations will need // to re-enable non-blocking I/O. state &= ~(user_set_non_blocking \| internal_non_blocking); } } } return result; } int fcntl(int d, int cmd, boost::system::error_code& ec) { if (d == -1) { ec = boost::asio::error::bad_descriptor; return -1; } int result = ::fcntl(d, cmd); get_last_error(ec, result < 0); return result; } int fcntl(int d, int cmd, long arg, boost::system::error_code& ec) { if (d == -1) { ec = boost::asio::error::bad_descriptor; return -1; } int result = ::fcntl(d, cmd, arg); get_last_error(ec, result < 0); return result; } int poll_read(int d, state_type state, boost::system::error_code& ec) { if (d == -1) { ec = boost::asio::error::bad_descriptor; return -1; } pollfd fds; fds.fd = d; fds.events = POLLIN; fds.revents = 0; int timeout = (state & user_set_non_blocking) ? 0 : -1; int result = ::poll(&fds, 1, timeout); get_last_error(ec, result < 0); if (result == 0) if (state & user_set_non_blocking) ec = boost::asio::error::would_block; return result; } int poll_write(int d, state_type state, boost::system::error_code& ec) { if (d == -1) { ec = boost::asio::error::bad_descriptor; return -1; } pollfd fds; fds.fd = d; fds.events = POLLOUT; fds.revents = 0; int timeout = (state & user_set_non_blocking) ? 0 : -1; int result = ::poll(&fds, 1, timeout); get_last_error(ec, result < 0); if (result == 0) if (state & user_set_non_blocking) ec = boost::asio::error::would_block; return result; } int poll_error(int d, state_type state, boost::system::error_code& ec) { if (d == -1) { ec = boost::asio::error::bad_descriptor; return -1; } pollfd fds; fds.fd = d; fds.events = POLLPRI \| POLLERR \| POLLHUP; fds.revents = 0; int timeout = (state & user_set_non_blocking) ? 0 : -1; int result = ::poll(&fds, 1, timeout); get_last_error(ec, result < 0); if (result == 0) if (state & user_set_non_blocking) ec = boost::asio::error::would_block; return result; } } // namespace descriptor_ops } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // !defined(BOOST_ASIO_WINDOWS) // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) // && !defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_IMPL_DESCRIPTOR_OPS_IPP PK��h!\N��!j ��j ��impl/timer_queue_ptime.ippnu��[��// // detail/impl/timer_queue_ptime.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_TIMER_QUEUE_PTIME_IPP #define BOOST_ASIO_DETAIL_IMPL_TIMER_QUEUE_PTIME_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_HAS_BOOST_DATE_TIME) #include <boost/asio/detail/timer_queue_ptime.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { timer_queue<time_traits<boost::posix_time::ptime> >::timer_queue() { } timer_queue<time_traits<boost::posix_time::ptime> >::~timer_queue() { } bool timer_queue<time_traits<boost::posix_time::ptime> >::enqueue_timer( const time_type& time, per_timer_data& timer, wait_op op) { return impl_.enqueue_timer(time, timer, op); } bool timer_queue<time_traits<boost::posix_time::ptime> >::empty() const { return impl_.empty(); } long timer_queue<time_traits<boost::posix_time::ptime> >::wait_duration_msec( long max_duration) const { return impl_.wait_duration_msec(max_duration); } long timer_queue<time_traits<boost::posix_time::ptime> >::wait_duration_usec( long max_duration) const { return impl_.wait_duration_usec(max_duration); } void timer_queue<time_traits<boost::posix_time::ptime> >::get_ready_timers( op_queue<operation>& ops) { impl_.get_ready_timers(ops); } void timer_queue<time_traits<boost::posix_time::ptime> >::get_all_timers( op_queue<operation>& ops) { impl_.get_all_timers(ops); } std::size_t timer_queue<time_traits<boost::posix_time::ptime> >::cancel_timer( per_timer_data& timer, op_queue<operation>& ops, std::size_t max_cancelled) { return impl_.cancel_timer(timer, ops, max_cancelled); } void timer_queue<time_traits<boost::posix_time::ptime> >::move_timer( per_timer_data& target, per_timer_data& source) { impl_.move_timer(target, source); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) #endif // BOOST_ASIO_DETAIL_IMPL_TIMER_QUEUE_PTIME_IPP PK��h!\gWU�@��@��impl/win_iocp_io_context.ippnu��[��// // detail/impl/win_iocp_io_context.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_WIN_IOCP_IO_CONTEXT_IPP #define BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_IO_CONTEXT_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_HAS_IOCP) #include <boost/asio/error.hpp> #include <boost/asio/detail/cstdint.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/limits.hpp> #include <boost/asio/detail/thread.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/detail/win_iocp_io_context.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { struct win_iocp_io_context::thread_function { explicit thread_function(win_iocp_io_context* s) : this_(s) { } void operator()() { boost::system::error_code ec; this_->run(ec); } win_iocp_io_context* this_; }; struct win_iocp_io_context::work_finished_on_block_exit { ~work_finished_on_block_exit() { io_context_->work_finished(); } win_iocp_io_context* io_context_; }; struct win_iocp_io_context::timer_thread_function { void operator()() { while (::InterlockedExchangeAdd(&io_context_->shutdown_, 0) == 0) { if (::WaitForSingleObject(io_context_->waitable_timer_.handle, INFINITE) == WAIT_OBJECT_0) { ::InterlockedExchange(&io_context_->dispatch_required_, 1); ::PostQueuedCompletionStatus(io_context_->iocp_.handle, 0, wake_for_dispatch, 0); } } } win_iocp_io_context* io_context_; }; win_iocp_io_context::win_iocp_io_context( boost::asio::execution_context& ctx, int concurrency_hint, bool own_thread) : execution_context_service_base<win_iocp_io_context>(ctx), iocp_(), outstanding_work_(0), stopped_(0), stop_event_posted_(0), shutdown_(0), gqcs_timeout_(get_gqcs_timeout()), dispatch_required_(0), concurrency_hint_(concurrency_hint) { BOOST_ASIO_HANDLER_TRACKING_INIT; iocp_.handle = ::CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0, static_cast<DWORD>(concurrency_hint >= 0 ? concurrency_hint : DWORD(~0))); if (!iocp_.handle) { DWORD last_error = ::GetLastError(); boost::system::error_code ec(last_error, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "iocp"); } if (own_thread) { ::InterlockedIncrement(&outstanding_work_); thread_.reset(new boost::asio::detail::thread(thread_function(this))); } } win_iocp_io_context::~win_iocp_io_context() { if (thread_.get()) { stop(); thread_->join(); thread_.reset(); } } void win_iocp_io_context::shutdown() { ::InterlockedExchange(&shutdown_, 1); if (timer_thread_.get()) { LARGE_INTEGER timeout; timeout.QuadPart = 1; ::SetWaitableTimer(waitable_timer_.handle, &timeout, 1, 0, 0, FALSE); } if (thread_.get()) { stop(); thread_->join(); thread_.reset(); ::InterlockedDecrement(&outstanding_work_); } while (::InterlockedExchangeAdd(&outstanding_work_, 0) > 0) { op_queue<win_iocp_operation> ops; timer_queues_.get_all_timers(ops); ops.push(completed_ops_); if (!ops.empty()) { while (win_iocp_operation* op = ops.front()) { ops.pop(); ::InterlockedDecrement(&outstanding_work_); op->destroy(); } } else { DWORD bytes_transferred = 0; dword_ptr_t completion_key = 0; LPOVERLAPPED overlapped = 0; ::GetQueuedCompletionStatus(iocp_.handle, &bytes_transferred, &completion_key, &overlapped, gqcs_timeout_); if (overlapped) { ::InterlockedDecrement(&outstanding_work_); static_cast<win_iocp_operation>(overlapped)->destroy(); } } } if (timer_thread_.get()) timer_thread_->join(); } boost::system::error_code win_iocp_io_context::register_handle( HANDLE handle, boost::system::error_code& ec) { if (::CreateIoCompletionPort(handle, iocp_.handle, 0, 0) == 0) { DWORD last_error = ::GetLastError(); ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); } else { ec = boost::system::error_code(); } return ec; } size_t win_iocp_io_context::run(boost::system::error_code& ec) { if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0) { stop(); ec = boost::system::error_code(); return 0; } win_iocp_thread_info this_thread; thread_call_stack::context ctx(this, this_thread); size_t n = 0; while (do_one(INFINITE, this_thread, ec)) if (n != (std::numeric_limits<size_t>::max)()) ++n; return n; } size_t win_iocp_io_context::run_one(boost::system::error_code& ec) { if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0) { stop(); ec = boost::system::error_code(); return 0; } win_iocp_thread_info this_thread; thread_call_stack::context ctx(this, this_thread); return do_one(INFINITE, this_thread, ec); } size_t win_iocp_io_context::wait_one(long usec, boost::system::error_code& ec) { if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0) { stop(); ec = boost::system::error_code(); return 0; } win_iocp_thread_info this_thread; thread_call_stack::context ctx(this, this_thread); return do_one(usec < 0 ? INFINITE : ((usec - 1) / 1000 + 1), this_thread, ec); } size_t win_iocp_io_context::poll(boost::system::error_code& ec) { if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0) { stop(); ec = boost::system::error_code(); return 0; } win_iocp_thread_info this_thread; thread_call_stack::context ctx(this, this_thread); size_t n = 0; while (do_one(0, this_thread, ec)) if (n != (std::numeric_limits<size_t>::max)()) ++n; return n; } size_t win_iocp_io_context::poll_one(boost::system::error_code& ec) { if (::InterlockedExchangeAdd(&outstanding_work_, 0) == 0) { stop(); ec = boost::system::error_code(); return 0; } win_iocp_thread_info this_thread; thread_call_stack::context ctx(this, this_thread); return do_one(0, this_thread, ec); } void win_iocp_io_context::stop() { if (::InterlockedExchange(&stopped_, 1) == 0) { if (::InterlockedExchange(&stop_event_posted_, 1) == 0) { if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, 0)) { DWORD last_error = ::GetLastError(); boost::system::error_code ec(last_error, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "pqcs"); } } } } void win_iocp_io_context::capture_current_exception() { if (thread_info_base this_thread = thread_call_stack::contains(this)) this_thread->capture_current_exception(); } void win_iocp_io_context::post_deferred_completion(win_iocp_operation* op) { // Flag the operation as ready. op->ready_ = 1; // Enqueue the operation on the I/O completion port. if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, op)) { // Out of resources. Put on completed queue instead. mutex::scoped_lock lock(dispatch_mutex_); completed_ops_.push(op); ::InterlockedExchange(&dispatch_required_, 1); } } void win_iocp_io_context::post_deferred_completions( op_queue<win_iocp_operation>& ops) { while (win_iocp_operation* op = ops.front()) { ops.pop(); // Flag the operation as ready. op->ready_ = 1; // Enqueue the operation on the I/O completion port. if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, op)) { // Out of resources. Put on completed queue instead. mutex::scoped_lock lock(dispatch_mutex_); completed_ops_.push(op); completed_ops_.push(ops); ::InterlockedExchange(&dispatch_required_, 1); } } } void win_iocp_io_context::abandon_operations( op_queue<win_iocp_operation>& ops) { while (win_iocp_operation* op = ops.front()) { ops.pop(); ::InterlockedDecrement(&outstanding_work_); op->destroy(); } } void win_iocp_io_context::on_pending(win_iocp_operation* op) { if (::InterlockedCompareExchange(&op->ready_, 1, 0) == 1) { // Enqueue the operation on the I/O completion port. if (!::PostQueuedCompletionStatus(iocp_.handle, 0, overlapped_contains_result, op)) { // Out of resources. Put on completed queue instead. mutex::scoped_lock lock(dispatch_mutex_); completed_ops_.push(op); ::InterlockedExchange(&dispatch_required_, 1); } } } void win_iocp_io_context::on_completion(win_iocp_operation* op, DWORD last_error, DWORD bytes_transferred) { // Flag that the operation is ready for invocation. op->ready_ = 1; // Store results in the OVERLAPPED structure. op->Internal = reinterpret_cast<ulong_ptr_t>( &boost::asio::error::get_system_category()); op->Offset = last_error; op->OffsetHigh = bytes_transferred; // Enqueue the operation on the I/O completion port. if (!::PostQueuedCompletionStatus(iocp_.handle, 0, overlapped_contains_result, op)) { // Out of resources. Put on completed queue instead. mutex::scoped_lock lock(dispatch_mutex_); completed_ops_.push(op); ::InterlockedExchange(&dispatch_required_, 1); } } void win_iocp_io_context::on_completion(win_iocp_operation* op, const boost::system::error_code& ec, DWORD bytes_transferred) { // Flag that the operation is ready for invocation. op->ready_ = 1; // Store results in the OVERLAPPED structure. op->Internal = reinterpret_cast<ulong_ptr_t>(&ec.category()); op->Offset = ec.value(); op->OffsetHigh = bytes_transferred; // Enqueue the operation on the I/O completion port. if (!::PostQueuedCompletionStatus(iocp_.handle, 0, overlapped_contains_result, op)) { // Out of resources. Put on completed queue instead. mutex::scoped_lock lock(dispatch_mutex_); completed_ops_.push(op); ::InterlockedExchange(&dispatch_required_, 1); } } size_t win_iocp_io_context::do_one(DWORD msec, win_iocp_thread_info& this_thread, boost::system::error_code& ec) { for (;;) { // Try to acquire responsibility for dispatching timers and completed ops. if (::InterlockedCompareExchange(&dispatch_required_, 0, 1) == 1) { mutex::scoped_lock lock(dispatch_mutex_); // Dispatch pending timers and operations. op_queue<win_iocp_operation> ops; ops.push(completed_ops_); timer_queues_.get_ready_timers(ops); post_deferred_completions(ops); update_timeout(); } // Get the next operation from the queue. DWORD bytes_transferred = 0; dword_ptr_t completion_key = 0; LPOVERLAPPED overlapped = 0; ::SetLastError(0); BOOL ok = ::GetQueuedCompletionStatus(iocp_.handle, &bytes_transferred, &completion_key, &overlapped, msec < gqcs_timeout_ ? msec : gqcs_timeout_); DWORD last_error = ::GetLastError(); if (overlapped) { win_iocp_operation* op = static_cast<win_iocp_operation>(overlapped); boost::system::error_code result_ec(last_error, boost::asio::error::get_system_category()); // We may have been passed the last_error and bytes_transferred in the // OVERLAPPED structure itself. if (completion_key == overlapped_contains_result) { result_ec = boost::system::error_code(static_cast<int>(op->Offset), reinterpret_cast<boost::system::error_category>(op->Internal)); bytes_transferred = op->OffsetHigh; } // Otherwise ensure any result has been saved into the OVERLAPPED // structure. else { op->Internal = reinterpret_cast<ulong_ptr_t>(&result_ec.category()); op->Offset = result_ec.value(); op->OffsetHigh = bytes_transferred; } // Dispatch the operation only if ready. The operation may not be ready // if the initiating function (e.g. a call to WSARecv) has not yet // returned. This is because the initiating function still wants access // to the operation's OVERLAPPED structure. if (::InterlockedCompareExchange(&op->ready_, 1, 0) == 1) { // Ensure the count of outstanding work is decremented on block exit. work_finished_on_block_exit on_exit = { this }; (void)on_exit; op->complete(this, result_ec, bytes_transferred); this_thread.rethrow_pending_exception(); ec = boost::system::error_code(); return 1; } } else if (!ok) { if (last_error != WAIT_TIMEOUT) { ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); return 0; } // If we're waiting indefinitely we need to keep going until we get a // real handler. if (msec == INFINITE) continue; ec = boost::system::error_code(); return 0; } else if (completion_key == wake_for_dispatch) { // We have been woken up to try to acquire responsibility for dispatching // timers and completed operations. } else { // Indicate that there is no longer an in-flight stop event. ::InterlockedExchange(&stop_event_posted_, 0); // The stopped_ flag is always checked to ensure that any leftover // stop events from a previous run invocation are ignored. if (::InterlockedExchangeAdd(&stopped_, 0) != 0) { // Wake up next thread that is blocked on GetQueuedCompletionStatus. if (::InterlockedExchange(&stop_event_posted_, 1) == 0) { if (!::PostQueuedCompletionStatus(iocp_.handle, 0, 0, 0)) { last_error = ::GetLastError(); ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); return 0; } } ec = boost::system::error_code(); return 0; } } } } DWORD win_iocp_io_context::get_gqcs_timeout() { OSVERSIONINFOEX osvi; ZeroMemory(&osvi, sizeof(osvi)); osvi.dwOSVersionInfoSize = sizeof(osvi); osvi.dwMajorVersion = 6ul; const uint64_t condition_mask = ::VerSetConditionMask( 0, VER_MAJORVERSION, VER_GREATER_EQUAL); if (!!::VerifyVersionInfo(&osvi, VER_MAJORVERSION, condition_mask)) return INFINITE; return default_gqcs_timeout; } void win_iocp_io_context::do_add_timer_queue(timer_queue_base& queue) { mutex::scoped_lock lock(dispatch_mutex_); timer_queues_.insert(&queue); if (!waitable_timer_.handle) { waitable_timer_.handle = ::CreateWaitableTimer(0, FALSE, 0); if (waitable_timer_.handle == 0) { DWORD last_error = ::GetLastError(); boost::system::error_code ec(last_error, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "timer"); } LARGE_INTEGER timeout; timeout.QuadPart = -max_timeout_usec; timeout.QuadPart = 10; ::SetWaitableTimer(waitable_timer_.handle, &timeout, max_timeout_msec, 0, 0, FALSE); } if (!timer_thread_.get()) { timer_thread_function thread_function = { this }; timer_thread_.reset(new thread(thread_function, 65536)); } } void win_iocp_io_context::do_remove_timer_queue(timer_queue_base& queue) { mutex::scoped_lock lock(dispatch_mutex_); timer_queues_.erase(&queue); } void win_iocp_io_context::update_timeout() { if (timer_thread_.get()) { // There's no point updating the waitable timer if the new timeout period // exceeds the maximum timeout. In that case, we might as well wait for the // existing period of the timer to expire. long timeout_usec = timer_queues_.wait_duration_usec(max_timeout_usec); if (timeout_usec < max_timeout_usec) { LARGE_INTEGER timeout; timeout.QuadPart = -timeout_usec; timeout.QuadPart = 10; ::SetWaitableTimer(waitable_timer_.handle, &timeout, max_timeout_msec, 0, 0, FALSE); } } } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #endif // BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_IO_CONTEXT_IPP PK��h!\�mN�2-��2-�� impl/strand_executor_service.hppnu��[��// // detail/impl/strand_executor_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_STRAND_EXECUTOR_SERVICE_HPP #define BOOST_ASIO_DETAIL_IMPL_STRAND_EXECUTOR_SERVICE_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/call_stack.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/recycling_allocator.hpp> #include <boost/asio/executor_work_guard.hpp> #include <boost/asio/defer.hpp> #include <boost/asio/dispatch.hpp> #include <boost/asio/post.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename F, typename Allocator> class strand_executor_service::allocator_binder { public: typedef Allocator allocator_type; allocator_binder(BOOST_ASIO_MOVE_ARG(F) f, const Allocator& a) : f_(BOOST_ASIO_MOVE_CAST(F)(f)), allocator_(a) { } allocator_binder(const allocator_binder& other) : f_(other.f_), allocator_(other.allocator_) { } #if defined(BOOST_ASIO_HAS_MOVE) allocator_binder(allocator_binder&& other) : f_(BOOST_ASIO_MOVE_CAST(F)(other.f_)), allocator_(BOOST_ASIO_MOVE_CAST(allocator_type)(other.allocator_)) { } #endif // defined(BOOST_ASIO_HAS_MOVE) allocator_type get_allocator() const BOOST_ASIO_NOEXCEPT { return allocator_; } void operator()() { f_(); } private: F f_; allocator_type allocator_; }; template <typename Executor> class strand_executor_service::invoker<Executor, typename enable_if< execution::is_executor<Executor>::value >::type> { public: invoker(const implementation_type& impl, Executor& ex) : impl_(impl), executor_(boost::asio::prefer(ex, execution::outstanding_work.tracked)) { } invoker(const invoker& other) : impl_(other.impl_), executor_(other.executor_) { } #if defined(BOOST_ASIO_HAS_MOVE) invoker(invoker&& other) : impl_(BOOST_ASIO_MOVE_CAST(implementation_type)(other.impl_)), executor_(BOOST_ASIO_MOVE_CAST(executor_type)(other.executor_)) { } #endif // defined(BOOST_ASIO_HAS_MOVE) struct on_invoker_exit { invoker this_; ~on_invoker_exit() { this_->impl_->mutex_->lock(); this_->impl_->ready_queue_.push(this_->impl_->waiting_queue_); bool more_handlers = this_->impl_->locked_ = !this_->impl_->ready_queue_.empty(); this_->impl_->mutex_->unlock(); if (more_handlers) { recycling_allocator<void> allocator; execution::execute( boost::asio::prefer( boost::asio::require(this_->executor_, execution::blocking.never), execution::allocator(allocator)), BOOST_ASIO_MOVE_CAST(invoker)(this_)); } } }; void operator()() { // Indicate that this strand is executing on the current thread. call_stack<strand_impl>::context ctx(impl_.get()); // Ensure the next handler, if any, is scheduled on block exit. on_invoker_exit on_exit = { this }; (void)on_exit; // Run all ready handlers. No lock is required since the ready queue is // accessed only within the strand. boost::system::error_code ec; while (scheduler_operation o = impl_->ready_queue_.front()) { impl_->ready_queue_.pop(); o->complete(impl_.get(), ec, 0); } } private: typedef typename decay< typename prefer_result< Executor, execution::outstanding_work_t::tracked_t >::type >::type executor_type; implementation_type impl_; executor_type executor_; }; #if !defined(BOOST_ASIO_NO_TS_EXECUTORS) template <typename Executor> class strand_executor_service::invoker<Executor, typename enable_if< !execution::is_executor<Executor>::value >::type> { public: invoker(const implementation_type& impl, Executor& ex) : impl_(impl), work_(ex) { } invoker(const invoker& other) : impl_(other.impl_), work_(other.work_) { } #if defined(BOOST_ASIO_HAS_MOVE) invoker(invoker&& other) : impl_(BOOST_ASIO_MOVE_CAST(implementation_type)(other.impl_)), work_(BOOST_ASIO_MOVE_CAST(executor_work_guard<Executor>)(other.work_)) { } #endif // defined(BOOST_ASIO_HAS_MOVE) struct on_invoker_exit { invoker* this_; ~on_invoker_exit() { this_->impl_->mutex_->lock(); this_->impl_->ready_queue_.push(this_->impl_->waiting_queue_); bool more_handlers = this_->impl_->locked_ = !this_->impl_->ready_queue_.empty(); this_->impl_->mutex_->unlock(); if (more_handlers) { Executor ex(this_->work_.get_executor()); recycling_allocator<void> allocator; ex.post(BOOST_ASIO_MOVE_CAST(invoker)(this_), allocator); } } }; void operator()() { // Indicate that this strand is executing on the current thread. call_stack<strand_impl>::context ctx(impl_.get()); // Ensure the next handler, if any, is scheduled on block exit. on_invoker_exit on_exit = { this }; (void)on_exit; // Run all ready handlers. No lock is required since the ready queue is // accessed only within the strand. boost::system::error_code ec; while (scheduler_operation o = impl_->ready_queue_.front()) { impl_->ready_queue_.pop(); o->complete(impl_.get(), ec, 0); } } private: implementation_type impl_; executor_work_guard<Executor> work_; }; #endif // !defined(BOOST_ASIO_NO_TS_EXECUTORS) template <typename Executor, typename Function> inline void strand_executor_service::execute(const implementation_type& impl, Executor& ex, BOOST_ASIO_MOVE_ARG(Function) function, typename enable_if< can_query<Executor, execution::allocator_t<void> >::value >::type) { return strand_executor_service::do_execute(impl, ex, BOOST_ASIO_MOVE_CAST(Function)(function), boost::asio::query(ex, execution::allocator)); } template <typename Executor, typename Function> inline void strand_executor_service::execute(const implementation_type& impl, Executor& ex, BOOST_ASIO_MOVE_ARG(Function) function, typename enable_if< !can_query<Executor, execution::allocator_t<void> >::value >::type) { return strand_executor_service::do_execute(impl, ex, BOOST_ASIO_MOVE_CAST(Function)(function), std::allocator<void>()); } template <typename Executor, typename Function, typename Allocator> void strand_executor_service::do_execute(const implementation_type& impl, Executor& ex, BOOST_ASIO_MOVE_ARG(Function) function, const Allocator& a) { typedef typename decay<Function>::type function_type; // If the executor is not never-blocking, and we are already in the strand, // then the function can run immediately. if (boost::asio::query(ex, execution::blocking) != execution::blocking.never && call_stack<strand_impl>::contains(impl.get())) { // Make a local, non-const copy of the function. function_type tmp(BOOST_ASIO_MOVE_CAST(Function)(function)); fenced_block b(fenced_block::full); boost_asio_handler_invoke_helpers::invoke(tmp, tmp); return; } // Allocate and construct an operation to wrap the function. typedef executor_op<function_type, Allocator> op; typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 }; p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(function), a); BOOST_ASIO_HANDLER_CREATION((impl->service_->context(), p.p, "strand_executor", impl.get(), 0, "execute")); // Add the function to the strand and schedule the strand if required. bool first = enqueue(impl, p.p); p.v = p.p = 0; if (first) { execution::execute(ex, invoker<Executor>(impl, ex)); } } template <typename Executor, typename Function, typename Allocator> void strand_executor_service::dispatch(const implementation_type& impl, Executor& ex, BOOST_ASIO_MOVE_ARG(Function) function, const Allocator& a) { typedef typename decay<Function>::type function_type; // If we are already in the strand then the function can run immediately. if (call_stack<strand_impl>::contains(impl.get())) { // Make a local, non-const copy of the function. function_type tmp(BOOST_ASIO_MOVE_CAST(Function)(function)); fenced_block b(fenced_block::full); boost_asio_handler_invoke_helpers::invoke(tmp, tmp); return; } // Allocate and construct an operation to wrap the function. typedef executor_op<function_type, Allocator> op; typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 }; p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(function), a); BOOST_ASIO_HANDLER_CREATION((impl->service_->context(), p.p, "strand_executor", impl.get(), 0, "dispatch")); // Add the function to the strand and schedule the strand if required. bool first = enqueue(impl, p.p); p.v = p.p = 0; if (first) { boost::asio::dispatch(ex, allocator_binder<invoker<Executor>, Allocator>( invoker<Executor>(impl, ex), a)); } } // Request invocation of the given function and return immediately. template <typename Executor, typename Function, typename Allocator> void strand_executor_service::post(const implementation_type& impl, Executor& ex, BOOST_ASIO_MOVE_ARG(Function) function, const Allocator& a) { typedef typename decay<Function>::type function_type; // Allocate and construct an operation to wrap the function. typedef executor_op<function_type, Allocator> op; typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 }; p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(function), a); BOOST_ASIO_HANDLER_CREATION((impl->service_->context(), p.p, "strand_executor", impl.get(), 0, "post")); // Add the function to the strand and schedule the strand if required. bool first = enqueue(impl, p.p); p.v = p.p = 0; if (first) { boost::asio::post(ex, allocator_binder<invoker<Executor>, Allocator>( invoker<Executor>(impl, ex), a)); } } // Request invocation of the given function and return immediately. template <typename Executor, typename Function, typename Allocator> void strand_executor_service::defer(const implementation_type& impl, Executor& ex, BOOST_ASIO_MOVE_ARG(Function) function, const Allocator& a) { typedef typename decay<Function>::type function_type; // Allocate and construct an operation to wrap the function. typedef executor_op<function_type, Allocator> op; typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 }; p.p = new (p.v) op(BOOST_ASIO_MOVE_CAST(Function)(function), a); BOOST_ASIO_HANDLER_CREATION((impl->service_->context(), p.p, "strand_executor", impl.get(), 0, "defer")); // Add the function to the strand and schedule the strand if required. bool first = enqueue(impl, p.p); p.v = p.p = 0; if (first) { boost::asio::defer(ex, allocator_binder<invoker<Executor>, Allocator>( invoker<Executor>(impl, ex), a)); } } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_IMPL_STRAND_EXECUTOR_SERVICE_HPP PK��h!\uVv^��#��impl/eventfd_select_interrupter.ippnu��[��// // detail/impl/eventfd_select_interrupter.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2008 Roelof Naude (roelof.naude at gmail 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_DETAIL_IMPL_EVENTFD_SELECT_INTERRUPTER_IPP #define BOOST_ASIO_DETAIL_IMPL_EVENTFD_SELECT_INTERRUPTER_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_HAS_EVENTFD) #include <sys/stat.h> #include <sys/types.h> #include <fcntl.h> #if __GLIBC__ == 2 && __GLIBC_MINOR__ < 8 && !defined(__UCLIBC__) # include <asm/unistd.h> #else // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8 && !defined(__UCLIBC__) # include <sys/eventfd.h> #endif // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8 && !defined(__UCLIBC__) #include <boost/asio/detail/cstdint.hpp> #include <boost/asio/detail/eventfd_select_interrupter.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { eventfd_select_interrupter::eventfd_select_interrupter() { open_descriptors(); } void eventfd_select_interrupter::open_descriptors() { #if __GLIBC__ == 2 && __GLIBC_MINOR__ < 8 && !defined(__UCLIBC__) write_descriptor_ = read_descriptor_ = syscall(__NR_eventfd, 0); if (read_descriptor_ != -1) { ::fcntl(read_descriptor_, F_SETFL, O_NONBLOCK); ::fcntl(read_descriptor_, F_SETFD, FD_CLOEXEC); } #else // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8 && !defined(__UCLIBC__) # if defined(EFD_CLOEXEC) && defined(EFD_NONBLOCK) write_descriptor_ = read_descriptor_ = ::eventfd(0, EFD_CLOEXEC \| EFD_NONBLOCK); # else // defined(EFD_CLOEXEC) && defined(EFD_NONBLOCK) errno = EINVAL; write_descriptor_ = read_descriptor_ = -1; # endif // defined(EFD_CLOEXEC) && defined(EFD_NONBLOCK) if (read_descriptor_ == -1 && errno == EINVAL) { write_descriptor_ = read_descriptor_ = ::eventfd(0, 0); if (read_descriptor_ != -1) { ::fcntl(read_descriptor_, F_SETFL, O_NONBLOCK); ::fcntl(read_descriptor_, F_SETFD, FD_CLOEXEC); } } #endif // __GLIBC__ == 2 && __GLIBC_MINOR__ < 8 && !defined(__UCLIBC__) if (read_descriptor_ == -1) { int pipe_fds[2]; if (pipe(pipe_fds) == 0) { read_descriptor_ = pipe_fds[0]; ::fcntl(read_descriptor_, F_SETFL, O_NONBLOCK); ::fcntl(read_descriptor_, F_SETFD, FD_CLOEXEC); write_descriptor_ = pipe_fds[1]; ::fcntl(write_descriptor_, F_SETFL, O_NONBLOCK); ::fcntl(write_descriptor_, F_SETFD, FD_CLOEXEC); } else { boost::system::error_code ec(errno, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "eventfd_select_interrupter"); } } } eventfd_select_interrupter::~eventfd_select_interrupter() { close_descriptors(); } void eventfd_select_interrupter::close_descriptors() { if (write_descriptor_ != -1 && write_descriptor_ != read_descriptor_) ::close(write_descriptor_); if (read_descriptor_ != -1) ::close(read_descriptor_); } void eventfd_select_interrupter::recreate() { close_descriptors(); write_descriptor_ = -1; read_descriptor_ = -1; open_descriptors(); } void eventfd_select_interrupter::interrupt() { uint64_t counter(1UL); int result = ::write(write_descriptor_, &counter, sizeof(uint64_t)); (void)result; } bool eventfd_select_interrupter::reset() { if (write_descriptor_ == read_descriptor_) { for (;;) { // Only perform one read. The kernel maintains an atomic counter. uint64_t counter(0); errno = 0; int bytes_read = ::read(read_descriptor_, &counter, sizeof(uint64_t)); if (bytes_read < 0 && errno == EINTR) continue; return true; } } else { for (;;) { // Clear all data from the pipe. char data[1024]; int bytes_read = ::read(read_descriptor_, data, sizeof(data)); if (bytes_read == sizeof(data)) continue; if (bytes_read > 0) return true; if (bytes_read == 0) return false; if (errno == EINTR) continue; if (errno == EWOULDBLOCK) return true; if (errno == EAGAIN) return true; return false; } } } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_EVENTFD) #endif // BOOST_ASIO_DETAIL_IMPL_EVENTFD_SELECT_INTERRUPTER_IPP PK��h!\��op5��5�� impl/strand_executor_service.ippnu��[��// // detail/impl/strand_executor_service.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_STRAND_EXECUTOR_SERVICE_IPP #define BOOST_ASIO_DETAIL_IMPL_STRAND_EXECUTOR_SERVICE_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/detail/strand_executor_service.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { strand_executor_service::strand_executor_service(execution_context& ctx) : execution_context_service_base<strand_executor_service>(ctx), mutex_(), salt_(0), impl_list_(0) { } void strand_executor_service::shutdown() { op_queue<scheduler_operation> ops; boost::asio::detail::mutex::scoped_lock lock(mutex_); strand_impl* impl = impl_list_; while (impl) { impl->mutex_->lock(); impl->shutdown_ = true; ops.push(impl->waiting_queue_); ops.push(impl->ready_queue_); impl->mutex_->unlock(); impl = impl->next_; } } strand_executor_service::implementation_type strand_executor_service::create_implementation() { implementation_type new_impl(new strand_impl); new_impl->locked_ = false; new_impl->shutdown_ = false; boost::asio::detail::mutex::scoped_lock lock(mutex_); // Select a mutex from the pool of shared mutexes. std::size_t salt = salt_++; std::size_t mutex_index = reinterpret_cast<std::size_t>(new_impl.get()); mutex_index += (reinterpret_cast<std::size_t>(new_impl.get()) >> 3); mutex_index ^= salt + 0x9e3779b9 + (mutex_index << 6) + (mutex_index >> 2); mutex_index = mutex_index % num_mutexes; if (!mutexes_[mutex_index].get()) mutexes_[mutex_index].reset(new mutex); new_impl->mutex_ = mutexes_[mutex_index].get(); // Insert implementation into linked list of all implementations. new_impl->next_ = impl_list_; new_impl->prev_ = 0; if (impl_list_) impl_list_->prev_ = new_impl.get(); impl_list_ = new_impl.get(); new_impl->service_ = this; return new_impl; } strand_executor_service::strand_impl::~strand_impl() { boost::asio::detail::mutex::scoped_lock lock(service_->mutex_); // Remove implementation from linked list of all implementations. if (service_->impl_list_ == this) service_->impl_list_ = next_; if (prev_) prev_->next_ = next_; if (next_) next_->prev_= prev_; } bool strand_executor_service::enqueue(const implementation_type& impl, scheduler_operation* op) { impl->mutex_->lock(); if (impl->shutdown_) { impl->mutex_->unlock(); op->destroy(); return false; } else if (impl->locked_) { // Some other function already holds the strand lock. Enqueue for later. impl->waiting_queue_.push(op); impl->mutex_->unlock(); return false; } else { // The function is acquiring the strand lock and so is responsible for // scheduling the strand. impl->locked_ = true; impl->mutex_->unlock(); impl->ready_queue_.push(op); return true; } } bool strand_executor_service::running_in_this_thread( const implementation_type& impl) { return !!call_stack<strand_impl>::contains(impl.get()); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_IMPL_STRAND_EXECUTOR_SERVICE_IPP PK��h!\��h ��h ��impl/winrt_timer_scheduler.hppnu��[��// // detail/impl/winrt_timer_scheduler.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_HPP #define BOOST_ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_HPP #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_WINDOWS_RUNTIME) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Time_Traits> void winrt_timer_scheduler::add_timer_queue(timer_queue<Time_Traits>& queue) { do_add_timer_queue(queue); } // Remove a timer queue from the reactor. template <typename Time_Traits> void winrt_timer_scheduler::remove_timer_queue(timer_queue<Time_Traits>& queue) { do_remove_timer_queue(queue); } template <typename Time_Traits> void winrt_timer_scheduler::schedule_timer(timer_queue<Time_Traits>& queue, const typename Time_Traits::time_type& time, typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op) { boost::asio::detail::mutex::scoped_lock lock(mutex_); if (shutdown_) { scheduler_.post_immediate_completion(op, false); return; } bool earliest = queue.enqueue_timer(time, timer, op); scheduler_.work_started(); if (earliest) event_.signal(lock); } template <typename Time_Traits> std::size_t winrt_timer_scheduler::cancel_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& timer, std::size_t max_cancelled) { boost::asio::detail::mutex::scoped_lock lock(mutex_); op_queue<operation> ops; std::size_t n = queue.cancel_timer(timer, ops, max_cancelled); lock.unlock(); scheduler_.post_deferred_completions(ops); return n; } template <typename Time_Traits> void winrt_timer_scheduler::move_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& to, typename timer_queue<Time_Traits>::per_timer_data& from) { boost::asio::detail::mutex::scoped_lock lock(mutex_); op_queue<operation> ops; queue.cancel_timer(to, ops); queue.move_timer(to, from); lock.unlock(); scheduler_.post_deferred_completions(ops); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_HPP PK��h!\�4��%��impl/reactive_serial_port_service.ippnu��[��// // detail/impl/reactive_serial_port_service.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.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_DETAIL_IMPL_REACTIVE_SERIAL_PORT_SERVICE_IPP #define BOOST_ASIO_DETAIL_IMPL_REACTIVE_SERIAL_PORT_SERVICE_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_HAS_SERIAL_PORT) #if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) #include <cstring> #include <boost/asio/detail/reactive_serial_port_service.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { reactive_serial_port_service::reactive_serial_port_service( execution_context& context) : execution_context_service_base<reactive_serial_port_service>(context), descriptor_service_(context) { } void reactive_serial_port_service::shutdown() { descriptor_service_.shutdown(); } boost::system::error_code reactive_serial_port_service::open( reactive_serial_port_service::implementation_type& impl, const std::string& device, boost::system::error_code& ec) { if (is_open(impl)) { ec = boost::asio::error::already_open; return ec; } descriptor_ops::state_type state = 0; int fd = descriptor_ops::open(device.c_str(), O_RDWR \| O_NONBLOCK \| O_NOCTTY, ec); if (fd < 0) return ec; int s = descriptor_ops::fcntl(fd, F_GETFL, ec); if (s >= 0) s = descriptor_ops::fcntl(fd, F_SETFL, s \| O_NONBLOCK, ec); if (s < 0) { boost::system::error_code ignored_ec; descriptor_ops::close(fd, state, ignored_ec); return ec; } // Set up default serial port options. termios ios; s = ::tcgetattr(fd, &ios); descriptor_ops::get_last_error(ec, s < 0); if (s >= 0) { #if defined(_BSD_SOURCE) \|\| defined(_DEFAULT_SOURCE) ::cfmakeraw(&ios); #else ios.c_iflag &= ~(IGNBRK \| BRKINT \| PARMRK \| ISTRIP \| INLCR \| IGNCR \| ICRNL \| IXON); ios.c_oflag &= ~OPOST; ios.c_lflag &= ~(ECHO \| ECHONL \| ICANON \| ISIG \| IEXTEN); ios.c_cflag &= ~(CSIZE \| PARENB); ios.c_cflag \|= CS8; #endif ios.c_iflag \|= IGNPAR; ios.c_cflag \|= CREAD \| CLOCAL; s = ::tcsetattr(fd, TCSANOW, &ios); descriptor_ops::get_last_error(ec, s < 0); } if (s < 0) { boost::system::error_code ignored_ec; descriptor_ops::close(fd, state, ignored_ec); return ec; } // We're done. Take ownership of the serial port descriptor. if (descriptor_service_.assign(impl, fd, ec)) { boost::system::error_code ignored_ec; descriptor_ops::close(fd, state, ignored_ec); } return ec; } boost::system::error_code reactive_serial_port_service::do_set_option( reactive_serial_port_service::implementation_type& impl, reactive_serial_port_service::store_function_type store, const void* option, boost::system::error_code& ec) { termios ios; int s = ::tcgetattr(descriptor_service_.native_handle(impl), &ios); descriptor_ops::get_last_error(ec, s < 0); if (s < 0) return ec; if (store(option, ios, ec)) return ec; s = ::tcsetattr(descriptor_service_.native_handle(impl), TCSANOW, &ios); descriptor_ops::get_last_error(ec, s < 0); return ec; } boost::system::error_code reactive_serial_port_service::do_get_option( const reactive_serial_port_service::implementation_type& impl, reactive_serial_port_service::load_function_type load, void* option, boost::system::error_code& ec) const { termios ios; int s = ::tcgetattr(descriptor_service_.native_handle(impl), &ios); descriptor_ops::get_last_error(ec, s < 0); if (s < 0) return ec; return load(option, ios, ec); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) #endif // defined(BOOST_ASIO_HAS_SERIAL_PORT) #endif // BOOST_ASIO_DETAIL_IMPL_REACTIVE_SERIAL_PORT_SERVICE_IPP PK��h!\+�9��impl/posix_thread.ippnu��[��// // detail/impl/posix_thread.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_POSIX_THREAD_IPP #define BOOST_ASIO_DETAIL_IMPL_POSIX_THREAD_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_HAS_PTHREADS) #include <boost/asio/detail/posix_thread.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { posix_thread::~posix_thread() { if (!joined_) ::pthread_detach(thread_); } void posix_thread::join() { if (!joined_) { ::pthread_join(thread_, 0); joined_ = true; } } std::size_t posix_thread::hardware_concurrency() { #if defined(_SC_NPROCESSORS_ONLN) long result = sysconf(_SC_NPROCESSORS_ONLN); if (result > 0) return result; #endif // defined(_SC_NPROCESSORS_ONLN) return 0; } void posix_thread::start_thread(func_base* arg) { int error = ::pthread_create(&thread_, 0, boost_asio_detail_posix_thread_function, arg); if (error != 0) { delete arg; boost::system::error_code ec(error, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "thread"); } } void* boost_asio_detail_posix_thread_function(void* arg) { posix_thread::auto_func_base_ptr func = { static_cast<posix_thread::func_base>(arg) }; func.ptr->run(); return 0; } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_PTHREADS) #endif // BOOST_ASIO_DETAIL_IMPL_POSIX_THREAD_IPP PK��h!\�\EdW��dW��impl/epoll_reactor.ippnu��[��// // detail/impl/epoll_reactor.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_EPOLL_REACTOR_IPP #define BOOST_ASIO_DETAIL_IMPL_EPOLL_REACTOR_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_HAS_EPOLL) #include <cstddef> #include <sys/epoll.h> #include <boost/asio/detail/epoll_reactor.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> #if defined(BOOST_ASIO_HAS_TIMERFD) # include <sys/timerfd.h> #endif // defined(BOOST_ASIO_HAS_TIMERFD) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { epoll_reactor::epoll_reactor(boost::asio::execution_context& ctx) : execution_context_service_base<epoll_reactor>(ctx), scheduler_(use_service<scheduler>(ctx)), mutex_(BOOST_ASIO_CONCURRENCY_HINT_IS_LOCKING( REACTOR_REGISTRATION, scheduler_.concurrency_hint())), interrupter_(), epoll_fd_(do_epoll_create()), timer_fd_(do_timerfd_create()), shutdown_(false), registered_descriptors_mutex_(mutex_.enabled()) { // Add the interrupter's descriptor to epoll. epoll_event ev = { 0, { 0 } }; ev.events = EPOLLIN \| EPOLLERR \| EPOLLET; ev.data.ptr = &interrupter_; epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, interrupter_.read_descriptor(), &ev); interrupter_.interrupt(); // Add the timer descriptor to epoll. if (timer_fd_ != -1) { ev.events = EPOLLIN \| EPOLLERR; ev.data.ptr = &timer_fd_; epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, timer_fd_, &ev); } } epoll_reactor::~epoll_reactor() { if (epoll_fd_ != -1) close(epoll_fd_); if (timer_fd_ != -1) close(timer_fd_); } void epoll_reactor::shutdown() { mutex::scoped_lock lock(mutex_); shutdown_ = true; lock.unlock(); op_queue<operation> ops; while (descriptor_state state = registered_descriptors_.first()) { for (int i = 0; i < max_ops; ++i) ops.push(state->op_queue_[i]); state->shutdown_ = true; registered_descriptors_.free(state); } timer_queues_.get_all_timers(ops); scheduler_.abandon_operations(ops); } void epoll_reactor::notify_fork( boost::asio::execution_context::fork_event fork_ev) { if (fork_ev == boost::asio::execution_context::fork_child) { if (epoll_fd_ != -1) ::close(epoll_fd_); epoll_fd_ = -1; epoll_fd_ = do_epoll_create(); if (timer_fd_ != -1) ::close(timer_fd_); timer_fd_ = -1; timer_fd_ = do_timerfd_create(); interrupter_.recreate(); // Add the interrupter's descriptor to epoll. epoll_event ev = { 0, { 0 } }; ev.events = EPOLLIN \| EPOLLERR \| EPOLLET; ev.data.ptr = &interrupter_; epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, interrupter_.read_descriptor(), &ev); interrupter_.interrupt(); // Add the timer descriptor to epoll. if (timer_fd_ != -1) { ev.events = EPOLLIN \| EPOLLERR; ev.data.ptr = &timer_fd_; epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, timer_fd_, &ev); } update_timeout(); // Re-register all descriptors with epoll. mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_); for (descriptor_state* state = registered_descriptors_.first(); state != 0; state = state->next_) { ev.events = state->registered_events_; ev.data.ptr = state; int result = epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, state->descriptor_, &ev); if (result != 0) { boost::system::error_code ec(errno, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "epoll re-registration"); } } } } void epoll_reactor::init_task() { scheduler_.init_task(); } int epoll_reactor::register_descriptor(socket_type descriptor, epoll_reactor::per_descriptor_data& descriptor_data) { descriptor_data = allocate_descriptor_state(); BOOST_ASIO_HANDLER_REACTOR_REGISTRATION(( context(), static_cast<uintmax_t>(descriptor), reinterpret_cast<uintmax_t>(descriptor_data))); { mutex::scoped_lock descriptor_lock(descriptor_data->mutex_); descriptor_data->reactor_ = this; descriptor_data->descriptor_ = descriptor; descriptor_data->shutdown_ = false; for (int i = 0; i < max_ops; ++i) descriptor_data->try_speculative_[i] = true; } epoll_event ev = { 0, { 0 } }; ev.events = EPOLLIN \| EPOLLERR \| EPOLLHUP \| EPOLLPRI \| EPOLLET; descriptor_data->registered_events_ = ev.events; ev.data.ptr = descriptor_data; int result = epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, descriptor, &ev); if (result != 0) { if (errno == EPERM) { // This file descriptor type is not supported by epoll. However, if it is // a regular file then operations on it will not block. We will allow // this descriptor to be used and fail later if an operation on it would // otherwise require a trip through the reactor. descriptor_data->registered_events_ = 0; return 0; } return errno; } return 0; } int epoll_reactor::register_internal_descriptor( int op_type, socket_type descriptor, epoll_reactor::per_descriptor_data& descriptor_data, reactor_op* op) { descriptor_data = allocate_descriptor_state(); BOOST_ASIO_HANDLER_REACTOR_REGISTRATION(( context(), static_cast<uintmax_t>(descriptor), reinterpret_cast<uintmax_t>(descriptor_data))); { mutex::scoped_lock descriptor_lock(descriptor_data->mutex_); descriptor_data->reactor_ = this; descriptor_data->descriptor_ = descriptor; descriptor_data->shutdown_ = false; descriptor_data->op_queue_[op_type].push(op); for (int i = 0; i < max_ops; ++i) descriptor_data->try_speculative_[i] = true; } epoll_event ev = { 0, { 0 } }; ev.events = EPOLLIN \| EPOLLERR \| EPOLLHUP \| EPOLLPRI \| EPOLLET; descriptor_data->registered_events_ = ev.events; ev.data.ptr = descriptor_data; int result = epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, descriptor, &ev); if (result != 0) return errno; return 0; } void epoll_reactor::move_descriptor(socket_type, epoll_reactor::per_descriptor_data& target_descriptor_data, epoll_reactor::per_descriptor_data& source_descriptor_data) { target_descriptor_data = source_descriptor_data; source_descriptor_data = 0; } void epoll_reactor::start_op(int op_type, socket_type descriptor, epoll_reactor::per_descriptor_data& descriptor_data, reactor_op* op, bool is_continuation, bool allow_speculative) { if (!descriptor_data) { op->ec_ = boost::asio::error::bad_descriptor; post_immediate_completion(op, is_continuation); return; } mutex::scoped_lock descriptor_lock(descriptor_data->mutex_); if (descriptor_data->shutdown_) { post_immediate_completion(op, is_continuation); return; } if (descriptor_data->op_queue_[op_type].empty()) { if (allow_speculative && (op_type != read_op \|\| descriptor_data->op_queue_[except_op].empty())) { if (descriptor_data->try_speculative_[op_type]) { if (reactor_op::status status = op->perform()) { if (status == reactor_op::done_and_exhausted) if (descriptor_data->registered_events_ != 0) descriptor_data->try_speculative_[op_type] = false; descriptor_lock.unlock(); scheduler_.post_immediate_completion(op, is_continuation); return; } } if (descriptor_data->registered_events_ == 0) { op->ec_ = boost::asio::error::operation_not_supported; scheduler_.post_immediate_completion(op, is_continuation); return; } if (op_type == write_op) { if ((descriptor_data->registered_events_ & EPOLLOUT) == 0) { epoll_event ev = { 0, { 0 } }; ev.events = descriptor_data->registered_events_ \| EPOLLOUT; ev.data.ptr = descriptor_data; if (epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, descriptor, &ev) == 0) { descriptor_data->registered_events_ \|= ev.events; } else { op->ec_ = boost::system::error_code(errno, boost::asio::error::get_system_category()); scheduler_.post_immediate_completion(op, is_continuation); return; } } } } else if (descriptor_data->registered_events_ == 0) { op->ec_ = boost::asio::error::operation_not_supported; scheduler_.post_immediate_completion(op, is_continuation); return; } else { if (op_type == write_op) { descriptor_data->registered_events_ \|= EPOLLOUT; } epoll_event ev = { 0, { 0 } }; ev.events = descriptor_data->registered_events_; ev.data.ptr = descriptor_data; epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, descriptor, &ev); } } descriptor_data->op_queue_[op_type].push(op); scheduler_.work_started(); } void epoll_reactor::cancel_ops(socket_type, epoll_reactor::per_descriptor_data& descriptor_data) { if (!descriptor_data) return; mutex::scoped_lock descriptor_lock(descriptor_data->mutex_); op_queue<operation> ops; for (int i = 0; i < max_ops; ++i) { while (reactor_op* op = descriptor_data->op_queue_[i].front()) { op->ec_ = boost::asio::error::operation_aborted; descriptor_data->op_queue_[i].pop(); ops.push(op); } } descriptor_lock.unlock(); scheduler_.post_deferred_completions(ops); } void epoll_reactor::deregister_descriptor(socket_type descriptor, epoll_reactor::per_descriptor_data& descriptor_data, bool closing) { if (!descriptor_data) return; mutex::scoped_lock descriptor_lock(descriptor_data->mutex_); if (!descriptor_data->shutdown_) { if (closing) { // The descriptor will be automatically removed from the epoll set when // it is closed. } else if (descriptor_data->registered_events_ != 0) { epoll_event ev = { 0, { 0 } }; epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, descriptor, &ev); } op_queue<operation> ops; for (int i = 0; i < max_ops; ++i) { while (reactor_op* op = descriptor_data->op_queue_[i].front()) { op->ec_ = boost::asio::error::operation_aborted; descriptor_data->op_queue_[i].pop(); ops.push(op); } } descriptor_data->descriptor_ = -1; descriptor_data->shutdown_ = true; descriptor_lock.unlock(); BOOST_ASIO_HANDLER_REACTOR_DEREGISTRATION(( context(), static_cast<uintmax_t>(descriptor), reinterpret_cast<uintmax_t>(descriptor_data))); scheduler_.post_deferred_completions(ops); // Leave descriptor_data set so that it will be freed by the subsequent // call to cleanup_descriptor_data. } else { // We are shutting down, so prevent cleanup_descriptor_data from freeing // the descriptor_data object and let the destructor free it instead. descriptor_data = 0; } } void epoll_reactor::deregister_internal_descriptor(socket_type descriptor, epoll_reactor::per_descriptor_data& descriptor_data) { if (!descriptor_data) return; mutex::scoped_lock descriptor_lock(descriptor_data->mutex_); if (!descriptor_data->shutdown_) { epoll_event ev = { 0, { 0 } }; epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, descriptor, &ev); op_queue<operation> ops; for (int i = 0; i < max_ops; ++i) ops.push(descriptor_data->op_queue_[i]); descriptor_data->descriptor_ = -1; descriptor_data->shutdown_ = true; descriptor_lock.unlock(); BOOST_ASIO_HANDLER_REACTOR_DEREGISTRATION(( context(), static_cast<uintmax_t>(descriptor), reinterpret_cast<uintmax_t>(descriptor_data))); // Leave descriptor_data set so that it will be freed by the subsequent // call to cleanup_descriptor_data. } else { // We are shutting down, so prevent cleanup_descriptor_data from freeing // the descriptor_data object and let the destructor free it instead. descriptor_data = 0; } } void epoll_reactor::cleanup_descriptor_data( per_descriptor_data& descriptor_data) { if (descriptor_data) { free_descriptor_state(descriptor_data); descriptor_data = 0; } } void epoll_reactor::run(long usec, op_queue<operation>& ops) { // This code relies on the fact that the scheduler queues the reactor task // behind all descriptor operations generated by this function. This means, // that by the time we reach this point, any previously returned descriptor // operations have already been dequeued. Therefore it is now safe for us to // reuse and return them for the scheduler to queue again. // Calculate timeout. Check the timer queues only if timerfd is not in use. int timeout; if (usec == 0) timeout = 0; else { timeout = (usec < 0) ? -1 : ((usec - 1) / 1000 + 1); if (timer_fd_ == -1) { mutex::scoped_lock lock(mutex_); timeout = get_timeout(timeout); } } // Block on the epoll descriptor. epoll_event events[128]; int num_events = epoll_wait(epoll_fd_, events, 128, timeout); #if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) // Trace the waiting events. for (int i = 0; i < num_events; ++i) { void* ptr = events[i].data.ptr; if (ptr == &interrupter_) { // Ignore. } # if defined(BOOST_ASIO_HAS_TIMERFD) else if (ptr == &timer_fd_) { // Ignore. } # endif // defined(BOOST_ASIO_HAS_TIMERFD) else { unsigned event_mask = 0; if ((events[i].events & EPOLLIN) != 0) event_mask \|= BOOST_ASIO_HANDLER_REACTOR_READ_EVENT; if ((events[i].events & EPOLLOUT)) event_mask \|= BOOST_ASIO_HANDLER_REACTOR_WRITE_EVENT; if ((events[i].events & (EPOLLERR \| EPOLLHUP)) != 0) event_mask \|= BOOST_ASIO_HANDLER_REACTOR_ERROR_EVENT; BOOST_ASIO_HANDLER_REACTOR_EVENTS((context(), reinterpret_cast<uintmax_t>(ptr), event_mask)); } } #endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) #if defined(BOOST_ASIO_HAS_TIMERFD) bool check_timers = (timer_fd_ == -1); #else // defined(BOOST_ASIO_HAS_TIMERFD) bool check_timers = true; #endif // defined(BOOST_ASIO_HAS_TIMERFD) // Dispatch the waiting events. for (int i = 0; i < num_events; ++i) { void* ptr = events[i].data.ptr; if (ptr == &interrupter_) { // No need to reset the interrupter since we're leaving the descriptor // in a ready-to-read state and relying on edge-triggered notifications // to make it so that we only get woken up when the descriptor's epoll // registration is updated. #if defined(BOOST_ASIO_HAS_TIMERFD) if (timer_fd_ == -1) check_timers = true; #else // defined(BOOST_ASIO_HAS_TIMERFD) check_timers = true; #endif // defined(BOOST_ASIO_HAS_TIMERFD) } #if defined(BOOST_ASIO_HAS_TIMERFD) else if (ptr == &timer_fd_) { check_timers = true; } #endif // defined(BOOST_ASIO_HAS_TIMERFD) else { // The descriptor operation doesn't count as work in and of itself, so we // don't call work_started() here. This still allows the scheduler to // stop if the only remaining operations are descriptor operations. descriptor_state* descriptor_data = static_cast<descriptor_state>(ptr); if (!ops.is_enqueued(descriptor_data)) { descriptor_data->set_ready_events(events[i].events); ops.push(descriptor_data); } else { descriptor_data->add_ready_events(events[i].events); } } } if (check_timers) { mutex::scoped_lock common_lock(mutex_); timer_queues_.get_ready_timers(ops); #if defined(BOOST_ASIO_HAS_TIMERFD) if (timer_fd_ != -1) { itimerspec new_timeout; itimerspec old_timeout; int flags = get_timeout(new_timeout); timerfd_settime(timer_fd_, flags, &new_timeout, &old_timeout); } #endif // defined(BOOST_ASIO_HAS_TIMERFD) } } void epoll_reactor::interrupt() { epoll_event ev = { 0, { 0 } }; ev.events = EPOLLIN \| EPOLLERR \| EPOLLET; ev.data.ptr = &interrupter_; epoll_ctl(epoll_fd_, EPOLL_CTL_MOD, interrupter_.read_descriptor(), &ev); } int epoll_reactor::do_epoll_create() { #if defined(EPOLL_CLOEXEC) int fd = epoll_create1(EPOLL_CLOEXEC); #else // defined(EPOLL_CLOEXEC) int fd = -1; errno = EINVAL; #endif // defined(EPOLL_CLOEXEC) if (fd == -1 && (errno == EINVAL \|\| errno == ENOSYS)) { fd = epoll_create(epoll_size); if (fd != -1) ::fcntl(fd, F_SETFD, FD_CLOEXEC); } if (fd == -1) { boost::system::error_code ec(errno, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "epoll"); } return fd; } int epoll_reactor::do_timerfd_create() { #if defined(BOOST_ASIO_HAS_TIMERFD) # if defined(TFD_CLOEXEC) int fd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC); # else // defined(TFD_CLOEXEC) int fd = -1; errno = EINVAL; # endif // defined(TFD_CLOEXEC) if (fd == -1 && errno == EINVAL) { fd = timerfd_create(CLOCK_MONOTONIC, 0); if (fd != -1) ::fcntl(fd, F_SETFD, FD_CLOEXEC); } return fd; #else // defined(BOOST_ASIO_HAS_TIMERFD) return -1; #endif // defined(BOOST_ASIO_HAS_TIMERFD) } epoll_reactor::descriptor_state epoll_reactor::allocate_descriptor_state() { mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_); return registered_descriptors_.alloc(BOOST_ASIO_CONCURRENCY_HINT_IS_LOCKING( REACTOR_IO, scheduler_.concurrency_hint())); } void epoll_reactor::free_descriptor_state(epoll_reactor::descriptor_state* s) { mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_); registered_descriptors_.free(s); } void epoll_reactor::do_add_timer_queue(timer_queue_base& queue) { mutex::scoped_lock lock(mutex_); timer_queues_.insert(&queue); } void epoll_reactor::do_remove_timer_queue(timer_queue_base& queue) { mutex::scoped_lock lock(mutex_); timer_queues_.erase(&queue); } void epoll_reactor::update_timeout() { #if defined(BOOST_ASIO_HAS_TIMERFD) if (timer_fd_ != -1) { itimerspec new_timeout; itimerspec old_timeout; int flags = get_timeout(new_timeout); timerfd_settime(timer_fd_, flags, &new_timeout, &old_timeout); return; } #endif // defined(BOOST_ASIO_HAS_TIMERFD) interrupt(); } int epoll_reactor::get_timeout(int msec) { // By default we will wait no longer than 5 minutes. This will ensure that // any changes to the system clock are detected after no longer than this. const int max_msec = 5 * 60 * 1000; return timer_queues_.wait_duration_msec( (msec < 0 \|\| max_msec < msec) ? max_msec : msec); } #if defined(BOOST_ASIO_HAS_TIMERFD) int epoll_reactor::get_timeout(itimerspec& ts) { ts.it_interval.tv_sec = 0; ts.it_interval.tv_nsec = 0; long usec = timer_queues_.wait_duration_usec(5 * 60 * 1000 * 1000); ts.it_value.tv_sec = usec / 1000000; ts.it_value.tv_nsec = usec ? (usec % 1000000) * 1000 : 1; return usec ? 0 : TFD_TIMER_ABSTIME; } #endif // defined(BOOST_ASIO_HAS_TIMERFD) struct epoll_reactor::perform_io_cleanup_on_block_exit { explicit perform_io_cleanup_on_block_exit(epoll_reactor* r) : reactor_(r), first_op_(0) { } ~perform_io_cleanup_on_block_exit() { if (first_op_) { // Post the remaining completed operations for invocation. if (!ops_.empty()) reactor_->scheduler_.post_deferred_completions(ops_); // A user-initiated operation has completed, but there's no need to // explicitly call work_finished() here. Instead, we'll take advantage of // the fact that the scheduler will call work_finished() once we return. } else { // No user-initiated operations have completed, so we need to compensate // for the work_finished() call that the scheduler will make once this // operation returns. reactor_->scheduler_.compensating_work_started(); } } epoll_reactor* reactor_; op_queue<operation> ops_; operation* first_op_; }; epoll_reactor::descriptor_state::descriptor_state(bool locking) : operation(&epoll_reactor::descriptor_state::do_complete), mutex_(locking) { } operation* epoll_reactor::descriptor_state::perform_io(uint32_t events) { mutex_.lock(); perform_io_cleanup_on_block_exit io_cleanup(reactor_); mutex::scoped_lock descriptor_lock(mutex_, mutex::scoped_lock::adopt_lock); // Exception operations must be processed first to ensure that any // out-of-band data is read before normal data. static const int flag[max_ops] = { EPOLLIN, EPOLLOUT, EPOLLPRI }; for (int j = max_ops - 1; j >= 0; --j) { if (events & (flag[j] \| EPOLLERR \| EPOLLHUP)) { try_speculative_[j] = true; while (reactor_op* op = op_queue_[j].front()) { if (reactor_op::status status = op->perform()) { op_queue_[j].pop(); io_cleanup.ops_.push(op); if (status == reactor_op::done_and_exhausted) { try_speculative_[j] = false; break; } } else break; } } } // The first operation will be returned for completion now. The others will // be posted for later by the io_cleanup object's destructor. io_cleanup.first_op_ = io_cleanup.ops_.front(); io_cleanup.ops_.pop(); return io_cleanup.first_op_; } void epoll_reactor::descriptor_state::do_complete( void* owner, operation* base, const boost::system::error_code& ec, std::size_t bytes_transferred) { if (owner) { descriptor_state* descriptor_data = static_cast<descriptor_state>(base); uint32_t events = static_cast<uint32_t>(bytes_transferred); if (operation op = descriptor_data->perform_io(events)) { op->complete(owner, ec, 0); } } } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_EPOLL) #endif // BOOST_ASIO_DETAIL_IMPL_EPOLL_REACTOR_IPP PK��h!\ڡ\ ��\ ��impl/service_registry.hppnu��[��// // detail/impl/service_registry.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_SERVICE_REGISTRY_HPP #define BOOST_ASIO_DETAIL_IMPL_SERVICE_REGISTRY_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Service> Service& service_registry::use_service() { execution_context::service::key key; init_key<Service>(key, 0); factory_type factory = &service_registry::create<Service, execution_context>; return static_cast<Service>(do_use_service(key, factory, &owner_)); } template <typename Service> Service& service_registry::use_service(io_context& owner) { execution_context::service::key key; init_key<Service>(key, 0); factory_type factory = &service_registry::create<Service, io_context>; return static_cast<Service>(do_use_service(key, factory, &owner)); } template <typename Service> void service_registry::add_service(Service* new_service) { execution_context::service::key key; init_key<Service>(key, 0); return do_add_service(key, new_service); } template <typename Service> bool service_registry::has_service() const { execution_context::service::key key; init_key<Service>(key, 0); return do_has_service(key); } template <typename Service> inline void service_registry::init_key( execution_context::service::key& key, ...) { init_key_from_id(key, Service::id); } #if !defined(BOOST_ASIO_NO_TYPEID) template <typename Service> void service_registry::init_key(execution_context::service::key& key, typename enable_if< is_base_of<typename Service::key_type, Service>::value>::type) { key.type_info_ = &typeid(typeid_wrapper<Service>); key.id_ = 0; } template <typename Service> void service_registry::init_key_from_id(execution_context::service::key& key, const service_id<Service>& /id/) { key.type_info_ = &typeid(typeid_wrapper<Service>); key.id_ = 0; } #endif // !defined(BOOST_ASIO_NO_TYPEID) template <typename Service, typename Owner> execution_context::service service_registry::create(void* owner) { return new Service(static_cast<Owner>(owner)); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_IMPL_SERVICE_REGISTRY_HPP PK��h!\z��>>��>��impl/scheduler.ippnu��[��// // detail/impl/scheduler.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_SCHEDULER_IPP #define BOOST_ASIO_DETAIL_IMPL_SCHEDULER_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/detail/concurrency_hint.hpp> #include <boost/asio/detail/event.hpp> #include <boost/asio/detail/limits.hpp> #include <boost/asio/detail/reactor.hpp> #include <boost/asio/detail/scheduler.hpp> #include <boost/asio/detail/scheduler_thread_info.hpp> #include <boost/asio/detail/signal_blocker.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class scheduler::thread_function { public: explicit thread_function(scheduler* s) : this_(s) { } void operator()() { boost::system::error_code ec; this_->run(ec); } private: scheduler* this_; }; struct scheduler::task_cleanup { ~task_cleanup() { if (this_thread_->private_outstanding_work > 0) { boost::asio::detail::increment( scheduler_->outstanding_work_, this_thread_->private_outstanding_work); } this_thread_->private_outstanding_work = 0; // Enqueue the completed operations and reinsert the task at the end of // the operation queue. lock_->lock(); scheduler_->task_interrupted_ = true; scheduler_->op_queue_.push(this_thread_->private_op_queue); scheduler_->op_queue_.push(&scheduler_->task_operation_); } scheduler* scheduler_; mutex::scoped_lock* lock_; thread_info* this_thread_; }; struct scheduler::work_cleanup { ~work_cleanup() { if (this_thread_->private_outstanding_work > 1) { boost::asio::detail::increment( scheduler_->outstanding_work_, this_thread_->private_outstanding_work - 1); } else if (this_thread_->private_outstanding_work < 1) { scheduler_->work_finished(); } this_thread_->private_outstanding_work = 0; #if defined(BOOST_ASIO_HAS_THREADS) if (!this_thread_->private_op_queue.empty()) { lock_->lock(); scheduler_->op_queue_.push(this_thread_->private_op_queue); } #endif // defined(BOOST_ASIO_HAS_THREADS) } scheduler* scheduler_; mutex::scoped_lock* lock_; thread_info* this_thread_; }; scheduler::scheduler(boost::asio::execution_context& ctx, int concurrency_hint, bool own_thread) : boost::asio::detail::execution_context_service_base<scheduler>(ctx), one_thread_(concurrency_hint == 1 \|\| !BOOST_ASIO_CONCURRENCY_HINT_IS_LOCKING( SCHEDULER, concurrency_hint) \|\| !BOOST_ASIO_CONCURRENCY_HINT_IS_LOCKING( REACTOR_IO, concurrency_hint)), mutex_(BOOST_ASIO_CONCURRENCY_HINT_IS_LOCKING( SCHEDULER, concurrency_hint)), task_(0), task_interrupted_(true), outstanding_work_(0), stopped_(false), shutdown_(false), concurrency_hint_(concurrency_hint), thread_(0) { BOOST_ASIO_HANDLER_TRACKING_INIT; if (own_thread) { ++outstanding_work_; boost::asio::detail::signal_blocker sb; thread_ = new boost::asio::detail::thread(thread_function(this)); } } scheduler::~scheduler() { if (thread_) { mutex::scoped_lock lock(mutex_); shutdown_ = true; stop_all_threads(lock); lock.unlock(); thread_->join(); delete thread_; } } void scheduler::shutdown() { mutex::scoped_lock lock(mutex_); shutdown_ = true; if (thread_) stop_all_threads(lock); lock.unlock(); // Join thread to ensure task operation is returned to queue. if (thread_) { thread_->join(); delete thread_; thread_ = 0; } // Destroy handler objects. while (!op_queue_.empty()) { operation* o = op_queue_.front(); op_queue_.pop(); if (o != &task_operation_) o->destroy(); } // Reset to initial state. task_ = 0; } void scheduler::init_task() { mutex::scoped_lock lock(mutex_); if (!shutdown_ && !task_) { task_ = &use_service<reactor>(this->context()); op_queue_.push(&task_operation_); wake_one_thread_and_unlock(lock); } } std::size_t scheduler::run(boost::system::error_code& ec) { ec = boost::system::error_code(); if (outstanding_work_ == 0) { stop(); return 0; } thread_info this_thread; this_thread.private_outstanding_work = 0; thread_call_stack::context ctx(this, this_thread); mutex::scoped_lock lock(mutex_); std::size_t n = 0; for (; do_run_one(lock, this_thread, ec); lock.lock()) if (n != (std::numeric_limits<std::size_t>::max)()) ++n; return n; } std::size_t scheduler::run_one(boost::system::error_code& ec) { ec = boost::system::error_code(); if (outstanding_work_ == 0) { stop(); return 0; } thread_info this_thread; this_thread.private_outstanding_work = 0; thread_call_stack::context ctx(this, this_thread); mutex::scoped_lock lock(mutex_); return do_run_one(lock, this_thread, ec); } std::size_t scheduler::wait_one(long usec, boost::system::error_code& ec) { ec = boost::system::error_code(); if (outstanding_work_ == 0) { stop(); return 0; } thread_info this_thread; this_thread.private_outstanding_work = 0; thread_call_stack::context ctx(this, this_thread); mutex::scoped_lock lock(mutex_); return do_wait_one(lock, this_thread, usec, ec); } std::size_t scheduler::poll(boost::system::error_code& ec) { ec = boost::system::error_code(); if (outstanding_work_ == 0) { stop(); return 0; } thread_info this_thread; this_thread.private_outstanding_work = 0; thread_call_stack::context ctx(this, this_thread); mutex::scoped_lock lock(mutex_); #if defined(BOOST_ASIO_HAS_THREADS) // We want to support nested calls to poll() and poll_one(), so any handlers // that are already on a thread-private queue need to be put on to the main // queue now. if (one_thread_) if (thread_info* outer_info = static_cast<thread_info>(ctx.next_by_key())) op_queue_.push(outer_info->private_op_queue); #endif // defined(BOOST_ASIO_HAS_THREADS) std::size_t n = 0; for (; do_poll_one(lock, this_thread, ec); lock.lock()) if (n != (std::numeric_limits<std::size_t>::max)()) ++n; return n; } std::size_t scheduler::poll_one(boost::system::error_code& ec) { ec = boost::system::error_code(); if (outstanding_work_ == 0) { stop(); return 0; } thread_info this_thread; this_thread.private_outstanding_work = 0; thread_call_stack::context ctx(this, this_thread); mutex::scoped_lock lock(mutex_); #if defined(BOOST_ASIO_HAS_THREADS) // We want to support nested calls to poll() and poll_one(), so any handlers // that are already on a thread-private queue need to be put on to the main // queue now. if (one_thread_) if (thread_info outer_info = static_cast<thread_info>(ctx.next_by_key())) op_queue_.push(outer_info->private_op_queue); #endif // defined(BOOST_ASIO_HAS_THREADS) return do_poll_one(lock, this_thread, ec); } void scheduler::stop() { mutex::scoped_lock lock(mutex_); stop_all_threads(lock); } bool scheduler::stopped() const { mutex::scoped_lock lock(mutex_); return stopped_; } void scheduler::restart() { mutex::scoped_lock lock(mutex_); stopped_ = false; } void scheduler::compensating_work_started() { thread_info_base this_thread = thread_call_stack::contains(this); ++static_cast<thread_info>(this_thread)->private_outstanding_work; } void scheduler::capture_current_exception() { if (thread_info_base this_thread = thread_call_stack::contains(this)) this_thread->capture_current_exception(); } void scheduler::post_immediate_completion( scheduler::operation* op, bool is_continuation) { #if defined(BOOST_ASIO_HAS_THREADS) if (one_thread_ \|\| is_continuation) { if (thread_info_base* this_thread = thread_call_stack::contains(this)) { ++static_cast<thread_info>(this_thread)->private_outstanding_work; static_cast<thread_info>(this_thread)->private_op_queue.push(op); return; } } #else // defined(BOOST_ASIO_HAS_THREADS) (void)is_continuation; #endif // defined(BOOST_ASIO_HAS_THREADS) work_started(); mutex::scoped_lock lock(mutex_); op_queue_.push(op); wake_one_thread_and_unlock(lock); } void scheduler::post_immediate_completions(std::size_t n, op_queue<scheduler::operation>& ops, bool is_continuation) { #if defined(BOOST_ASIO_HAS_THREADS) if (one_thread_ \|\| is_continuation) { if (thread_info_base* this_thread = thread_call_stack::contains(this)) { static_cast<thread_info>(this_thread)->private_outstanding_work += static_cast<long>(n); static_cast<thread_info>(this_thread)->private_op_queue.push(ops); return; } } #else // defined(BOOST_ASIO_HAS_THREADS) (void)is_continuation; #endif // defined(BOOST_ASIO_HAS_THREADS) increment(outstanding_work_, static_cast<long>(n)); mutex::scoped_lock lock(mutex_); op_queue_.push(ops); wake_one_thread_and_unlock(lock); } void scheduler::post_deferred_completion(scheduler::operation* op) { #if defined(BOOST_ASIO_HAS_THREADS) if (one_thread_) { if (thread_info_base* this_thread = thread_call_stack::contains(this)) { static_cast<thread_info>(this_thread)->private_op_queue.push(op); return; } } #endif // defined(BOOST_ASIO_HAS_THREADS) mutex::scoped_lock lock(mutex_); op_queue_.push(op); wake_one_thread_and_unlock(lock); } void scheduler::post_deferred_completions( op_queue<scheduler::operation>& ops) { if (!ops.empty()) { #if defined(BOOST_ASIO_HAS_THREADS) if (one_thread_) { if (thread_info_base this_thread = thread_call_stack::contains(this)) { static_cast<thread_info>(this_thread)->private_op_queue.push(ops); return; } } #endif // defined(BOOST_ASIO_HAS_THREADS) mutex::scoped_lock lock(mutex_); op_queue_.push(ops); wake_one_thread_and_unlock(lock); } } void scheduler::do_dispatch( scheduler::operation op) { work_started(); mutex::scoped_lock lock(mutex_); op_queue_.push(op); wake_one_thread_and_unlock(lock); } void scheduler::abandon_operations( op_queue<scheduler::operation>& ops) { op_queue<scheduler::operation> ops2; ops2.push(ops); } std::size_t scheduler::do_run_one(mutex::scoped_lock& lock, scheduler::thread_info& this_thread, const boost::system::error_code& ec) { while (!stopped_) { if (!op_queue_.empty()) { // Prepare to execute first handler from queue. operation* o = op_queue_.front(); op_queue_.pop(); bool more_handlers = (!op_queue_.empty()); if (o == &task_operation_) { task_interrupted_ = more_handlers; if (more_handlers && !one_thread_) wakeup_event_.unlock_and_signal_one(lock); else lock.unlock(); task_cleanup on_exit = { this, &lock, &this_thread }; (void)on_exit; // Run the task. May throw an exception. Only block if the operation // queue is empty and we're not polling, otherwise we want to return // as soon as possible. task_->run(more_handlers ? 0 : -1, this_thread.private_op_queue); } else { std::size_t task_result = o->task_result_; if (more_handlers && !one_thread_) wake_one_thread_and_unlock(lock); else lock.unlock(); // Ensure the count of outstanding work is decremented on block exit. work_cleanup on_exit = { this, &lock, &this_thread }; (void)on_exit; // Complete the operation. May throw an exception. Deletes the object. o->complete(this, ec, task_result); this_thread.rethrow_pending_exception(); return 1; } } else { wakeup_event_.clear(lock); wakeup_event_.wait(lock); } } return 0; } std::size_t scheduler::do_wait_one(mutex::scoped_lock& lock, scheduler::thread_info& this_thread, long usec, const boost::system::error_code& ec) { if (stopped_) return 0; operation* o = op_queue_.front(); if (o == 0) { wakeup_event_.clear(lock); wakeup_event_.wait_for_usec(lock, usec); usec = 0; // Wait at most once. o = op_queue_.front(); } if (o == &task_operation_) { op_queue_.pop(); bool more_handlers = (!op_queue_.empty()); task_interrupted_ = more_handlers; if (more_handlers && !one_thread_) wakeup_event_.unlock_and_signal_one(lock); else lock.unlock(); { task_cleanup on_exit = { this, &lock, &this_thread }; (void)on_exit; // Run the task. May throw an exception. Only block if the operation // queue is empty and we're not polling, otherwise we want to return // as soon as possible. task_->run(more_handlers ? 0 : usec, this_thread.private_op_queue); } o = op_queue_.front(); if (o == &task_operation_) { if (!one_thread_) wakeup_event_.maybe_unlock_and_signal_one(lock); return 0; } } if (o == 0) return 0; op_queue_.pop(); bool more_handlers = (!op_queue_.empty()); std::size_t task_result = o->task_result_; if (more_handlers && !one_thread_) wake_one_thread_and_unlock(lock); else lock.unlock(); // Ensure the count of outstanding work is decremented on block exit. work_cleanup on_exit = { this, &lock, &this_thread }; (void)on_exit; // Complete the operation. May throw an exception. Deletes the object. o->complete(this, ec, task_result); this_thread.rethrow_pending_exception(); return 1; } std::size_t scheduler::do_poll_one(mutex::scoped_lock& lock, scheduler::thread_info& this_thread, const boost::system::error_code& ec) { if (stopped_) return 0; operation* o = op_queue_.front(); if (o == &task_operation_) { op_queue_.pop(); lock.unlock(); { task_cleanup c = { this, &lock, &this_thread }; (void)c; // Run the task. May throw an exception. Only block if the operation // queue is empty and we're not polling, otherwise we want to return // as soon as possible. task_->run(0, this_thread.private_op_queue); } o = op_queue_.front(); if (o == &task_operation_) { wakeup_event_.maybe_unlock_and_signal_one(lock); return 0; } } if (o == 0) return 0; op_queue_.pop(); bool more_handlers = (!op_queue_.empty()); std::size_t task_result = o->task_result_; if (more_handlers && !one_thread_) wake_one_thread_and_unlock(lock); else lock.unlock(); // Ensure the count of outstanding work is decremented on block exit. work_cleanup on_exit = { this, &lock, &this_thread }; (void)on_exit; // Complete the operation. May throw an exception. Deletes the object. o->complete(this, ec, task_result); this_thread.rethrow_pending_exception(); return 1; } void scheduler::stop_all_threads( mutex::scoped_lock& lock) { stopped_ = true; wakeup_event_.signal_all(lock); if (!task_interrupted_ && task_) { task_interrupted_ = true; task_->interrupt(); } } void scheduler::wake_one_thread_and_unlock( mutex::scoped_lock& lock) { if (!wakeup_event_.maybe_unlock_and_signal_one(lock)) { if (!task_interrupted_ && task_) { task_interrupted_ = true; task_->interrupt(); } lock.unlock(); } } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_IMPL_SCHEDULER_IPP PK��h!\�2��impl/winsock_init.ippnu��[��// // detail/impl/winsock_init.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_WINSOCK_INIT_IPP #define BOOST_ASIO_DETAIL_IMPL_WINSOCK_INIT_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_WINDOWS) \|\| defined(__CYGWIN__) #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/winsock_init.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { void winsock_init_base::startup(data& d, unsigned char major, unsigned char minor) { if (::InterlockedIncrement(&d.init_count_) == 1) { WSADATA wsa_data; long result = ::WSAStartup(MAKEWORD(major, minor), &wsa_data); ::InterlockedExchange(&d.result_, result); } } void winsock_init_base::manual_startup(data& d) { if (::InterlockedIncrement(&d.init_count_) == 1) { ::InterlockedExchange(&d.result_, 0); } } void winsock_init_base::cleanup(data& d) { if (::InterlockedDecrement(&d.init_count_) == 0) { ::WSACleanup(); } } void winsock_init_base::manual_cleanup(data& d) { ::InterlockedDecrement(&d.init_count_); } void winsock_init_base::throw_on_error(data& d) { long result = ::InterlockedExchangeAdd(&d.result_, 0); if (result != 0) { boost::system::error_code ec(result, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "winsock"); } } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_IMPL_WINSOCK_INIT_IPP PK��h!\c��impl/win_iocp_io_context.hppnu��[��// // detail/impl/win_iocp_io_context.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_WIN_IOCP_IO_CONTEXT_HPP #define BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_IO_CONTEXT_HPP #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_HAS_IOCP) #include <boost/asio/detail/completion_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Time_Traits> void win_iocp_io_context::add_timer_queue( timer_queue<Time_Traits>& queue) { do_add_timer_queue(queue); } template <typename Time_Traits> void win_iocp_io_context::remove_timer_queue( timer_queue<Time_Traits>& queue) { do_remove_timer_queue(queue); } template <typename Time_Traits> void win_iocp_io_context::schedule_timer(timer_queue<Time_Traits>& queue, const typename Time_Traits::time_type& time, typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op) { // If the service has been shut down we silently discard the timer. if (::InterlockedExchangeAdd(&shutdown_, 0) != 0) { post_immediate_completion(op, false); return; } mutex::scoped_lock lock(dispatch_mutex_); bool earliest = queue.enqueue_timer(time, timer, op); work_started(); if (earliest) update_timeout(); } template <typename Time_Traits> std::size_t win_iocp_io_context::cancel_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& timer, std::size_t max_cancelled) { // If the service has been shut down we silently ignore the cancellation. if (::InterlockedExchangeAdd(&shutdown_, 0) != 0) return 0; mutex::scoped_lock lock(dispatch_mutex_); op_queue<win_iocp_operation> ops; std::size_t n = queue.cancel_timer(timer, ops, max_cancelled); lock.unlock(); post_deferred_completions(ops); return n; } template <typename Time_Traits> void win_iocp_io_context::move_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& to, typename timer_queue<Time_Traits>::per_timer_data& from) { boost::asio::detail::mutex::scoped_lock lock(dispatch_mutex_); op_queue<operation> ops; queue.cancel_timer(to, ops); queue.move_timer(to, from); lock.unlock(); post_deferred_completions(ops); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #endif // BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_IO_CONTEXT_HPP PK��h!\;0�ub"��b"��%��impl/reactive_socket_service_base.ippnu��[��// // detail/reactive_socket_service_base.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_REACTIVE_SOCKET_SERVICE_BASE_IPP #define BOOST_ASIO_DETAIL_IMPL_REACTIVE_SOCKET_SERVICE_BASE_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_HAS_IOCP) \ && !defined(BOOST_ASIO_WINDOWS_RUNTIME) #include <boost/asio/detail/reactive_socket_service_base.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { reactive_socket_service_base::reactive_socket_service_base( execution_context& context) : reactor_(use_service<reactor>(context)) { reactor_.init_task(); } void reactive_socket_service_base::base_shutdown() { } void reactive_socket_service_base::construct( reactive_socket_service_base::base_implementation_type& impl) { impl.socket_ = invalid_socket; impl.state_ = 0; } void reactive_socket_service_base::base_move_construct( reactive_socket_service_base::base_implementation_type& impl, reactive_socket_service_base::base_implementation_type& other_impl) BOOST_ASIO_NOEXCEPT { impl.socket_ = other_impl.socket_; other_impl.socket_ = invalid_socket; impl.state_ = other_impl.state_; other_impl.state_ = 0; reactor_.move_descriptor(impl.socket_, impl.reactor_data_, other_impl.reactor_data_); } void reactive_socket_service_base::base_move_assign( reactive_socket_service_base::base_implementation_type& impl, reactive_socket_service_base& other_service, reactive_socket_service_base::base_implementation_type& other_impl) { destroy(impl); impl.socket_ = other_impl.socket_; other_impl.socket_ = invalid_socket; impl.state_ = other_impl.state_; other_impl.state_ = 0; other_service.reactor_.move_descriptor(impl.socket_, impl.reactor_data_, other_impl.reactor_data_); } void reactive_socket_service_base::destroy( reactive_socket_service_base::base_implementation_type& impl) { if (impl.socket_ != invalid_socket) { BOOST_ASIO_HANDLER_OPERATION((reactor_.context(), "socket", &impl, impl.socket_, "close")); reactor_.deregister_descriptor(impl.socket_, impl.reactor_data_, (impl.state_ & socket_ops::possible_dup) == 0); boost::system::error_code ignored_ec; socket_ops::close(impl.socket_, impl.state_, true, ignored_ec); reactor_.cleanup_descriptor_data(impl.reactor_data_); } } boost::system::error_code reactive_socket_service_base::close( reactive_socket_service_base::base_implementation_type& impl, boost::system::error_code& ec) { if (is_open(impl)) { BOOST_ASIO_HANDLER_OPERATION((reactor_.context(), "socket", &impl, impl.socket_, "close")); reactor_.deregister_descriptor(impl.socket_, impl.reactor_data_, (impl.state_ & socket_ops::possible_dup) == 0); socket_ops::close(impl.socket_, impl.state_, false, ec); reactor_.cleanup_descriptor_data(impl.reactor_data_); } else { ec = boost::system::error_code(); } // The descriptor is closed by the OS even if close() returns an error. // // (Actually, POSIX says the state of the descriptor is unspecified. On // Linux the descriptor is apparently closed anyway; e.g. see // http://lkml.org/lkml/2005/9/10/129 // We'll just have to assume that other OSes follow the same behaviour. The // known exception is when Windows's closesocket() function fails with // WSAEWOULDBLOCK, but this case is handled inside socket_ops::close(). construct(impl); return ec; } socket_type reactive_socket_service_base::release( reactive_socket_service_base::base_implementation_type& impl, boost::system::error_code& ec) { if (!is_open(impl)) { ec = boost::asio::error::bad_descriptor; return invalid_socket; } BOOST_ASIO_HANDLER_OPERATION((reactor_.context(), "socket", &impl, impl.socket_, "release")); reactor_.deregister_descriptor(impl.socket_, impl.reactor_data_, false); reactor_.cleanup_descriptor_data(impl.reactor_data_); socket_type sock = impl.socket_; construct(impl); ec = boost::system::error_code(); return sock; } boost::system::error_code reactive_socket_service_base::cancel( reactive_socket_service_base::base_implementation_type& impl, boost::system::error_code& ec) { if (!is_open(impl)) { ec = boost::asio::error::bad_descriptor; return ec; } BOOST_ASIO_HANDLER_OPERATION((reactor_.context(), "socket", &impl, impl.socket_, "cancel")); reactor_.cancel_ops(impl.socket_, impl.reactor_data_); ec = boost::system::error_code(); return ec; } boost::system::error_code reactive_socket_service_base::do_open( reactive_socket_service_base::base_implementation_type& impl, int af, int type, int protocol, boost::system::error_code& ec) { if (is_open(impl)) { ec = boost::asio::error::already_open; return ec; } socket_holder sock(socket_ops::socket(af, type, protocol, ec)); if (sock.get() == invalid_socket) return ec; if (int err = reactor_.register_descriptor(sock.get(), impl.reactor_data_)) { ec = boost::system::error_code(err, boost::asio::error::get_system_category()); return ec; } impl.socket_ = sock.release(); switch (type) { case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break; case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break; default: impl.state_ = 0; break; } ec = boost::system::error_code(); return ec; } boost::system::error_code reactive_socket_service_base::do_assign( reactive_socket_service_base::base_implementation_type& impl, int type, const reactive_socket_service_base::native_handle_type& native_socket, boost::system::error_code& ec) { if (is_open(impl)) { ec = boost::asio::error::already_open; return ec; } if (int err = reactor_.register_descriptor( native_socket, impl.reactor_data_)) { ec = boost::system::error_code(err, boost::asio::error::get_system_category()); return ec; } impl.socket_ = native_socket; switch (type) { case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break; case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break; default: impl.state_ = 0; break; } impl.state_ \|= socket_ops::possible_dup; ec = boost::system::error_code(); return ec; } void reactive_socket_service_base::start_op( reactive_socket_service_base::base_implementation_type& impl, int op_type, reactor_op* op, bool is_continuation, bool is_non_blocking, bool noop) { if (!noop) { if ((impl.state_ & socket_ops::non_blocking) \|\| socket_ops::set_internal_non_blocking( impl.socket_, impl.state_, true, op->ec_)) { reactor_.start_op(op_type, impl.socket_, impl.reactor_data_, op, is_continuation, is_non_blocking); return; } } reactor_.post_immediate_completion(op, is_continuation); } void reactive_socket_service_base::start_accept_op( reactive_socket_service_base::base_implementation_type& impl, reactor_op* op, bool is_continuation, bool peer_is_open) { if (!peer_is_open) start_op(impl, reactor::read_op, op, is_continuation, true, false); else { op->ec_ = boost::asio::error::already_open; reactor_.post_immediate_completion(op, is_continuation); } } void reactive_socket_service_base::start_connect_op( reactive_socket_service_base::base_implementation_type& impl, reactor_op* op, bool is_continuation, const socket_addr_type* addr, size_t addrlen) { if ((impl.state_ & socket_ops::non_blocking) \|\| socket_ops::set_internal_non_blocking( impl.socket_, impl.state_, true, op->ec_)) { if (socket_ops::connect(impl.socket_, addr, addrlen, op->ec_) != 0) { if (op->ec_ == boost::asio::error::in_progress \|\| op->ec_ == boost::asio::error::would_block) { op->ec_ = boost::system::error_code(); reactor_.start_op(reactor::connect_op, impl.socket_, impl.reactor_data_, op, is_continuation, false); return; } } } reactor_.post_immediate_completion(op, is_continuation); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // !defined(BOOST_ASIO_HAS_IOCP) // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_IMPL_REACTIVE_SOCKET_SERVICE_BASE_IPP PK��h!\!�k�O��O��impl/signal_set_service.ippnu��[��// // detail/impl/signal_set_service.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_SIGNAL_SET_SERVICE_IPP #define BOOST_ASIO_DETAIL_IMPL_SIGNAL_SET_SERVICE_IPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <cstring> #include <stdexcept> #include <boost/asio/detail/reactor.hpp> #include <boost/asio/detail/signal_blocker.hpp> #include <boost/asio/detail/signal_set_service.hpp> #include <boost/asio/detail/static_mutex.hpp> #include <boost/asio/detail/throw_exception.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { struct signal_state { // Mutex used for protecting global state. static_mutex mutex_; // The read end of the pipe used for signal notifications. int read_descriptor_; // The write end of the pipe used for signal notifications. int write_descriptor_; // Whether the signal state has been prepared for a fork. bool fork_prepared_; // The head of a linked list of all signal_set_service instances. class signal_set_service* service_list_; // A count of the number of objects that are registered for each signal. std::size_t registration_count_[max_signal_number]; }; signal_state* get_signal_state() { static signal_state state = { BOOST_ASIO_STATIC_MUTEX_INIT, -1, -1, false, 0, { 0 } }; return &state; } void boost_asio_signal_handler(int signal_number) { #if defined(BOOST_ASIO_WINDOWS) \ \|\| defined(BOOST_ASIO_WINDOWS_RUNTIME) \ \|\| defined(__CYGWIN__) signal_set_service::deliver_signal(signal_number); #else // defined(BOOST_ASIO_WINDOWS) // \|\| defined(BOOST_ASIO_WINDOWS_RUNTIME) // \|\| defined(__CYGWIN__) int saved_errno = errno; signal_state* state = get_signal_state(); signed_size_type result = ::write(state->write_descriptor_, &signal_number, sizeof(signal_number)); (void)result; errno = saved_errno; #endif // defined(BOOST_ASIO_WINDOWS) // \|\| defined(BOOST_ASIO_WINDOWS_RUNTIME) // \|\| defined(__CYGWIN__) #if defined(BOOST_ASIO_HAS_SIGNAL) && !defined(BOOST_ASIO_HAS_SIGACTION) ::signal(signal_number, boost_asio_signal_handler); #endif // defined(BOOST_ASIO_HAS_SIGNAL) && !defined(BOOST_ASIO_HAS_SIGACTION) } #if !defined(BOOST_ASIO_WINDOWS) \ && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ && !defined(__CYGWIN__) class signal_set_service::pipe_read_op : public reactor_op { public: pipe_read_op() : reactor_op(boost::system::error_code(), &pipe_read_op::do_perform, pipe_read_op::do_complete) { } static status do_perform(reactor_op) { signal_state state = get_signal_state(); int fd = state->read_descriptor_; int signal_number = 0; while (::read(fd, &signal_number, sizeof(int)) == sizeof(int)) if (signal_number >= 0 && signal_number < max_signal_number) signal_set_service::deliver_signal(signal_number); return not_done; } static void do_complete(void* /owner/, operation* base, const boost::system::error_code& /ec/, std::size_t /bytes_transferred/) { pipe_read_op* o(static_cast<pipe_read_op>(base)); delete o; } }; #endif // !defined(BOOST_ASIO_WINDOWS) // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) // && !defined(__CYGWIN__) signal_set_service::signal_set_service(execution_context& context) : execution_context_service_base<signal_set_service>(context), scheduler_(boost::asio::use_service<scheduler_impl>(context)), #if !defined(BOOST_ASIO_WINDOWS) \ && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ && !defined(__CYGWIN__) reactor_(boost::asio::use_service<reactor>(context)), #endif // !defined(BOOST_ASIO_WINDOWS) // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) // && !defined(__CYGWIN__) next_(0), prev_(0) { get_signal_state()->mutex_.init(); #if !defined(BOOST_ASIO_WINDOWS) \ && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ && !defined(__CYGWIN__) reactor_.init_task(); #endif // !defined(BOOST_ASIO_WINDOWS) // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) // && !defined(__CYGWIN__) for (int i = 0; i < max_signal_number; ++i) registrations_[i] = 0; add_service(this); } signal_set_service::~signal_set_service() { remove_service(this); } void signal_set_service::shutdown() { remove_service(this); op_queue<operation> ops; for (int i = 0; i < max_signal_number; ++i) { registration reg = registrations_[i]; while (reg) { ops.push(reg->queue_); reg = reg->next_in_table_; } } scheduler_.abandon_operations(ops); } void signal_set_service::notify_fork(execution_context::fork_event fork_ev) { #if !defined(BOOST_ASIO_WINDOWS) \ && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ && !defined(__CYGWIN__) signal_state state = get_signal_state(); static_mutex::scoped_lock lock(state->mutex_); switch (fork_ev) { case execution_context::fork_prepare: { int read_descriptor = state->read_descriptor_; state->fork_prepared_ = true; lock.unlock(); reactor_.deregister_internal_descriptor(read_descriptor, reactor_data_); reactor_.cleanup_descriptor_data(reactor_data_); } break; case execution_context::fork_parent: if (state->fork_prepared_) { int read_descriptor = state->read_descriptor_; state->fork_prepared_ = false; lock.unlock(); reactor_.register_internal_descriptor(reactor::read_op, read_descriptor, reactor_data_, new pipe_read_op); } break; case execution_context::fork_child: if (state->fork_prepared_) { boost::asio::detail::signal_blocker blocker; close_descriptors(); open_descriptors(); int read_descriptor = state->read_descriptor_; state->fork_prepared_ = false; lock.unlock(); reactor_.register_internal_descriptor(reactor::read_op, read_descriptor, reactor_data_, new pipe_read_op); } break; default: break; } #else // !defined(BOOST_ASIO_WINDOWS) // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) // && !defined(__CYGWIN__) (void)fork_ev; #endif // !defined(BOOST_ASIO_WINDOWS) // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) // && !defined(__CYGWIN__) } void signal_set_service::construct( signal_set_service::implementation_type& impl) { impl.signals_ = 0; } void signal_set_service::destroy( signal_set_service::implementation_type& impl) { boost::system::error_code ignored_ec; clear(impl, ignored_ec); cancel(impl, ignored_ec); } boost::system::error_code signal_set_service::add( signal_set_service::implementation_type& impl, int signal_number, boost::system::error_code& ec) { // Check that the signal number is valid. if (signal_number < 0 \|\| signal_number >= max_signal_number) { ec = boost::asio::error::invalid_argument; return ec; } signal_state* state = get_signal_state(); static_mutex::scoped_lock lock(state->mutex_); // Find the appropriate place to insert the registration. registration** insertion_point = &impl.signals_; registration* next = impl.signals_; while (next && next->signal_number_ < signal_number) { insertion_point = &next->next_in_set_; next = next->next_in_set_; } // Only do something if the signal is not already registered. if (next == 0 \|\| next->signal_number_ != signal_number) { registration* new_registration = new registration; #if defined(BOOST_ASIO_HAS_SIGNAL) \|\| defined(BOOST_ASIO_HAS_SIGACTION) // Register for the signal if we're the first. if (state->registration_count_[signal_number] == 0) { # if defined(BOOST_ASIO_HAS_SIGACTION) using namespace std; // For memset. struct sigaction sa; memset(&sa, 0, sizeof(sa)); sa.sa_handler = boost_asio_signal_handler; sigfillset(&sa.sa_mask); if (::sigaction(signal_number, &sa, 0) == -1) # else // defined(BOOST_ASIO_HAS_SIGACTION) if (::signal(signal_number, boost_asio_signal_handler) == SIG_ERR) # endif // defined(BOOST_ASIO_HAS_SIGACTION) { # if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) ec = boost::asio::error::invalid_argument; # else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) ec = boost::system::error_code(errno, boost::asio::error::get_system_category()); # endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) delete new_registration; return ec; } } #endif // defined(BOOST_ASIO_HAS_SIGNAL) \|\| defined(BOOST_ASIO_HAS_SIGACTION) // Record the new registration in the set. new_registration->signal_number_ = signal_number; new_registration->queue_ = &impl.queue_; new_registration->next_in_set_ = next; insertion_point = new_registration; // Insert registration into the registration table. new_registration->next_in_table_ = registrations_[signal_number]; if (registrations_[signal_number]) registrations_[signal_number]->prev_in_table_ = new_registration; registrations_[signal_number] = new_registration; ++state->registration_count_[signal_number]; } ec = boost::system::error_code(); return ec; } boost::system::error_code signal_set_service::remove( signal_set_service::implementation_type& impl, int signal_number, boost::system::error_code& ec) { // Check that the signal number is valid. if (signal_number < 0 \|\| signal_number >= max_signal_number) { ec = boost::asio::error::invalid_argument; return ec; } signal_state state = get_signal_state(); static_mutex::scoped_lock lock(state->mutex_); // Find the signal number in the list of registrations. registration** deletion_point = &impl.signals_; registration* reg = impl.signals_; while (reg && reg->signal_number_ < signal_number) { deletion_point = &reg->next_in_set_; reg = reg->next_in_set_; } if (reg != 0 && reg->signal_number_ == signal_number) { #if defined(BOOST_ASIO_HAS_SIGNAL) \|\| defined(BOOST_ASIO_HAS_SIGACTION) // Set signal handler back to the default if we're the last. if (state->registration_count_[signal_number] == 1) { # if defined(BOOST_ASIO_HAS_SIGACTION) using namespace std; // For memset. struct sigaction sa; memset(&sa, 0, sizeof(sa)); sa.sa_handler = SIG_DFL; if (::sigaction(signal_number, &sa, 0) == -1) # else // defined(BOOST_ASIO_HAS_SIGACTION) if (::signal(signal_number, SIG_DFL) == SIG_ERR) # endif // defined(BOOST_ASIO_HAS_SIGACTION) { # if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) ec = boost::asio::error::invalid_argument; # else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) ec = boost::system::error_code(errno, boost::asio::error::get_system_category()); # endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) return ec; } } #endif // defined(BOOST_ASIO_HAS_SIGNAL) \|\| defined(BOOST_ASIO_HAS_SIGACTION) // Remove the registration from the set. deletion_point = reg->next_in_set_; // Remove the registration from the registration table. if (registrations_[signal_number] == reg) registrations_[signal_number] = reg->next_in_table_; if (reg->prev_in_table_) reg->prev_in_table_->next_in_table_ = reg->next_in_table_; if (reg->next_in_table_) reg->next_in_table_->prev_in_table_ = reg->prev_in_table_; --state->registration_count_[signal_number]; delete reg; } ec = boost::system::error_code(); return ec; } boost::system::error_code signal_set_service::clear( signal_set_service::implementation_type& impl, boost::system::error_code& ec) { signal_state state = get_signal_state(); static_mutex::scoped_lock lock(state->mutex_); while (registration* reg = impl.signals_) { #if defined(BOOST_ASIO_HAS_SIGNAL) \|\| defined(BOOST_ASIO_HAS_SIGACTION) // Set signal handler back to the default if we're the last. if (state->registration_count_[reg->signal_number_] == 1) { # if defined(BOOST_ASIO_HAS_SIGACTION) using namespace std; // For memset. struct sigaction sa; memset(&sa, 0, sizeof(sa)); sa.sa_handler = SIG_DFL; if (::sigaction(reg->signal_number_, &sa, 0) == -1) # else // defined(BOOST_ASIO_HAS_SIGACTION) if (::signal(reg->signal_number_, SIG_DFL) == SIG_ERR) # endif // defined(BOOST_ASIO_HAS_SIGACTION) { # if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) ec = boost::asio::error::invalid_argument; # else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) ec = boost::system::error_code(errno, boost::asio::error::get_system_category()); # endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) return ec; } } #endif // defined(BOOST_ASIO_HAS_SIGNAL) \|\| defined(BOOST_ASIO_HAS_SIGACTION) // Remove the registration from the registration table. if (registrations_[reg->signal_number_] == reg) registrations_[reg->signal_number_] = reg->next_in_table_; if (reg->prev_in_table_) reg->prev_in_table_->next_in_table_ = reg->next_in_table_; if (reg->next_in_table_) reg->next_in_table_->prev_in_table_ = reg->prev_in_table_; --state->registration_count_[reg->signal_number_]; impl.signals_ = reg->next_in_set_; delete reg; } ec = boost::system::error_code(); return ec; } boost::system::error_code signal_set_service::cancel( signal_set_service::implementation_type& impl, boost::system::error_code& ec) { BOOST_ASIO_HANDLER_OPERATION((scheduler_.context(), "signal_set", &impl, 0, "cancel")); op_queue<operation> ops; { signal_state* state = get_signal_state(); static_mutex::scoped_lock lock(state->mutex_); while (signal_op* op = impl.queue_.front()) { op->ec_ = boost::asio::error::operation_aborted; impl.queue_.pop(); ops.push(op); } } scheduler_.post_deferred_completions(ops); ec = boost::system::error_code(); return ec; } void signal_set_service::deliver_signal(int signal_number) { signal_state* state = get_signal_state(); static_mutex::scoped_lock lock(state->mutex_); signal_set_service* service = state->service_list_; while (service) { op_queue<operation> ops; registration* reg = service->registrations_[signal_number]; while (reg) { if (reg->queue_->empty()) { ++reg->undelivered_; } else { while (signal_op* op = reg->queue_->front()) { op->signal_number_ = signal_number; reg->queue_->pop(); ops.push(op); } } reg = reg->next_in_table_; } service->scheduler_.post_deferred_completions(ops); service = service->next_; } } void signal_set_service::add_service(signal_set_service* service) { signal_state* state = get_signal_state(); static_mutex::scoped_lock lock(state->mutex_); #if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) // If this is the first service to be created, open a new pipe. if (state->service_list_ == 0) open_descriptors(); #endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) // If a scheduler_ object is thread-unsafe then it must be the only // scheduler used to create signal_set objects. if (state->service_list_ != 0) { if (!BOOST_ASIO_CONCURRENCY_HINT_IS_LOCKING(SCHEDULER, service->scheduler_.concurrency_hint()) \|\| !BOOST_ASIO_CONCURRENCY_HINT_IS_LOCKING(SCHEDULER, state->service_list_->scheduler_.concurrency_hint())) { std::logic_error ex( "Thread-unsafe execution context objects require " "exclusive access to signal handling."); boost::asio::detail::throw_exception(ex); } } // Insert service into linked list of all services. service->next_ = state->service_list_; service->prev_ = 0; if (state->service_list_) state->service_list_->prev_ = service; state->service_list_ = service; #if !defined(BOOST_ASIO_WINDOWS) \ && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ && !defined(__CYGWIN__) // Register for pipe readiness notifications. int read_descriptor = state->read_descriptor_; lock.unlock(); service->reactor_.register_internal_descriptor(reactor::read_op, read_descriptor, service->reactor_data_, new pipe_read_op); #endif // !defined(BOOST_ASIO_WINDOWS) // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) // && !defined(__CYGWIN__) } void signal_set_service::remove_service(signal_set_service* service) { signal_state* state = get_signal_state(); static_mutex::scoped_lock lock(state->mutex_); if (service->next_ \|\| service->prev_ \|\| state->service_list_ == service) { #if !defined(BOOST_ASIO_WINDOWS) \ && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ && !defined(__CYGWIN__) // Disable the pipe readiness notifications. int read_descriptor = state->read_descriptor_; lock.unlock(); service->reactor_.deregister_internal_descriptor( read_descriptor, service->reactor_data_); service->reactor_.cleanup_descriptor_data(service->reactor_data_); lock.lock(); #endif // !defined(BOOST_ASIO_WINDOWS) // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) // && !defined(__CYGWIN__) // Remove service from linked list of all services. if (state->service_list_ == service) state->service_list_ = service->next_; if (service->prev_) service->prev_->next_ = service->next_; if (service->next_) service->next_->prev_= service->prev_; service->next_ = 0; service->prev_ = 0; #if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) // If this is the last service to be removed, close the pipe. if (state->service_list_ == 0) close_descriptors(); #endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) } } void signal_set_service::open_descriptors() { #if !defined(BOOST_ASIO_WINDOWS) \ && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ && !defined(__CYGWIN__) signal_state* state = get_signal_state(); int pipe_fds[2]; if (::pipe(pipe_fds) == 0) { state->read_descriptor_ = pipe_fds[0]; ::fcntl(state->read_descriptor_, F_SETFL, O_NONBLOCK); state->write_descriptor_ = pipe_fds[1]; ::fcntl(state->write_descriptor_, F_SETFL, O_NONBLOCK); #if defined(FD_CLOEXEC) ::fcntl(state->read_descriptor_, F_SETFD, FD_CLOEXEC); ::fcntl(state->write_descriptor_, F_SETFD, FD_CLOEXEC); #endif // defined(FD_CLOEXEC) } else { boost::system::error_code ec(errno, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "signal_set_service pipe"); } #endif // !defined(BOOST_ASIO_WINDOWS) // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) // && !defined(__CYGWIN__) } void signal_set_service::close_descriptors() { #if !defined(BOOST_ASIO_WINDOWS) \ && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ && !defined(__CYGWIN__) signal_state* state = get_signal_state(); if (state->read_descriptor_ != -1) ::close(state->read_descriptor_); state->read_descriptor_ = -1; if (state->write_descriptor_ != -1) ::close(state->write_descriptor_); state->write_descriptor_ = -1; #endif // !defined(BOOST_ASIO_WINDOWS) // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) // && !defined(__CYGWIN__) } void signal_set_service::start_wait_op( signal_set_service::implementation_type& impl, signal_op* op) { scheduler_.work_started(); signal_state* state = get_signal_state(); static_mutex::scoped_lock lock(state->mutex_); registration* reg = impl.signals_; while (reg) { if (reg->undelivered_ > 0) { --reg->undelivered_; op->signal_number_ = reg->signal_number_; scheduler_.post_deferred_completion(op); return; } reg = reg->next_in_set_; } impl.queue_.push(op); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_IMPL_SIGNAL_SET_SERVICE_IPP PK��h!\�Iqs.��.��impl/handler_tracking.ippnu��[��// // detail/impl/handler_tracking.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_HANDLER_TRACKING_IPP #define BOOST_ASIO_DETAIL_IMPL_HANDLER_TRACKING_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_CUSTOM_HANDLER_TRACKING) // The handler tracking implementation is provided by the user-specified header. #elif defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) #include <cstdarg> #include <cstdio> #include <boost/asio/detail/handler_tracking.hpp> #if defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) # include <boost/asio/time_traits.hpp> #elif defined(BOOST_ASIO_HAS_CHRONO) # include <boost/asio/detail/chrono.hpp> # include <boost/asio/detail/chrono_time_traits.hpp> # include <boost/asio/wait_traits.hpp> #endif // defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) #if defined(BOOST_ASIO_WINDOWS_RUNTIME) # include <boost/asio/detail/socket_types.hpp> #elif !defined(BOOST_ASIO_WINDOWS) # include <unistd.h> #endif // !defined(BOOST_ASIO_WINDOWS) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { struct handler_tracking_timestamp { uint64_t seconds; uint64_t microseconds; handler_tracking_timestamp() { #if defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1)); boost::posix_time::time_duration now = boost::posix_time::microsec_clock::universal_time() - epoch; #elif defined(BOOST_ASIO_HAS_CHRONO) typedef chrono_time_traits<chrono::system_clock, boost::asio::wait_traits<chrono::system_clock> > traits_helper; traits_helper::posix_time_duration now( chrono::system_clock::now().time_since_epoch()); #endif seconds = static_cast<uint64_t>(now.total_seconds()); microseconds = static_cast<uint64_t>(now.total_microseconds() % 1000000); } }; struct handler_tracking::tracking_state { static_mutex mutex_; uint64_t next_id_; tss_ptr<completion>* current_completion_; tss_ptr<location>* current_location_; }; handler_tracking::tracking_state* handler_tracking::get_state() { static tracking_state state = { BOOST_ASIO_STATIC_MUTEX_INIT, 1, 0, 0 }; return &state; } void handler_tracking::init() { static tracking_state* state = get_state(); state->mutex_.init(); static_mutex::scoped_lock lock(state->mutex_); if (state->current_completion_ == 0) state->current_completion_ = new tss_ptr<completion>; if (state->current_location_ == 0) state->current_location_ = new tss_ptr<location>; } handler_tracking::location::location( const char* file, int line, const char* func) : file_(file), line_(line), func_(func), next_(get_state()->current_location_) { if (file_) get_state()->current_location_ = this; } handler_tracking::location::~location() { if (file_) get_state()->current_location_ = next_; } void handler_tracking::creation(execution_context&, handler_tracking::tracked_handler& h, const char object_type, void* object, uintmax_t /native_handle/, const char* op_name) { static tracking_state* state = get_state(); static_mutex::scoped_lock lock(state->mutex_); h.id_ = state->next_id_++; lock.unlock(); handler_tracking_timestamp timestamp; uint64_t current_id = 0; if (completion* current_completion = state->current_completion_) current_id = current_completion->id_; for (location current_location = state->current_location_; current_location; current_location = current_location->next_) { write_line( #if defined(BOOST_ASIO_WINDOWS) "@asio\|%I64u.%06I64u\|%I64u^%I64u\|%s%s%.80s%s(%.80s:%d)\n", #else // defined(BOOST_ASIO_WINDOWS) "@asio\|%llu.%06llu\|%llu^%llu\|%s%s%.80s%s(%.80s:%d)\n", #endif // defined(BOOST_ASIO_WINDOWS) timestamp.seconds, timestamp.microseconds, current_id, h.id_, current_location == state->current_location_ ? "in " : "called from ", current_location->func_ ? "'" : "", current_location->func_ ? current_location->func_ : "", current_location->func_ ? "' " : "", current_location->file_, current_location->line_); } write_line( #if defined(BOOST_ASIO_WINDOWS) "@asio\|%I64u.%06I64u\|%I64u%I64u\|%.20s@%p.%.50s\n", #else // defined(BOOST_ASIO_WINDOWS) "@asio\|%llu.%06llu\|%llu%llu\|%.20s@%p.%.50s\n", #endif // defined(BOOST_ASIO_WINDOWS) timestamp.seconds, timestamp.microseconds, current_id, h.id_, object_type, object, op_name); } handler_tracking::completion::completion( const handler_tracking::tracked_handler& h) : id_(h.id_), invoked_(false), next_(get_state()->current_completion_) { get_state()->current_completion_ = this; } handler_tracking::completion::~completion() { if (id_) { handler_tracking_timestamp timestamp; write_line( #if defined(BOOST_ASIO_WINDOWS) "@asio\|%I64u.%06I64u\|%c%I64u\|\n", #else // defined(BOOST_ASIO_WINDOWS) "@asio\|%llu.%06llu\|%c%llu\|\n", #endif // defined(BOOST_ASIO_WINDOWS) timestamp.seconds, timestamp.microseconds, invoked_ ? '!' : '~', id_); } get_state()->current_completion_ = next_; } void handler_tracking::completion::invocation_begin() { handler_tracking_timestamp timestamp; write_line( #if defined(BOOST_ASIO_WINDOWS) "@asio\|%I64u.%06I64u\|>%I64u\|\n", #else // defined(BOOST_ASIO_WINDOWS) "@asio\|%llu.%06llu\|>%llu\|\n", #endif // defined(BOOST_ASIO_WINDOWS) timestamp.seconds, timestamp.microseconds, id_); invoked_ = true; } void handler_tracking::completion::invocation_begin( const boost::system::error_code& ec) { handler_tracking_timestamp timestamp; write_line( #if defined(BOOST_ASIO_WINDOWS) "@asio\|%I64u.%06I64u\|>%I64u\|ec=%.20s:%d\n", #else // defined(BOOST_ASIO_WINDOWS) "@asio\|%llu.%06llu\|>%llu\|ec=%.20s:%d\n", #endif // defined(BOOST_ASIO_WINDOWS) timestamp.seconds, timestamp.microseconds, id_, ec.category().name(), ec.value()); invoked_ = true; } void handler_tracking::completion::invocation_begin( const boost::system::error_code& ec, std::size_t bytes_transferred) { handler_tracking_timestamp timestamp; write_line( #if defined(BOOST_ASIO_WINDOWS) "@asio\|%I64u.%06I64u\|>%I64u\|ec=%.20s:%d,bytes_transferred=%I64u\n", #else // defined(BOOST_ASIO_WINDOWS) "@asio\|%llu.%06llu\|>%llu\|ec=%.20s:%d,bytes_transferred=%llu\n", #endif // defined(BOOST_ASIO_WINDOWS) timestamp.seconds, timestamp.microseconds, id_, ec.category().name(), ec.value(), static_cast<uint64_t>(bytes_transferred)); invoked_ = true; } void handler_tracking::completion::invocation_begin( const boost::system::error_code& ec, int signal_number) { handler_tracking_timestamp timestamp; write_line( #if defined(BOOST_ASIO_WINDOWS) "@asio\|%I64u.%06I64u\|>%I64u\|ec=%.20s:%d,signal_number=%d\n", #else // defined(BOOST_ASIO_WINDOWS) "@asio\|%llu.%06llu\|>%llu\|ec=%.20s:%d,signal_number=%d\n", #endif // defined(BOOST_ASIO_WINDOWS) timestamp.seconds, timestamp.microseconds, id_, ec.category().name(), ec.value(), signal_number); invoked_ = true; } void handler_tracking::completion::invocation_begin( const boost::system::error_code& ec, const char arg) { handler_tracking_timestamp timestamp; write_line( #if defined(BOOST_ASIO_WINDOWS) "@asio\|%I64u.%06I64u\|>%I64u\|ec=%.20s:%d,%.50s\n", #else // defined(BOOST_ASIO_WINDOWS) "@asio\|%llu.%06llu\|>%llu\|ec=%.20s:%d,%.50s\n", #endif // defined(BOOST_ASIO_WINDOWS) timestamp.seconds, timestamp.microseconds, id_, ec.category().name(), ec.value(), arg); invoked_ = true; } void handler_tracking::completion::invocation_end() { if (id_) { handler_tracking_timestamp timestamp; write_line( #if defined(BOOST_ASIO_WINDOWS) "@asio\|%I64u.%06I64u\|<%I64u\|\n", #else // defined(BOOST_ASIO_WINDOWS) "@asio\|%llu.%06llu\|<%llu\|\n", #endif // defined(BOOST_ASIO_WINDOWS) timestamp.seconds, timestamp.microseconds, id_); id_ = 0; } } void handler_tracking::operation(execution_context&, const char* object_type, void* object, uintmax_t /native_handle/, const char* op_name) { static tracking_state* state = get_state(); handler_tracking_timestamp timestamp; unsigned long long current_id = 0; if (completion* current_completion = state->current_completion_) current_id = current_completion->id_; write_line( #if defined(BOOST_ASIO_WINDOWS) "@asio\|%I64u.%06I64u\|%I64u\|%.20s@%p.%.50s\n", #else // defined(BOOST_ASIO_WINDOWS) "@asio\|%llu.%06llu\|%llu\|%.20s@%p.%.50s\n", #endif // defined(BOOST_ASIO_WINDOWS) timestamp.seconds, timestamp.microseconds, current_id, object_type, object, op_name); } void handler_tracking::reactor_registration(execution_context& /context/, uintmax_t /native_handle/, uintmax_t /registration/) { } void handler_tracking::reactor_deregistration(execution_context& /context/, uintmax_t /native_handle/, uintmax_t /registration/) { } void handler_tracking::reactor_events(execution_context& /context/, uintmax_t /native_handle/, unsigned /events/) { } void handler_tracking::reactor_operation( const tracked_handler& h, const char op_name, const boost::system::error_code& ec) { handler_tracking_timestamp timestamp; write_line( #if defined(BOOST_ASIO_WINDOWS) "@asio\|%I64u.%06I64u\|.%I64u\|%s,ec=%.20s:%d\n", #else // defined(BOOST_ASIO_WINDOWS) "@asio\|%llu.%06llu\|.%llu\|%s,ec=%.20s:%d\n", #endif // defined(BOOST_ASIO_WINDOWS) timestamp.seconds, timestamp.microseconds, h.id_, op_name, ec.category().name(), ec.value()); } void handler_tracking::reactor_operation( const tracked_handler& h, const char* op_name, const boost::system::error_code& ec, std::size_t bytes_transferred) { handler_tracking_timestamp timestamp; write_line( #if defined(BOOST_ASIO_WINDOWS) "@asio\|%I64u.%06I64u\|.%I64u\|%s,ec=%.20s:%d,bytes_transferred=%I64u\n", #else // defined(BOOST_ASIO_WINDOWS) "@asio\|%llu.%06llu\|.%llu\|%s,ec=%.20s:%d,bytes_transferred=%llu\n", #endif // defined(BOOST_ASIO_WINDOWS) timestamp.seconds, timestamp.microseconds, h.id_, op_name, ec.category().name(), ec.value(), static_cast<uint64_t>(bytes_transferred)); } void handler_tracking::write_line(const char* format, ...) { using namespace std; // For sprintf (or equivalent). va_list args; va_start(args, format); char line[256] = ""; #if defined(BOOST_ASIO_HAS_SECURE_RTL) int length = vsprintf_s(line, sizeof(line), format, args); #else // defined(BOOST_ASIO_HAS_SECURE_RTL) int length = vsprintf(line, format, args); #endif // defined(BOOST_ASIO_HAS_SECURE_RTL) va_end(args); #if defined(BOOST_ASIO_WINDOWS_RUNTIME) wchar_t wline[256] = L""; mbstowcs_s(0, wline, sizeof(wline) / sizeof(wchar_t), line, length); ::OutputDebugStringW(wline); #elif defined(BOOST_ASIO_WINDOWS) HANDLE stderr_handle = ::GetStdHandle(STD_ERROR_HANDLE); DWORD bytes_written = 0; ::WriteFile(stderr_handle, line, length, &bytes_written, 0); #else // defined(BOOST_ASIO_WINDOWS) ::write(STDERR_FILENO, line, length); #endif // defined(BOOST_ASIO_WINDOWS) } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) #endif // BOOST_ASIO_DETAIL_IMPL_HANDLER_TRACKING_IPP PK��h!\HJ� �� impl/strand_service.hppnu��[��// // detail/impl/strand_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_STRAND_SERVICE_HPP #define BOOST_ASIO_DETAIL_IMPL_STRAND_SERVICE_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/call_stack.hpp> #include <boost/asio/detail/completion_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { inline strand_service::strand_impl::strand_impl() : operation(&strand_service::do_complete), locked_(false) { } struct strand_service::on_dispatch_exit { io_context_impl* io_context_impl_; strand_impl* impl_; ~on_dispatch_exit() { impl_->mutex_.lock(); impl_->ready_queue_.push(impl_->waiting_queue_); bool more_handlers = impl_->locked_ = !impl_->ready_queue_.empty(); impl_->mutex_.unlock(); if (more_handlers) io_context_impl_->post_immediate_completion(impl_, false); } }; template <typename Handler> void strand_service::dispatch(strand_service::implementation_type& impl, Handler& handler) { // If we are already in the strand then the handler can run immediately. if (call_stack<strand_impl>::contains(impl)) { fenced_block b(fenced_block::full); boost_asio_handler_invoke_helpers::invoke(handler, handler); return; } // Allocate and construct an operation to wrap the handler. typedef completion_handler<Handler, io_context::executor_type> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(handler, io_context_.get_executor()); BOOST_ASIO_HANDLER_CREATION((this->context(), p.p, "strand", impl, 0, "dispatch")); bool dispatch_immediately = do_dispatch(impl, p.p); operation o = p.p; p.v = p.p = 0; if (dispatch_immediately) { // Indicate that this strand is executing on the current thread. call_stack<strand_impl>::context ctx(impl); // Ensure the next handler, if any, is scheduled on block exit. on_dispatch_exit on_exit = { &io_context_impl_, impl }; (void)on_exit; op::do_complete(&io_context_impl_, o, boost::system::error_code(), 0); } } // Request the io_context to invoke the given handler and return immediately. template <typename Handler> void strand_service::post(strand_service::implementation_type& impl, Handler& handler) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef completion_handler<Handler, io_context::executor_type> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(handler, io_context_.get_executor()); BOOST_ASIO_HANDLER_CREATION((this->context(), p.p, "strand", impl, 0, "post")); do_post(impl, p.p, is_continuation); p.v = p.p = 0; } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_IMPL_STRAND_SERVICE_HPP PK��h!\b�iD��iD��#��impl/winrt_ssocket_service_base.ippnu��[��// // detail/impl/winrt_ssocket_service_base.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_WINRT_SSOCKET_SERVICE_BASE_IPP #define BOOST_ASIO_DETAIL_IMPL_WINRT_SSOCKET_SERVICE_BASE_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_WINDOWS_RUNTIME) #include <cstring> #include <boost/asio/detail/winrt_ssocket_service_base.hpp> #include <boost/asio/detail/winrt_async_op.hpp> #include <boost/asio/detail/winrt_utils.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { winrt_ssocket_service_base::winrt_ssocket_service_base( execution_context& context) : scheduler_(use_service<scheduler_impl>(context)), async_manager_(use_service<winrt_async_manager>(context)), mutex_(), impl_list_(0) { } void winrt_ssocket_service_base::base_shutdown() { // Close all implementations, causing all operations to complete. boost::asio::detail::mutex::scoped_lock lock(mutex_); base_implementation_type impl = impl_list_; while (impl) { boost::system::error_code ignored_ec; close(impl, ignored_ec); impl = impl->next_; } } void winrt_ssocket_service_base::construct( winrt_ssocket_service_base::base_implementation_type& impl) { // Insert implementation into linked list of all implementations. boost::asio::detail::mutex::scoped_lock lock(mutex_); impl.next_ = impl_list_; impl.prev_ = 0; if (impl_list_) impl_list_->prev_ = &impl; impl_list_ = &impl; } void winrt_ssocket_service_base::base_move_construct( winrt_ssocket_service_base::base_implementation_type& impl, winrt_ssocket_service_base::base_implementation_type& other_impl) BOOST_ASIO_NOEXCEPT { impl.socket_ = other_impl.socket_; other_impl.socket_ = nullptr; // Insert implementation into linked list of all implementations. boost::asio::detail::mutex::scoped_lock lock(mutex_); impl.next_ = impl_list_; impl.prev_ = 0; if (impl_list_) impl_list_->prev_ = &impl; impl_list_ = &impl; } void winrt_ssocket_service_base::base_move_assign( winrt_ssocket_service_base::base_implementation_type& impl, winrt_ssocket_service_base& other_service, winrt_ssocket_service_base::base_implementation_type& other_impl) { boost::system::error_code ignored_ec; close(impl, ignored_ec); if (this != &other_service) { // Remove implementation from linked list of all implementations. boost::asio::detail::mutex::scoped_lock lock(mutex_); if (impl_list_ == &impl) impl_list_ = impl.next_; if (impl.prev_) impl.prev_->next_ = impl.next_; if (impl.next_) impl.next_->prev_= impl.prev_; impl.next_ = 0; impl.prev_ = 0; } impl.socket_ = other_impl.socket_; other_impl.socket_ = nullptr; if (this != &other_service) { // Insert implementation into linked list of all implementations. boost::asio::detail::mutex::scoped_lock lock(other_service.mutex_); impl.next_ = other_service.impl_list_; impl.prev_ = 0; if (other_service.impl_list_) other_service.impl_list_->prev_ = &impl; other_service.impl_list_ = &impl; } } void winrt_ssocket_service_base::destroy( winrt_ssocket_service_base::base_implementation_type& impl) { boost::system::error_code ignored_ec; close(impl, ignored_ec); // Remove implementation from linked list of all implementations. boost::asio::detail::mutex::scoped_lock lock(mutex_); if (impl_list_ == &impl) impl_list_ = impl.next_; if (impl.prev_) impl.prev_->next_ = impl.next_; if (impl.next_) impl.next_->prev_= impl.prev_; impl.next_ = 0; impl.prev_ = 0; } boost::system::error_code winrt_ssocket_service_base::close( winrt_ssocket_service_base::base_implementation_type& impl, boost::system::error_code& ec) { delete impl.socket_; impl.socket_ = nullptr; ec = boost::system::error_code(); return ec; } winrt_ssocket_service_base::native_handle_type winrt_ssocket_service_base::release( winrt_ssocket_service_base::base_implementation_type& impl, boost::system::error_code& ec) { if (!is_open(impl)) return nullptr; cancel(impl, ec); if (ec) return nullptr; native_handle_type tmp = impl.socket_; impl.socket_ = nullptr; return tmp; } std::size_t winrt_ssocket_service_base::do_get_endpoint( const base_implementation_type& impl, bool local, void addr, std::size_t addr_len, boost::system::error_code& ec) const { if (!is_open(impl)) { ec = boost::asio::error::bad_descriptor; return addr_len; } try { std::string addr_string = winrt_utils::string(local ? impl.socket_->Information->LocalAddress->CanonicalName : impl.socket_->Information->RemoteAddress->CanonicalName); unsigned short port = winrt_utils::integer(local ? impl.socket_->Information->LocalPort : impl.socket_->Information->RemotePort); unsigned long scope = 0; switch (reinterpret_cast<const socket_addr_type>(addr)->sa_family) { case BOOST_ASIO_OS_DEF(AF_INET): if (addr_len < sizeof(sockaddr_in4_type)) { ec = boost::asio::error::invalid_argument; return addr_len; } else { socket_ops::inet_pton(BOOST_ASIO_OS_DEF(AF_INET), addr_string.c_str(), &reinterpret_cast<sockaddr_in4_type>(addr)->sin_addr, &scope, ec); reinterpret_cast<sockaddr_in4_type>(addr)->sin_port = socket_ops::host_to_network_short(port); ec = boost::system::error_code(); return sizeof(sockaddr_in4_type); } case BOOST_ASIO_OS_DEF(AF_INET6): if (addr_len < sizeof(sockaddr_in6_type)) { ec = boost::asio::error::invalid_argument; return addr_len; } else { socket_ops::inet_pton(BOOST_ASIO_OS_DEF(AF_INET6), addr_string.c_str(), &reinterpret_cast<sockaddr_in6_type>(addr)->sin6_addr, &scope, ec); reinterpret_cast<sockaddr_in6_type>(addr)->sin6_port = socket_ops::host_to_network_short(port); ec = boost::system::error_code(); return sizeof(sockaddr_in6_type); } default: ec = boost::asio::error::address_family_not_supported; return addr_len; } } catch (Platform::Exception^ e) { ec = boost::system::error_code(e->HResult, boost::system::system_category()); return addr_len; } } boost::system::error_code winrt_ssocket_service_base::do_set_option( winrt_ssocket_service_base::base_implementation_type& impl, int level, int optname, const void optval, std::size_t optlen, boost::system::error_code& ec) { if (!is_open(impl)) { ec = boost::asio::error::bad_descriptor; return ec; } try { if (level == BOOST_ASIO_OS_DEF(SOL_SOCKET) && optname == BOOST_ASIO_OS_DEF(SO_KEEPALIVE)) { if (optlen == sizeof(int)) { int value = 0; std::memcpy(&value, optval, optlen); impl.socket_->Control->KeepAlive = !!value; ec = boost::system::error_code(); } else { ec = boost::asio::error::invalid_argument; } } else if (level == BOOST_ASIO_OS_DEF(IPPROTO_TCP) && optname == BOOST_ASIO_OS_DEF(TCP_NODELAY)) { if (optlen == sizeof(int)) { int value = 0; std::memcpy(&value, optval, optlen); impl.socket_->Control->NoDelay = !!value; ec = boost::system::error_code(); } else { ec = boost::asio::error::invalid_argument; } } else { ec = boost::asio::error::invalid_argument; } } catch (Platform::Exception^ e) { ec = boost::system::error_code(e->HResult, boost::system::system_category()); } return ec; } void winrt_ssocket_service_base::do_get_option( const winrt_ssocket_service_base::base_implementation_type& impl, int level, int optname, void* optval, std::size_t* optlen, boost::system::error_code& ec) const { if (!is_open(impl)) { ec = boost::asio::error::bad_descriptor; return; } try { if (level == BOOST_ASIO_OS_DEF(SOL_SOCKET) && optname == BOOST_ASIO_OS_DEF(SO_KEEPALIVE)) { if (optlen >= sizeof(int)) { int value = impl.socket_->Control->KeepAlive ? 1 : 0; std::memcpy(optval, &value, sizeof(int)); optlen = sizeof(int); ec = boost::system::error_code(); } else { ec = boost::asio::error::invalid_argument; } } else if (level == BOOST_ASIO_OS_DEF(IPPROTO_TCP) && optname == BOOST_ASIO_OS_DEF(TCP_NODELAY)) { if (optlen >= sizeof(int)) { int value = impl.socket_->Control->NoDelay ? 1 : 0; std::memcpy(optval, &value, sizeof(int)); optlen = sizeof(int); ec = boost::system::error_code(); } else { ec = boost::asio::error::invalid_argument; } } else { ec = boost::asio::error::invalid_argument; } } catch (Platform::Exception^ e) { ec = boost::system::error_code(e->HResult, boost::system::system_category()); } } boost::system::error_code winrt_ssocket_service_base::do_connect( winrt_ssocket_service_base::base_implementation_type& impl, const void* addr, boost::system::error_code& ec) { if (!is_open(impl)) { ec = boost::asio::error::bad_descriptor; return ec; } char addr_string[max_addr_v6_str_len]; unsigned short port; switch (reinterpret_cast<const socket_addr_type>(addr)->sa_family) { case BOOST_ASIO_OS_DEF(AF_INET): socket_ops::inet_ntop(BOOST_ASIO_OS_DEF(AF_INET), &reinterpret_cast<const sockaddr_in4_type>(addr)->sin_addr, addr_string, sizeof(addr_string), 0, ec); port = socket_ops::network_to_host_short( reinterpret_cast<const sockaddr_in4_type>(addr)->sin_port); break; case BOOST_ASIO_OS_DEF(AF_INET6): socket_ops::inet_ntop(BOOST_ASIO_OS_DEF(AF_INET6), &reinterpret_cast<const sockaddr_in6_type>(addr)->sin6_addr, addr_string, sizeof(addr_string), 0, ec); port = socket_ops::network_to_host_short( reinterpret_cast<const sockaddr_in6_type>(addr)->sin6_port); break; default: ec = boost::asio::error::address_family_not_supported; return ec; } if (!ec) try { async_manager_.sync(impl.socket_->ConnectAsync( ref new Windows::Networking::HostName( winrt_utils::string(addr_string)), winrt_utils::string(port)), ec); } catch (Platform::Exception^ e) { ec = boost::system::error_code(e->HResult, boost::system::system_category()); } return ec; } void winrt_ssocket_service_base::start_connect_op( winrt_ssocket_service_base::base_implementation_type& impl, const void addr, winrt_async_op<void>* op, bool is_continuation) { if (!is_open(impl)) { op->ec_ = boost::asio::error::bad_descriptor; scheduler_.post_immediate_completion(op, is_continuation); return; } char addr_string[max_addr_v6_str_len]; unsigned short port = 0; switch (reinterpret_cast<const socket_addr_type>(addr)->sa_family) { case BOOST_ASIO_OS_DEF(AF_INET): socket_ops::inet_ntop(BOOST_ASIO_OS_DEF(AF_INET), &reinterpret_cast<const sockaddr_in4_type>(addr)->sin_addr, addr_string, sizeof(addr_string), 0, op->ec_); port = socket_ops::network_to_host_short( reinterpret_cast<const sockaddr_in4_type>(addr)->sin_port); break; case BOOST_ASIO_OS_DEF(AF_INET6): socket_ops::inet_ntop(BOOST_ASIO_OS_DEF(AF_INET6), &reinterpret_cast<const sockaddr_in6_type>(addr)->sin6_addr, addr_string, sizeof(addr_string), 0, op->ec_); port = socket_ops::network_to_host_short( reinterpret_cast<const sockaddr_in6_type>(addr)->sin6_port); break; default: op->ec_ = boost::asio::error::address_family_not_supported; break; } if (op->ec_) { scheduler_.post_immediate_completion(op, is_continuation); return; } try { async_manager_.async(impl.socket_->ConnectAsync( ref new Windows::Networking::HostName( winrt_utils::string(addr_string)), winrt_utils::string(port)), op); } catch (Platform::Exception^ e) { op->ec_ = boost::system::error_code( e->HResult, boost::system::system_category()); scheduler_.post_immediate_completion(op, is_continuation); } } std::size_t winrt_ssocket_service_base::do_send( winrt_ssocket_service_base::base_implementation_type& impl, const boost::asio::const_buffer& data, socket_base::message_flags flags, boost::system::error_code& ec) { if (flags) { ec = boost::asio::error::operation_not_supported; return 0; } if (!is_open(impl)) { ec = boost::asio::error::bad_descriptor; return 0; } try { buffer_sequence_adapter<boost::asio::const_buffer, boost::asio::const_buffer> bufs(boost::asio::buffer(data)); if (bufs.all_empty()) { ec = boost::system::error_code(); return 0; } return async_manager_.sync( impl.socket_->OutputStream->WriteAsync(bufs.buffers()[0]), ec); } catch (Platform::Exception^ e) { ec = boost::system::error_code(e->HResult, boost::system::system_category()); return 0; } } void winrt_ssocket_service_base::start_send_op( winrt_ssocket_service_base::base_implementation_type& impl, const boost::asio::const_buffer& data, socket_base::message_flags flags, winrt_async_op<unsigned int> op, bool is_continuation) { if (flags) { op->ec_ = boost::asio::error::operation_not_supported; scheduler_.post_immediate_completion(op, is_continuation); return; } if (!is_open(impl)) { op->ec_ = boost::asio::error::bad_descriptor; scheduler_.post_immediate_completion(op, is_continuation); return; } try { buffer_sequence_adapter<boost::asio::const_buffer, boost::asio::const_buffer> bufs(boost::asio::buffer(data)); if (bufs.all_empty()) { scheduler_.post_immediate_completion(op, is_continuation); return; } async_manager_.async( impl.socket_->OutputStream->WriteAsync(bufs.buffers()[0]), op); } catch (Platform::Exception^ e) { op->ec_ = boost::system::error_code(e->HResult, boost::system::system_category()); scheduler_.post_immediate_completion(op, is_continuation); } } std::size_t winrt_ssocket_service_base::do_receive( winrt_ssocket_service_base::base_implementation_type& impl, const boost::asio::mutable_buffer& data, socket_base::message_flags flags, boost::system::error_code& ec) { if (flags) { ec = boost::asio::error::operation_not_supported; return 0; } if (!is_open(impl)) { ec = boost::asio::error::bad_descriptor; return 0; } try { buffer_sequence_adapter<boost::asio::mutable_buffer, boost::asio::mutable_buffer> bufs(boost::asio::buffer(data)); if (bufs.all_empty()) { ec = boost::system::error_code(); return 0; } async_manager_.sync( impl.socket_->InputStream->ReadAsync( bufs.buffers()[0], bufs.buffers()[0]->Capacity, Windows::Storage::Streams::InputStreamOptions::Partial), ec); std::size_t bytes_transferred = bufs.buffers()[0]->Length; if (bytes_transferred == 0 && !ec) { ec = boost::asio::error::eof; } return bytes_transferred; } catch (Platform::Exception^ e) { ec = boost::system::error_code(e->HResult, boost::system::system_category()); return 0; } } void winrt_ssocket_service_base::start_receive_op( winrt_ssocket_service_base::base_implementation_type& impl, const boost::asio::mutable_buffer& data, socket_base::message_flags flags, winrt_async_op<Windows::Storage::Streams::IBuffer^>* op, bool is_continuation) { if (flags) { op->ec_ = boost::asio::error::operation_not_supported; scheduler_.post_immediate_completion(op, is_continuation); return; } if (!is_open(impl)) { op->ec_ = boost::asio::error::bad_descriptor; scheduler_.post_immediate_completion(op, is_continuation); return; } try { buffer_sequence_adapter<boost::asio::mutable_buffer, boost::asio::mutable_buffer> bufs(boost::asio::buffer(data)); if (bufs.all_empty()) { scheduler_.post_immediate_completion(op, is_continuation); return; } async_manager_.async( impl.socket_->InputStream->ReadAsync( bufs.buffers()[0], bufs.buffers()[0]->Capacity, Windows::Storage::Streams::InputStreamOptions::Partial), op); } catch (Platform::Exception^ e) { op->ec_ = boost::system::error_code(e->HResult, boost::system::system_category()); scheduler_.post_immediate_completion(op, is_continuation); } } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_IMPL_WINRT_SSOCKET_SERVICE_BASE_IPP PK��h!\��"��impl/socket_select_interrupter.ippnu��[��// // detail/impl/socket_select_interrupter.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_SOCKET_SELECT_INTERRUPTER_IPP #define BOOST_ASIO_DETAIL_IMPL_SOCKET_SELECT_INTERRUPTER_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_WINDOWS_RUNTIME) #if defined(BOOST_ASIO_WINDOWS) \ \|\| defined(__CYGWIN__) \ \|\| defined(__SYMBIAN32__) #include <cstdlib> #include <boost/asio/detail/socket_holder.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/detail/socket_select_interrupter.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { socket_select_interrupter::socket_select_interrupter() { open_descriptors(); } void socket_select_interrupter::open_descriptors() { boost::system::error_code ec; socket_holder acceptor(socket_ops::socket( AF_INET, SOCK_STREAM, IPPROTO_TCP, ec)); if (acceptor.get() == invalid_socket) boost::asio::detail::throw_error(ec, "socket_select_interrupter"); int opt = 1; socket_ops::state_type acceptor_state = 0; socket_ops::setsockopt(acceptor.get(), acceptor_state, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt), ec); using namespace std; // For memset. sockaddr_in4_type addr; std::size_t addr_len = sizeof(addr); memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_addr.s_addr = socket_ops::host_to_network_long(INADDR_LOOPBACK); addr.sin_port = 0; if (socket_ops::bind(acceptor.get(), (const socket_addr_type)&addr, addr_len, ec) == socket_error_retval) boost::asio::detail::throw_error(ec, "socket_select_interrupter"); if (socket_ops::getsockname(acceptor.get(), (socket_addr_type)&addr, &addr_len, ec) == socket_error_retval) boost::asio::detail::throw_error(ec, "socket_select_interrupter"); // Some broken firewalls on Windows will intermittently cause getsockname to // return 0.0.0.0 when the socket is actually bound to 127.0.0.1. We // explicitly specify the target address here to work around this problem. if (addr.sin_addr.s_addr == socket_ops::host_to_network_long(INADDR_ANY)) addr.sin_addr.s_addr = socket_ops::host_to_network_long(INADDR_LOOPBACK); if (socket_ops::listen(acceptor.get(), SOMAXCONN, ec) == socket_error_retval) boost::asio::detail::throw_error(ec, "socket_select_interrupter"); socket_holder client(socket_ops::socket( AF_INET, SOCK_STREAM, IPPROTO_TCP, ec)); if (client.get() == invalid_socket) boost::asio::detail::throw_error(ec, "socket_select_interrupter"); if (socket_ops::connect(client.get(), (const socket_addr_type)&addr, addr_len, ec) == socket_error_retval) boost::asio::detail::throw_error(ec, "socket_select_interrupter"); socket_holder server(socket_ops::accept(acceptor.get(), 0, 0, ec)); if (server.get() == invalid_socket) boost::asio::detail::throw_error(ec, "socket_select_interrupter"); ioctl_arg_type non_blocking = 1; socket_ops::state_type client_state = 0; if (socket_ops::ioctl(client.get(), client_state, FIONBIO, &non_blocking, ec)) boost::asio::detail::throw_error(ec, "socket_select_interrupter"); opt = 1; socket_ops::setsockopt(client.get(), client_state, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt), ec); non_blocking = 1; socket_ops::state_type server_state = 0; if (socket_ops::ioctl(server.get(), server_state, FIONBIO, &non_blocking, ec)) boost::asio::detail::throw_error(ec, "socket_select_interrupter"); opt = 1; socket_ops::setsockopt(server.get(), server_state, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt), ec); read_descriptor_ = server.release(); write_descriptor_ = client.release(); } socket_select_interrupter::~socket_select_interrupter() { close_descriptors(); } void socket_select_interrupter::close_descriptors() { boost::system::error_code ec; socket_ops::state_type state = socket_ops::internal_non_blocking; if (read_descriptor_ != invalid_socket) socket_ops::close(read_descriptor_, state, true, ec); if (write_descriptor_ != invalid_socket) socket_ops::close(write_descriptor_, state, true, ec); } void socket_select_interrupter::recreate() { close_descriptors(); write_descriptor_ = invalid_socket; read_descriptor_ = invalid_socket; open_descriptors(); } void socket_select_interrupter::interrupt() { char byte = 0; socket_ops::buf b; socket_ops::init_buf(b, &byte, 1); boost::system::error_code ec; socket_ops::send(write_descriptor_, &b, 1, 0, ec); } bool socket_select_interrupter::reset() { char data[1024]; socket_ops::buf b; socket_ops::init_buf(b, data, sizeof(data)); boost::system::error_code ec; for (;;) { int bytes_read = socket_ops::recv(read_descriptor_, &b, 1, 0, ec); if (bytes_read == sizeof(data)) continue; if (bytes_read > 0) return true; if (bytes_read == 0) return false; if (ec == boost::asio::error::would_block \|\| ec == boost::asio::error::try_again) return true; return false; } } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS) // \|\| defined(__CYGWIN__) // \|\| defined(__SYMBIAN32__) #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_IMPL_SOCKET_SELECT_INTERRUPTER_IPP PK��h!\7u�:8��:8�� impl/win_iocp_handle_service.ippnu��[��// // detail/impl/win_iocp_handle_service.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.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_DETAIL_IMPL_WIN_IOCP_HANDLE_SERVICE_IPP #define BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_HANDLE_SERVICE_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_HAS_IOCP) #include <boost/asio/detail/win_iocp_handle_service.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class win_iocp_handle_service::overlapped_wrapper : public OVERLAPPED { public: explicit overlapped_wrapper(boost::system::error_code& ec) { Internal = 0; InternalHigh = 0; Offset = 0; OffsetHigh = 0; // Create a non-signalled manual-reset event, for GetOverlappedResult. hEvent = ::CreateEventW(0, TRUE, FALSE, 0); if (hEvent) { // As documented in GetQueuedCompletionStatus, setting the low order // bit of this event prevents our synchronous writes from being treated // as completion port events. DWORD_PTR tmp = reinterpret_cast<DWORD_PTR>(hEvent); hEvent = reinterpret_cast<HANDLE>(tmp \| 1); } else { DWORD last_error = ::GetLastError(); ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); } } ~overlapped_wrapper() { if (hEvent) { ::CloseHandle(hEvent); } } }; win_iocp_handle_service::win_iocp_handle_service(execution_context& context) : execution_context_service_base<win_iocp_handle_service>(context), iocp_service_(boost::asio::use_service<win_iocp_io_context>(context)), mutex_(), impl_list_(0) { } void win_iocp_handle_service::shutdown() { // Close all implementations, causing all operations to complete. boost::asio::detail::mutex::scoped_lock lock(mutex_); implementation_type impl = impl_list_; while (impl) { close_for_destruction(impl); impl = impl->next_; } } void win_iocp_handle_service::construct( win_iocp_handle_service::implementation_type& impl) { impl.handle_ = INVALID_HANDLE_VALUE; impl.safe_cancellation_thread_id_ = 0; // Insert implementation into linked list of all implementations. boost::asio::detail::mutex::scoped_lock lock(mutex_); impl.next_ = impl_list_; impl.prev_ = 0; if (impl_list_) impl_list_->prev_ = &impl; impl_list_ = &impl; } void win_iocp_handle_service::move_construct( win_iocp_handle_service::implementation_type& impl, win_iocp_handle_service::implementation_type& other_impl) { impl.handle_ = other_impl.handle_; other_impl.handle_ = INVALID_HANDLE_VALUE; impl.safe_cancellation_thread_id_ = other_impl.safe_cancellation_thread_id_; other_impl.safe_cancellation_thread_id_ = 0; // Insert implementation into linked list of all implementations. boost::asio::detail::mutex::scoped_lock lock(mutex_); impl.next_ = impl_list_; impl.prev_ = 0; if (impl_list_) impl_list_->prev_ = &impl; impl_list_ = &impl; } void win_iocp_handle_service::move_assign( win_iocp_handle_service::implementation_type& impl, win_iocp_handle_service& other_service, win_iocp_handle_service::implementation_type& other_impl) { close_for_destruction(impl); if (this != &other_service) { // Remove implementation from linked list of all implementations. boost::asio::detail::mutex::scoped_lock lock(mutex_); if (impl_list_ == &impl) impl_list_ = impl.next_; if (impl.prev_) impl.prev_->next_ = impl.next_; if (impl.next_) impl.next_->prev_= impl.prev_; impl.next_ = 0; impl.prev_ = 0; } impl.handle_ = other_impl.handle_; other_impl.handle_ = INVALID_HANDLE_VALUE; impl.safe_cancellation_thread_id_ = other_impl.safe_cancellation_thread_id_; other_impl.safe_cancellation_thread_id_ = 0; if (this != &other_service) { // Insert implementation into linked list of all implementations. boost::asio::detail::mutex::scoped_lock lock(other_service.mutex_); impl.next_ = other_service.impl_list_; impl.prev_ = 0; if (other_service.impl_list_) other_service.impl_list_->prev_ = &impl; other_service.impl_list_ = &impl; } } void win_iocp_handle_service::destroy( win_iocp_handle_service::implementation_type& impl) { close_for_destruction(impl); // Remove implementation from linked list of all implementations. boost::asio::detail::mutex::scoped_lock lock(mutex_); if (impl_list_ == &impl) impl_list_ = impl.next_; if (impl.prev_) impl.prev_->next_ = impl.next_; if (impl.next_) impl.next_->prev_= impl.prev_; impl.next_ = 0; impl.prev_ = 0; } boost::system::error_code win_iocp_handle_service::assign( win_iocp_handle_service::implementation_type& impl, const native_handle_type& handle, boost::system::error_code& ec) { if (is_open(impl)) { ec = boost::asio::error::already_open; return ec; } if (iocp_service_.register_handle(handle, ec)) return ec; impl.handle_ = handle; ec = boost::system::error_code(); return ec; } boost::system::error_code win_iocp_handle_service::close( win_iocp_handle_service::implementation_type& impl, boost::system::error_code& ec) { if (is_open(impl)) { BOOST_ASIO_HANDLER_OPERATION((iocp_service_.context(), "handle", &impl, reinterpret_cast<uintmax_t>(impl.handle_), "close")); if (!::CloseHandle(impl.handle_)) { DWORD last_error = ::GetLastError(); ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); } else { ec = boost::system::error_code(); } impl.handle_ = INVALID_HANDLE_VALUE; impl.safe_cancellation_thread_id_ = 0; } else { ec = boost::system::error_code(); } return ec; } boost::system::error_code win_iocp_handle_service::cancel( win_iocp_handle_service::implementation_type& impl, boost::system::error_code& ec) { if (!is_open(impl)) { ec = boost::asio::error::bad_descriptor; return ec; } BOOST_ASIO_HANDLER_OPERATION((iocp_service_.context(), "handle", &impl, reinterpret_cast<uintmax_t>(impl.handle_), "cancel")); if (FARPROC cancel_io_ex_ptr = ::GetProcAddress( ::GetModuleHandleA("KERNEL32"), "CancelIoEx")) { // The version of Windows supports cancellation from any thread. typedef BOOL (WINAPI cancel_io_ex_t)(HANDLE, LPOVERLAPPED); cancel_io_ex_t cancel_io_ex = reinterpret_cast<cancel_io_ex_t>( reinterpret_cast<void>(cancel_io_ex_ptr)); if (!cancel_io_ex(impl.handle_, 0)) { DWORD last_error = ::GetLastError(); if (last_error == ERROR_NOT_FOUND) { // ERROR_NOT_FOUND means that there were no operations to be // cancelled. We swallow this error to match the behaviour on other // platforms. ec = boost::system::error_code(); } else { ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); } } else { ec = boost::system::error_code(); } } else if (impl.safe_cancellation_thread_id_ == 0) { // No operations have been started, so there's nothing to cancel. ec = boost::system::error_code(); } else if (impl.safe_cancellation_thread_id_ == ::GetCurrentThreadId()) { // Asynchronous operations have been started from the current thread only, // so it is safe to try to cancel them using CancelIo. if (!::CancelIo(impl.handle_)) { DWORD last_error = ::GetLastError(); ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); } else { ec = boost::system::error_code(); } } else { // Asynchronous operations have been started from more than one thread, // so cancellation is not safe. ec = boost::asio::error::operation_not_supported; } return ec; } size_t win_iocp_handle_service::do_write( win_iocp_handle_service::implementation_type& impl, uint64_t offset, const boost::asio::const_buffer& buffer, boost::system::error_code& ec) { if (!is_open(impl)) { ec = boost::asio::error::bad_descriptor; return 0; } // A request to write 0 bytes on a handle is a no-op. if (buffer.size() == 0) { ec = boost::system::error_code(); return 0; } overlapped_wrapper overlapped(ec); if (ec) { return 0; } // Write the data. overlapped.Offset = offset & 0xFFFFFFFF; overlapped.OffsetHigh = (offset >> 32) & 0xFFFFFFFF; BOOL ok = ::WriteFile(impl.handle_, buffer.data(), static_cast<DWORD>(buffer.size()), 0, &overlapped); if (!ok) { DWORD last_error = ::GetLastError(); if (last_error != ERROR_IO_PENDING) { ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); return 0; } } // Wait for the operation to complete. DWORD bytes_transferred = 0; ok = ::GetOverlappedResult(impl.handle_, &overlapped, &bytes_transferred, TRUE); if (!ok) { DWORD last_error = ::GetLastError(); ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); return 0; } ec = boost::system::error_code(); return bytes_transferred; } void win_iocp_handle_service::start_write_op( win_iocp_handle_service::implementation_type& impl, uint64_t offset, const boost::asio::const_buffer& buffer, operation op) { update_cancellation_thread_id(impl); iocp_service_.work_started(); if (!is_open(impl)) { iocp_service_.on_completion(op, boost::asio::error::bad_descriptor); } else if (buffer.size() == 0) { // A request to write 0 bytes on a handle is a no-op. iocp_service_.on_completion(op); } else { DWORD bytes_transferred = 0; op->Offset = offset & 0xFFFFFFFF; op->OffsetHigh = (offset >> 32) & 0xFFFFFFFF; BOOL ok = ::WriteFile(impl.handle_, buffer.data(), static_cast<DWORD>(buffer.size()), &bytes_transferred, op); DWORD last_error = ::GetLastError(); if (!ok && last_error != ERROR_IO_PENDING && last_error != ERROR_MORE_DATA) { iocp_service_.on_completion(op, last_error, bytes_transferred); } else { iocp_service_.on_pending(op); } } } size_t win_iocp_handle_service::do_read( win_iocp_handle_service::implementation_type& impl, uint64_t offset, const boost::asio::mutable_buffer& buffer, boost::system::error_code& ec) { if (!is_open(impl)) { ec = boost::asio::error::bad_descriptor; return 0; } // A request to read 0 bytes on a stream handle is a no-op. if (buffer.size() == 0) { ec = boost::system::error_code(); return 0; } overlapped_wrapper overlapped(ec); if (ec) { return 0; } // Read some data. overlapped.Offset = offset & 0xFFFFFFFF; overlapped.OffsetHigh = (offset >> 32) & 0xFFFFFFFF; BOOL ok = ::ReadFile(impl.handle_, buffer.data(), static_cast<DWORD>(buffer.size()), 0, &overlapped); if (!ok) { DWORD last_error = ::GetLastError(); if (last_error != ERROR_IO_PENDING && last_error != ERROR_MORE_DATA) { if (last_error == ERROR_HANDLE_EOF) { ec = boost::asio::error::eof; } else { ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); } return 0; } } // Wait for the operation to complete. DWORD bytes_transferred = 0; ok = ::GetOverlappedResult(impl.handle_, &overlapped, &bytes_transferred, TRUE); if (!ok) { DWORD last_error = ::GetLastError(); if (last_error == ERROR_HANDLE_EOF) { ec = boost::asio::error::eof; } else { ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); } return (last_error == ERROR_MORE_DATA) ? bytes_transferred : 0; } ec = boost::system::error_code(); return bytes_transferred; } void win_iocp_handle_service::start_read_op( win_iocp_handle_service::implementation_type& impl, uint64_t offset, const boost::asio::mutable_buffer& buffer, operation* op) { update_cancellation_thread_id(impl); iocp_service_.work_started(); if (!is_open(impl)) { iocp_service_.on_completion(op, boost::asio::error::bad_descriptor); } else if (buffer.size() == 0) { // A request to read 0 bytes on a handle is a no-op. iocp_service_.on_completion(op); } else { DWORD bytes_transferred = 0; op->Offset = offset & 0xFFFFFFFF; op->OffsetHigh = (offset >> 32) & 0xFFFFFFFF; BOOL ok = ::ReadFile(impl.handle_, buffer.data(), static_cast<DWORD>(buffer.size()), &bytes_transferred, op); DWORD last_error = ::GetLastError(); if (!ok && last_error != ERROR_IO_PENDING && last_error != ERROR_MORE_DATA) { iocp_service_.on_completion(op, last_error, bytes_transferred); } else { iocp_service_.on_pending(op); } } } void win_iocp_handle_service::update_cancellation_thread_id( win_iocp_handle_service::implementation_type& impl) { if (impl.safe_cancellation_thread_id_ == 0) impl.safe_cancellation_thread_id_ = ::GetCurrentThreadId(); else if (impl.safe_cancellation_thread_id_ != ::GetCurrentThreadId()) impl.safe_cancellation_thread_id_ = ~DWORD(0); } void win_iocp_handle_service::close_for_destruction(implementation_type& impl) { if (is_open(impl)) { BOOST_ASIO_HANDLER_OPERATION((iocp_service_.context(), "handle", &impl, reinterpret_cast<uintmax_t>(impl.handle_), "close")); ::CloseHandle(impl.handle_); impl.handle_ = INVALID_HANDLE_VALUE; impl.safe_cancellation_thread_id_ = 0; } } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #endif // BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_HANDLE_SERVICE_IPP PK��h!\Θ.��B��B��impl/kqueue_reactor.ippnu��[��// // detail/impl/kqueue_reactor.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2005 Stefan Arentz (stefan at soze 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_DETAIL_IMPL_KQUEUE_REACTOR_IPP #define BOOST_ASIO_DETAIL_IMPL_KQUEUE_REACTOR_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_HAS_KQUEUE) #include <boost/asio/detail/kqueue_reactor.hpp> #include <boost/asio/detail/scheduler.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> #if defined(__NetBSD__) # include <sys/param.h> #endif #include <boost/asio/detail/push_options.hpp> #if defined(__NetBSD__) && __NetBSD_Version__ < 999001500 # define BOOST_ASIO_KQUEUE_EV_SET(ev, ident, filt, flags, fflags, data, udata) \ EV_SET(ev, ident, filt, flags, fflags, data, \ reinterpret_cast<intptr_t>(static_cast<void>(udata))) #else # define BOOST_ASIO_KQUEUE_EV_SET(ev, ident, filt, flags, fflags, data, udata) \ EV_SET(ev, ident, filt, flags, fflags, data, udata) #endif namespace boost { namespace asio { namespace detail { kqueue_reactor::kqueue_reactor(boost::asio::execution_context& ctx) : execution_context_service_base<kqueue_reactor>(ctx), scheduler_(use_service<scheduler>(ctx)), mutex_(BOOST_ASIO_CONCURRENCY_HINT_IS_LOCKING( REACTOR_REGISTRATION, scheduler_.concurrency_hint())), kqueue_fd_(do_kqueue_create()), interrupter_(), shutdown_(false), registered_descriptors_mutex_(mutex_.enabled()) { struct kevent events[1]; BOOST_ASIO_KQUEUE_EV_SET(&events[0], interrupter_.read_descriptor(), EVFILT_READ, EV_ADD, 0, 0, &interrupter_); if (::kevent(kqueue_fd_, events, 1, 0, 0, 0) == -1) { boost::system::error_code error(errno, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(error); } } kqueue_reactor::~kqueue_reactor() { close(kqueue_fd_); } void kqueue_reactor::shutdown() { mutex::scoped_lock lock(mutex_); shutdown_ = true; lock.unlock(); op_queue<operation> ops; while (descriptor_state state = registered_descriptors_.first()) { for (int i = 0; i < max_ops; ++i) ops.push(state->op_queue_[i]); state->shutdown_ = true; registered_descriptors_.free(state); } timer_queues_.get_all_timers(ops); scheduler_.abandon_operations(ops); } void kqueue_reactor::notify_fork( boost::asio::execution_context::fork_event fork_ev) { if (fork_ev == boost::asio::execution_context::fork_child) { // The kqueue descriptor is automatically closed in the child. kqueue_fd_ = -1; kqueue_fd_ = do_kqueue_create(); interrupter_.recreate(); struct kevent events[2]; BOOST_ASIO_KQUEUE_EV_SET(&events[0], interrupter_.read_descriptor(), EVFILT_READ, EV_ADD, 0, 0, &interrupter_); if (::kevent(kqueue_fd_, events, 1, 0, 0, 0) == -1) { boost::system::error_code ec(errno, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "kqueue interrupter registration"); } // Re-register all descriptors with kqueue. mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_); for (descriptor_state* state = registered_descriptors_.first(); state != 0; state = state->next_) { if (state->num_kevents_ > 0) { BOOST_ASIO_KQUEUE_EV_SET(&events[0], state->descriptor_, EVFILT_READ, EV_ADD \| EV_CLEAR, 0, 0, state); BOOST_ASIO_KQUEUE_EV_SET(&events[1], state->descriptor_, EVFILT_WRITE, EV_ADD \| EV_CLEAR, 0, 0, state); if (::kevent(kqueue_fd_, events, state->num_kevents_, 0, 0, 0) == -1) { boost::system::error_code ec(errno, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "kqueue re-registration"); } } } } } void kqueue_reactor::init_task() { scheduler_.init_task(); } int kqueue_reactor::register_descriptor(socket_type descriptor, kqueue_reactor::per_descriptor_data& descriptor_data) { descriptor_data = allocate_descriptor_state(); BOOST_ASIO_HANDLER_REACTOR_REGISTRATION(( context(), static_cast<uintmax_t>(descriptor), reinterpret_cast<uintmax_t>(descriptor_data))); mutex::scoped_lock lock(descriptor_data->mutex_); descriptor_data->descriptor_ = descriptor; descriptor_data->num_kevents_ = 0; descriptor_data->shutdown_ = false; return 0; } int kqueue_reactor::register_internal_descriptor( int op_type, socket_type descriptor, kqueue_reactor::per_descriptor_data& descriptor_data, reactor_op* op) { descriptor_data = allocate_descriptor_state(); BOOST_ASIO_HANDLER_REACTOR_REGISTRATION(( context(), static_cast<uintmax_t>(descriptor), reinterpret_cast<uintmax_t>(descriptor_data))); mutex::scoped_lock lock(descriptor_data->mutex_); descriptor_data->descriptor_ = descriptor; descriptor_data->num_kevents_ = 1; descriptor_data->shutdown_ = false; descriptor_data->op_queue_[op_type].push(op); struct kevent events[1]; BOOST_ASIO_KQUEUE_EV_SET(&events[0], descriptor, EVFILT_READ, EV_ADD \| EV_CLEAR, 0, 0, descriptor_data); if (::kevent(kqueue_fd_, events, 1, 0, 0, 0) == -1) return errno; return 0; } void kqueue_reactor::move_descriptor(socket_type, kqueue_reactor::per_descriptor_data& target_descriptor_data, kqueue_reactor::per_descriptor_data& source_descriptor_data) { target_descriptor_data = source_descriptor_data; source_descriptor_data = 0; } void kqueue_reactor::start_op(int op_type, socket_type descriptor, kqueue_reactor::per_descriptor_data& descriptor_data, reactor_op* op, bool is_continuation, bool allow_speculative) { if (!descriptor_data) { op->ec_ = boost::asio::error::bad_descriptor; post_immediate_completion(op, is_continuation); return; } mutex::scoped_lock descriptor_lock(descriptor_data->mutex_); if (descriptor_data->shutdown_) { post_immediate_completion(op, is_continuation); return; } if (descriptor_data->op_queue_[op_type].empty()) { static const int num_kevents[max_ops] = { 1, 2, 1 }; if (allow_speculative && (op_type != read_op \|\| descriptor_data->op_queue_[except_op].empty())) { if (op->perform()) { descriptor_lock.unlock(); scheduler_.post_immediate_completion(op, is_continuation); return; } if (descriptor_data->num_kevents_ < num_kevents[op_type]) { struct kevent events[2]; BOOST_ASIO_KQUEUE_EV_SET(&events[0], descriptor, EVFILT_READ, EV_ADD \| EV_CLEAR, 0, 0, descriptor_data); BOOST_ASIO_KQUEUE_EV_SET(&events[1], descriptor, EVFILT_WRITE, EV_ADD \| EV_CLEAR, 0, 0, descriptor_data); if (::kevent(kqueue_fd_, events, num_kevents[op_type], 0, 0, 0) != -1) { descriptor_data->num_kevents_ = num_kevents[op_type]; } else { op->ec_ = boost::system::error_code(errno, boost::asio::error::get_system_category()); scheduler_.post_immediate_completion(op, is_continuation); return; } } } else { if (descriptor_data->num_kevents_ < num_kevents[op_type]) descriptor_data->num_kevents_ = num_kevents[op_type]; struct kevent events[2]; BOOST_ASIO_KQUEUE_EV_SET(&events[0], descriptor, EVFILT_READ, EV_ADD \| EV_CLEAR, 0, 0, descriptor_data); BOOST_ASIO_KQUEUE_EV_SET(&events[1], descriptor, EVFILT_WRITE, EV_ADD \| EV_CLEAR, 0, 0, descriptor_data); ::kevent(kqueue_fd_, events, descriptor_data->num_kevents_, 0, 0, 0); } } descriptor_data->op_queue_[op_type].push(op); scheduler_.work_started(); } void kqueue_reactor::cancel_ops(socket_type, kqueue_reactor::per_descriptor_data& descriptor_data) { if (!descriptor_data) return; mutex::scoped_lock descriptor_lock(descriptor_data->mutex_); op_queue<operation> ops; for (int i = 0; i < max_ops; ++i) { while (reactor_op* op = descriptor_data->op_queue_[i].front()) { op->ec_ = boost::asio::error::operation_aborted; descriptor_data->op_queue_[i].pop(); ops.push(op); } } descriptor_lock.unlock(); scheduler_.post_deferred_completions(ops); } void kqueue_reactor::deregister_descriptor(socket_type descriptor, kqueue_reactor::per_descriptor_data& descriptor_data, bool closing) { if (!descriptor_data) return; mutex::scoped_lock descriptor_lock(descriptor_data->mutex_); if (!descriptor_data->shutdown_) { if (closing) { // The descriptor will be automatically removed from the kqueue when it // is closed. } else { struct kevent events[2]; BOOST_ASIO_KQUEUE_EV_SET(&events[0], descriptor, EVFILT_READ, EV_DELETE, 0, 0, 0); BOOST_ASIO_KQUEUE_EV_SET(&events[1], descriptor, EVFILT_WRITE, EV_DELETE, 0, 0, 0); ::kevent(kqueue_fd_, events, descriptor_data->num_kevents_, 0, 0, 0); } op_queue<operation> ops; for (int i = 0; i < max_ops; ++i) { while (reactor_op* op = descriptor_data->op_queue_[i].front()) { op->ec_ = boost::asio::error::operation_aborted; descriptor_data->op_queue_[i].pop(); ops.push(op); } } descriptor_data->descriptor_ = -1; descriptor_data->shutdown_ = true; descriptor_lock.unlock(); BOOST_ASIO_HANDLER_REACTOR_DEREGISTRATION(( context(), static_cast<uintmax_t>(descriptor), reinterpret_cast<uintmax_t>(descriptor_data))); scheduler_.post_deferred_completions(ops); // Leave descriptor_data set so that it will be freed by the subsequent // call to cleanup_descriptor_data. } else { // We are shutting down, so prevent cleanup_descriptor_data from freeing // the descriptor_data object and let the destructor free it instead. descriptor_data = 0; } } void kqueue_reactor::deregister_internal_descriptor(socket_type descriptor, kqueue_reactor::per_descriptor_data& descriptor_data) { if (!descriptor_data) return; mutex::scoped_lock descriptor_lock(descriptor_data->mutex_); if (!descriptor_data->shutdown_) { struct kevent events[2]; BOOST_ASIO_KQUEUE_EV_SET(&events[0], descriptor, EVFILT_READ, EV_DELETE, 0, 0, 0); BOOST_ASIO_KQUEUE_EV_SET(&events[1], descriptor, EVFILT_WRITE, EV_DELETE, 0, 0, 0); ::kevent(kqueue_fd_, events, descriptor_data->num_kevents_, 0, 0, 0); op_queue<operation> ops; for (int i = 0; i < max_ops; ++i) ops.push(descriptor_data->op_queue_[i]); descriptor_data->descriptor_ = -1; descriptor_data->shutdown_ = true; descriptor_lock.unlock(); BOOST_ASIO_HANDLER_REACTOR_DEREGISTRATION(( context(), static_cast<uintmax_t>(descriptor), reinterpret_cast<uintmax_t>(descriptor_data))); // Leave descriptor_data set so that it will be freed by the subsequent // call to cleanup_descriptor_data. } else { // We are shutting down, so prevent cleanup_descriptor_data from freeing // the descriptor_data object and let the destructor free it instead. descriptor_data = 0; } } void kqueue_reactor::cleanup_descriptor_data( per_descriptor_data& descriptor_data) { if (descriptor_data) { free_descriptor_state(descriptor_data); descriptor_data = 0; } } void kqueue_reactor::run(long usec, op_queue<operation>& ops) { mutex::scoped_lock lock(mutex_); // Determine how long to block while waiting for events. timespec timeout_buf = { 0, 0 }; timespec* timeout = usec ? get_timeout(usec, timeout_buf) : &timeout_buf; lock.unlock(); // Block on the kqueue descriptor. struct kevent events[128]; int num_events = kevent(kqueue_fd_, 0, 0, events, 128, timeout); #if defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) // Trace the waiting events. for (int i = 0; i < num_events; ++i) { void* ptr = reinterpret_cast<void>(events[i].udata); if (ptr != &interrupter_) { unsigned event_mask = 0; switch (events[i].filter) { case EVFILT_READ: event_mask \|= BOOST_ASIO_HANDLER_REACTOR_READ_EVENT; break; case EVFILT_WRITE: event_mask \|= BOOST_ASIO_HANDLER_REACTOR_WRITE_EVENT; break; } if ((events[i].flags & (EV_ERROR \| EV_OOBAND)) != 0) event_mask \|= BOOST_ASIO_HANDLER_REACTOR_ERROR_EVENT; BOOST_ASIO_HANDLER_REACTOR_EVENTS((context(), reinterpret_cast<uintmax_t>(ptr), event_mask)); } } #endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) // Dispatch the waiting events. for (int i = 0; i < num_events; ++i) { void ptr = reinterpret_cast<void>(events[i].udata); if (ptr == &interrupter_) { interrupter_.reset(); } else { descriptor_state descriptor_data = static_cast<descriptor_state>(ptr); mutex::scoped_lock descriptor_lock(descriptor_data->mutex_); if (events[i].filter == EVFILT_WRITE && descriptor_data->num_kevents_ == 2 && descriptor_data->op_queue_[write_op].empty()) { // Some descriptor types, like serial ports, don't seem to support // EV_CLEAR with EVFILT_WRITE. Since we have no pending write // operations we'll remove the EVFILT_WRITE registration here so that // we don't end up in a tight spin. struct kevent delete_events[1]; BOOST_ASIO_KQUEUE_EV_SET(&delete_events[0], descriptor_data->descriptor_, EVFILT_WRITE, EV_DELETE, 0, 0, 0); ::kevent(kqueue_fd_, delete_events, 1, 0, 0, 0); descriptor_data->num_kevents_ = 1; } // Exception operations must be processed first to ensure that any // out-of-band data is read before normal data. #if defined(__NetBSD__) static const unsigned int filter[max_ops] = #else static const int filter[max_ops] = #endif { EVFILT_READ, EVFILT_WRITE, EVFILT_READ }; for (int j = max_ops - 1; j >= 0; --j) { if (events[i].filter == filter[j]) { if (j != except_op \|\| events[i].flags & EV_OOBAND) { while (reactor_op op = descriptor_data->op_queue_[j].front()) { if (events[i].flags & EV_ERROR) { op->ec_ = boost::system::error_code( static_cast<int>(events[i].data), boost::asio::error::get_system_category()); descriptor_data->op_queue_[j].pop(); ops.push(op); } if (op->perform()) { descriptor_data->op_queue_[j].pop(); ops.push(op); } else break; } } } } } } lock.lock(); timer_queues_.get_ready_timers(ops); } void kqueue_reactor::interrupt() { interrupter_.interrupt(); } int kqueue_reactor::do_kqueue_create() { int fd = ::kqueue(); if (fd == -1) { boost::system::error_code ec(errno, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "kqueue"); } return fd; } kqueue_reactor::descriptor_state* kqueue_reactor::allocate_descriptor_state() { mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_); return registered_descriptors_.alloc(BOOST_ASIO_CONCURRENCY_HINT_IS_LOCKING( REACTOR_IO, scheduler_.concurrency_hint())); } void kqueue_reactor::free_descriptor_state(kqueue_reactor::descriptor_state* s) { mutex::scoped_lock descriptors_lock(registered_descriptors_mutex_); registered_descriptors_.free(s); } void kqueue_reactor::do_add_timer_queue(timer_queue_base& queue) { mutex::scoped_lock lock(mutex_); timer_queues_.insert(&queue); } void kqueue_reactor::do_remove_timer_queue(timer_queue_base& queue) { mutex::scoped_lock lock(mutex_); timer_queues_.erase(&queue); } timespec* kqueue_reactor::get_timeout(long usec, timespec& ts) { // By default we will wait no longer than 5 minutes. This will ensure that // any changes to the system clock are detected after no longer than this. const long max_usec = 5 * 60 * 1000 * 1000; usec = timer_queues_.wait_duration_usec( (usec < 0 \|\| max_usec < usec) ? max_usec : usec); ts.tv_sec = usec / 1000000; ts.tv_nsec = (usec % 1000000) * 1000; return &ts; } } // namespace detail } // namespace asio } // namespace boost #undef BOOST_ASIO_KQUEUE_EV_SET #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_KQUEUE) #endif // BOOST_ASIO_DETAIL_IMPL_KQUEUE_REACTOR_IPP PK��h!\�{�I��%��impl/win_iocp_serial_port_service.ippnu��[��// // detail/impl/win_iocp_serial_port_service.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.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_DETAIL_IMPL_WIN_IOCP_SERIAL_PORT_SERVICE_IPP #define BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_SERIAL_PORT_SERVICE_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_HAS_IOCP) && defined(BOOST_ASIO_HAS_SERIAL_PORT) #include <cstring> #include <boost/asio/detail/win_iocp_serial_port_service.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { win_iocp_serial_port_service::win_iocp_serial_port_service( execution_context& context) : execution_context_service_base<win_iocp_serial_port_service>(context), handle_service_(context) { } void win_iocp_serial_port_service::shutdown() { } boost::system::error_code win_iocp_serial_port_service::open( win_iocp_serial_port_service::implementation_type& impl, const std::string& device, boost::system::error_code& ec) { if (is_open(impl)) { ec = boost::asio::error::already_open; return ec; } // For convenience, add a leading \\.\ sequence if not already present. std::string name = (device[0] == '\\') ? device : "\\\\.\\" + device; // Open a handle to the serial port. ::HANDLE handle = ::CreateFileA(name.c_str(), GENERIC_READ \| GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0); if (handle == INVALID_HANDLE_VALUE) { DWORD last_error = ::GetLastError(); ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); return ec; } // Determine the initial serial port parameters. using namespace std; // For memset. ::DCB dcb; memset(&dcb, 0, sizeof(DCB)); dcb.DCBlength = sizeof(DCB); if (!::GetCommState(handle, &dcb)) { DWORD last_error = ::GetLastError(); ::CloseHandle(handle); ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); return ec; } // Set some default serial port parameters. This implementation does not // support changing all of these, so they might as well be in a known state. dcb.fBinary = TRUE; // Win32 only supports binary mode. dcb.fNull = FALSE; // Do not ignore NULL characters. dcb.fAbortOnError = FALSE; // Ignore serial framing errors. dcb.BaudRate = CBR_9600; // 9600 baud by default dcb.ByteSize = 8; // 8 bit bytes dcb.fOutxCtsFlow = FALSE; // No flow control dcb.fOutxDsrFlow = FALSE; dcb.fDtrControl = DTR_CONTROL_DISABLE; dcb.fDsrSensitivity = FALSE; dcb.fOutX = FALSE; dcb.fInX = FALSE; dcb.fRtsControl = RTS_CONTROL_DISABLE; dcb.fParity = FALSE; // No parity dcb.Parity = NOPARITY; dcb.StopBits = ONESTOPBIT; // One stop bit if (!::SetCommState(handle, &dcb)) { DWORD last_error = ::GetLastError(); ::CloseHandle(handle); ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); return ec; } // Set up timeouts so that the serial port will behave similarly to a // network socket. Reads wait for at least one byte, then return with // whatever they have. Writes return once everything is out the door. ::COMMTIMEOUTS timeouts; timeouts.ReadIntervalTimeout = 1; timeouts.ReadTotalTimeoutMultiplier = 0; timeouts.ReadTotalTimeoutConstant = 0; timeouts.WriteTotalTimeoutMultiplier = 0; timeouts.WriteTotalTimeoutConstant = 0; if (!::SetCommTimeouts(handle, &timeouts)) { DWORD last_error = ::GetLastError(); ::CloseHandle(handle); ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); return ec; } // We're done. Take ownership of the serial port handle. if (handle_service_.assign(impl, handle, ec)) ::CloseHandle(handle); return ec; } boost::system::error_code win_iocp_serial_port_service::do_set_option( win_iocp_serial_port_service::implementation_type& impl, win_iocp_serial_port_service::store_function_type store, const void* option, boost::system::error_code& ec) { using namespace std; // For memcpy. ::DCB dcb; memset(&dcb, 0, sizeof(DCB)); dcb.DCBlength = sizeof(DCB); if (!::GetCommState(handle_service_.native_handle(impl), &dcb)) { DWORD last_error = ::GetLastError(); ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); return ec; } if (store(option, dcb, ec)) return ec; if (!::SetCommState(handle_service_.native_handle(impl), &dcb)) { DWORD last_error = ::GetLastError(); ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); return ec; } ec = boost::system::error_code(); return ec; } boost::system::error_code win_iocp_serial_port_service::do_get_option( const win_iocp_serial_port_service::implementation_type& impl, win_iocp_serial_port_service::load_function_type load, void* option, boost::system::error_code& ec) const { using namespace std; // For memset. ::DCB dcb; memset(&dcb, 0, sizeof(DCB)); dcb.DCBlength = sizeof(DCB); if (!::GetCommState(handle_service_.native_handle(impl), &dcb)) { DWORD last_error = ::GetLastError(); ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); return ec; } return load(option, dcb, ec); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) && defined(BOOST_ASIO_HAS_SERIAL_PORT) #endif // BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_SERIAL_PORT_SERVICE_IPP PK��h!\� �5��impl/strand_service.ippnu��[��// // detail/impl/strand_service.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_STRAND_SERVICE_IPP #define BOOST_ASIO_DETAIL_IMPL_STRAND_SERVICE_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/detail/call_stack.hpp> #include <boost/asio/detail/strand_service.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { struct strand_service::on_do_complete_exit { io_context_impl* owner_; strand_impl* impl_; ~on_do_complete_exit() { impl_->mutex_.lock(); impl_->ready_queue_.push(impl_->waiting_queue_); bool more_handlers = impl_->locked_ = !impl_->ready_queue_.empty(); impl_->mutex_.unlock(); if (more_handlers) owner_->post_immediate_completion(impl_, true); } }; strand_service::strand_service(boost::asio::io_context& io_context) : boost::asio::detail::service_base<strand_service>(io_context), io_context_(io_context), io_context_impl_(boost::asio::use_service<io_context_impl>(io_context)), mutex_(), salt_(0) { } void strand_service::shutdown() { op_queue<operation> ops; boost::asio::detail::mutex::scoped_lock lock(mutex_); for (std::size_t i = 0; i < num_implementations; ++i) { if (strand_impl* impl = implementations_[i].get()) { ops.push(impl->waiting_queue_); ops.push(impl->ready_queue_); } } } void strand_service::construct(strand_service::implementation_type& impl) { boost::asio::detail::mutex::scoped_lock lock(mutex_); std::size_t salt = salt_++; #if defined(BOOST_ASIO_ENABLE_SEQUENTIAL_STRAND_ALLOCATION) std::size_t index = salt; #else // defined(BOOST_ASIO_ENABLE_SEQUENTIAL_STRAND_ALLOCATION) std::size_t index = reinterpret_cast<std::size_t>(&impl); index += (reinterpret_cast<std::size_t>(&impl) >> 3); index ^= salt + 0x9e3779b9 + (index << 6) + (index >> 2); #endif // defined(BOOST_ASIO_ENABLE_SEQUENTIAL_STRAND_ALLOCATION) index = index % num_implementations; if (!implementations_[index].get()) implementations_[index].reset(new strand_impl); impl = implementations_[index].get(); } bool strand_service::running_in_this_thread( const implementation_type& impl) const { return call_stack<strand_impl>::contains(impl) != 0; } bool strand_service::do_dispatch(implementation_type& impl, operation* op) { // If we are running inside the io_context, and no other handler already // holds the strand lock, then the handler can run immediately. bool can_dispatch = io_context_impl_.can_dispatch(); impl->mutex_.lock(); if (can_dispatch && !impl->locked_) { // Immediate invocation is allowed. impl->locked_ = true; impl->mutex_.unlock(); return true; } if (impl->locked_) { // Some other handler already holds the strand lock. Enqueue for later. impl->waiting_queue_.push(op); impl->mutex_.unlock(); } else { // The handler is acquiring the strand lock and so is responsible for // scheduling the strand. impl->locked_ = true; impl->mutex_.unlock(); impl->ready_queue_.push(op); io_context_impl_.post_immediate_completion(impl, false); } return false; } void strand_service::do_post(implementation_type& impl, operation* op, bool is_continuation) { impl->mutex_.lock(); if (impl->locked_) { // Some other handler already holds the strand lock. Enqueue for later. impl->waiting_queue_.push(op); impl->mutex_.unlock(); } else { // The handler is acquiring the strand lock and so is responsible for // scheduling the strand. impl->locked_ = true; impl->mutex_.unlock(); impl->ready_queue_.push(op); io_context_impl_.post_immediate_completion(impl, is_continuation); } } void strand_service::do_complete(void* owner, operation* base, const boost::system::error_code& ec, std::size_t /bytes_transferred/) { if (owner) { strand_impl* impl = static_cast<strand_impl>(base); // Indicate that this strand is executing on the current thread. call_stack<strand_impl>::context ctx(impl); // Ensure the next handler, if any, is scheduled on block exit. on_do_complete_exit on_exit; on_exit.owner_ = static_cast<io_context_impl>(owner); on_exit.impl_ = impl; // Run all ready handlers. No lock is required since the ready queue is // accessed only within the strand. while (operation* o = impl->ready_queue_.front()) { impl->ready_queue_.pop(); o->complete(owner, ec, 0); } } } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_IMPL_STRAND_SERVICE_IPP PK��h!\ ��impl/win_tss_ptr.ippnu��[��// // detail/impl/win_tss_ptr.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_WIN_TSS_PTR_IPP #define BOOST_ASIO_DETAIL_IMPL_WIN_TSS_PTR_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_WINDOWS) #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/detail/win_tss_ptr.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { DWORD win_tss_ptr_create() { #if defined(UNDER_CE) const DWORD out_of_indexes = 0xFFFFFFFF; #else const DWORD out_of_indexes = TLS_OUT_OF_INDEXES; #endif DWORD tss_key = ::TlsAlloc(); if (tss_key == out_of_indexes) { DWORD last_error = ::GetLastError(); boost::system::error_code ec(last_error, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "tss"); } return tss_key; } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS) #endif // BOOST_ASIO_DETAIL_IMPL_WIN_TSS_PTR_IPP PK��h!\h%�Nh��h�� impl/pipe_select_interrupter.ippnu��[��// // detail/impl/pipe_select_interrupter.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_PIPE_SELECT_INTERRUPTER_IPP #define BOOST_ASIO_DETAIL_IMPL_PIPE_SELECT_INTERRUPTER_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_WINDOWS_RUNTIME) #if !defined(BOOST_ASIO_WINDOWS) #if !defined(__CYGWIN__) #if !defined(__SYMBIAN32__) #if !defined(BOOST_ASIO_HAS_EVENTFD) #include <fcntl.h> #include <sys/stat.h> #include <sys/types.h> #include <unistd.h> #include <boost/asio/detail/pipe_select_interrupter.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { pipe_select_interrupter::pipe_select_interrupter() { open_descriptors(); } void pipe_select_interrupter::open_descriptors() { int pipe_fds[2]; if (pipe(pipe_fds) == 0) { read_descriptor_ = pipe_fds[0]; ::fcntl(read_descriptor_, F_SETFL, O_NONBLOCK); write_descriptor_ = pipe_fds[1]; ::fcntl(write_descriptor_, F_SETFL, O_NONBLOCK); #if defined(FD_CLOEXEC) ::fcntl(read_descriptor_, F_SETFD, FD_CLOEXEC); ::fcntl(write_descriptor_, F_SETFD, FD_CLOEXEC); #endif // defined(FD_CLOEXEC) } else { boost::system::error_code ec(errno, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "pipe_select_interrupter"); } } pipe_select_interrupter::~pipe_select_interrupter() { close_descriptors(); } void pipe_select_interrupter::close_descriptors() { if (read_descriptor_ != -1) ::close(read_descriptor_); if (write_descriptor_ != -1) ::close(write_descriptor_); } void pipe_select_interrupter::recreate() { close_descriptors(); write_descriptor_ = -1; read_descriptor_ = -1; open_descriptors(); } void pipe_select_interrupter::interrupt() { char byte = 0; signed_size_type result = ::write(write_descriptor_, &byte, 1); (void)result; } bool pipe_select_interrupter::reset() { for (;;) { char data[1024]; signed_size_type bytes_read = ::read(read_descriptor_, data, sizeof(data)); if (bytes_read == sizeof(data)) continue; if (bytes_read > 0) return true; if (bytes_read == 0) return false; if (errno == EINTR) continue; if (errno == EWOULDBLOCK \|\| errno == EAGAIN) return true; return false; } } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // !defined(BOOST_ASIO_HAS_EVENTFD) #endif // !defined(__SYMBIAN32__) #endif // !defined(__CYGWIN__) #endif // !defined(BOOST_ASIO_WINDOWS) #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_IMPL_PIPE_SELECT_INTERRUPTER_IPP PK��h!\��w��impl/posix_mutex.ippnu��[��// // detail/impl/posix_mutex.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_POSIX_MUTEX_IPP #define BOOST_ASIO_DETAIL_IMPL_POSIX_MUTEX_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_HAS_PTHREADS) #include <boost/asio/detail/posix_mutex.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { posix_mutex::posix_mutex() { int error = ::pthread_mutex_init(&mutex_, 0); boost::system::error_code ec(error, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "mutex"); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_PTHREADS) #endif // BOOST_ASIO_DETAIL_IMPL_POSIX_MUTEX_IPP PK��h!\�g��impl/win_event.ippnu��[��// // detail/win_event.ipp // ~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_WIN_EVENT_IPP #define BOOST_ASIO_DETAIL_IMPL_WIN_EVENT_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_WINDOWS) #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/detail/win_event.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { win_event::win_event() : state_(0) { #if defined(BOOST_ASIO_WINDOWS_APP) events_[0] = ::CreateEventExW(0, 0, CREATE_EVENT_MANUAL_RESET, EVENT_ALL_ACCESS); #else // defined(BOOST_ASIO_WINDOWS_APP) events_[0] = ::CreateEventW(0, true, false, 0); #endif // defined(BOOST_ASIO_WINDOWS_APP) if (!events_[0]) { DWORD last_error = ::GetLastError(); boost::system::error_code ec(last_error, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "event"); } #if defined(BOOST_ASIO_WINDOWS_APP) events_[1] = ::CreateEventExW(0, 0, 0, EVENT_ALL_ACCESS); #else // defined(BOOST_ASIO_WINDOWS_APP) events_[1] = ::CreateEventW(0, false, false, 0); #endif // defined(BOOST_ASIO_WINDOWS_APP) if (!events_[1]) { DWORD last_error = ::GetLastError(); ::CloseHandle(events_[0]); boost::system::error_code ec(last_error, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "event"); } } win_event::~win_event() { ::CloseHandle(events_[0]); ::CloseHandle(events_[1]); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS) #endif // BOOST_ASIO_DETAIL_IMPL_WIN_EVENT_IPP PK��h!\�� impl/buffer_sequence_adapter.ippnu��[��// // detail/impl/buffer_sequence_adapter.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_BUFFER_SEQUENCE_ADAPTER_IPP #define BOOST_ASIO_DETAIL_IMPL_BUFFER_SEQUENCE_ADAPTER_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_WINDOWS_RUNTIME) #include <robuffer.h> #include <windows.storage.streams.h> #include <wrl/implements.h> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class winrt_buffer_impl : public Microsoft::WRL::RuntimeClass< Microsoft::WRL::RuntimeClassFlags< Microsoft::WRL::RuntimeClassType::WinRtClassicComMix>, ABI::Windows::Storage::Streams::IBuffer, Windows::Storage::Streams::IBufferByteAccess> { public: explicit winrt_buffer_impl(const boost::asio::const_buffer& b) { bytes_ = const_cast<byte>(static_cast<const byte>(b.data())); length_ = b.size(); capacity_ = b.size(); } explicit winrt_buffer_impl(const boost::asio::mutable_buffer& b) { bytes_ = static_cast<byte>(b.data()); length_ = 0; capacity_ = b.size(); } ~winrt_buffer_impl() { } STDMETHODIMP Buffer(byte* value) { value = bytes_; return S_OK; } STDMETHODIMP get_Capacity(UINT32 value) { value = capacity_; return S_OK; } STDMETHODIMP get_Length(UINT32 value) { value = length_; return S_OK; } STDMETHODIMP put_Length(UINT32 value) { if (value > capacity_) return E_INVALIDARG; length_ = value; return S_OK; } private: byte bytes_; UINT32 length_; UINT32 capacity_; }; void buffer_sequence_adapter_base::init_native_buffer( buffer_sequence_adapter_base::native_buffer_type& buf, const boost::asio::mutable_buffer& buffer) { std::memset(&buf, 0, sizeof(native_buffer_type)); Microsoft::WRL::ComPtr<IInspectable> insp = Microsoft::WRL::Make<winrt_buffer_impl>(buffer); buf = reinterpret_cast<Windows::Storage::Streams::IBuffer^>(insp.Get()); } void buffer_sequence_adapter_base::init_native_buffer( buffer_sequence_adapter_base::native_buffer_type& buf, const boost::asio::const_buffer& buffer) { std::memset(&buf, 0, sizeof(native_buffer_type)); Microsoft::WRL::ComPtr<IInspectable> insp = Microsoft::WRL::Make<winrt_buffer_impl>(buffer); Platform::Object^ buf_obj = reinterpret_cast<Platform::Object^>(insp.Get()); buf = reinterpret_cast<Windows::Storage::Streams::IBuffer^>(insp.Get()); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_IMPL_BUFFER_SEQUENCE_ADAPTER_IPP PK��h!\[&C ��impl/winrt_timer_scheduler.ippnu��[��// // detail/impl/winrt_timer_scheduler.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_IPP #define BOOST_ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_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_WINDOWS_RUNTIME) #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/winrt_timer_scheduler.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { winrt_timer_scheduler::winrt_timer_scheduler(execution_context& context) : execution_context_service_base<winrt_timer_scheduler>(context), scheduler_(use_service<scheduler_impl>(context)), mutex_(), event_(), timer_queues_(), thread_(0), stop_thread_(false), shutdown_(false) { thread_ = new boost::asio::detail::thread( bind_handler(&winrt_timer_scheduler::call_run_thread, this)); } winrt_timer_scheduler::~winrt_timer_scheduler() { shutdown(); } void winrt_timer_scheduler::shutdown() { boost::asio::detail::mutex::scoped_lock lock(mutex_); shutdown_ = true; stop_thread_ = true; event_.signal(lock); lock.unlock(); if (thread_) { thread_->join(); delete thread_; thread_ = 0; } op_queue<operation> ops; timer_queues_.get_all_timers(ops); scheduler_.abandon_operations(ops); } void winrt_timer_scheduler::notify_fork(execution_context::fork_event) { } void winrt_timer_scheduler::init_task() { } void winrt_timer_scheduler::run_thread() { boost::asio::detail::mutex::scoped_lock lock(mutex_); while (!stop_thread_) { const long max_wait_duration = 5 * 60 * 1000000; long wait_duration = timer_queues_.wait_duration_usec(max_wait_duration); event_.wait_for_usec(lock, wait_duration); event_.clear(lock); op_queue<operation> ops; timer_queues_.get_ready_timers(ops); if (!ops.empty()) { lock.unlock(); scheduler_.post_deferred_completions(ops); lock.lock(); } } } void winrt_timer_scheduler::call_run_thread(winrt_timer_scheduler* scheduler) { scheduler->run_thread(); } void winrt_timer_scheduler::do_add_timer_queue(timer_queue_base& queue) { mutex::scoped_lock lock(mutex_); timer_queues_.insert(&queue); } void winrt_timer_scheduler::do_remove_timer_queue(timer_queue_base& queue) { mutex::scoped_lock lock(mutex_); timer_queues_.erase(&queue); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_IMPL_WINRT_TIMER_SCHEDULER_IPP PK��h!\Q��impl/select_reactor.hppnu��[��// // detail/impl/select_reactor.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_SELECT_REACTOR_HPP #define BOOST_ASIO_DETAIL_IMPL_SELECT_REACTOR_HPP #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_HAS_IOCP) \ \|\| (!defined(BOOST_ASIO_HAS_DEV_POLL) \ && !defined(BOOST_ASIO_HAS_EPOLL) \ && !defined(BOOST_ASIO_HAS_KQUEUE) \ && !defined(BOOST_ASIO_WINDOWS_RUNTIME)) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Time_Traits> void select_reactor::add_timer_queue(timer_queue<Time_Traits>& queue) { do_add_timer_queue(queue); } // Remove a timer queue from the reactor. template <typename Time_Traits> void select_reactor::remove_timer_queue(timer_queue<Time_Traits>& queue) { do_remove_timer_queue(queue); } template <typename Time_Traits> void select_reactor::schedule_timer(timer_queue<Time_Traits>& queue, const typename Time_Traits::time_type& time, typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op) { boost::asio::detail::mutex::scoped_lock lock(mutex_); if (shutdown_) { scheduler_.post_immediate_completion(op, false); return; } bool earliest = queue.enqueue_timer(time, timer, op); scheduler_.work_started(); if (earliest) interrupter_.interrupt(); } template <typename Time_Traits> std::size_t select_reactor::cancel_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& timer, std::size_t max_cancelled) { boost::asio::detail::mutex::scoped_lock lock(mutex_); op_queue<operation> ops; std::size_t n = queue.cancel_timer(timer, ops, max_cancelled); lock.unlock(); scheduler_.post_deferred_completions(ops); return n; } template <typename Time_Traits> void select_reactor::move_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& target, typename timer_queue<Time_Traits>::per_timer_data& source) { boost::asio::detail::mutex::scoped_lock lock(mutex_); op_queue<operation> ops; queue.cancel_timer(target, ops); queue.move_timer(target, source); lock.unlock(); scheduler_.post_deferred_completions(ops); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) // \|\| (!defined(BOOST_ASIO_HAS_DEV_POLL) // && !defined(BOOST_ASIO_HAS_EPOLL) // && !defined(BOOST_ASIO_HAS_KQUEUE) // && !defined(BOOST_ASIO_WINDOWS_RUNTIME)) #endif // BOOST_ASIO_DETAIL_IMPL_SELECT_REACTOR_HPP PK��h!\��zV��V��impl/service_registry.ippnu��[��// // detail/impl/service_registry.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_SERVICE_REGISTRY_IPP #define BOOST_ASIO_DETAIL_IMPL_SERVICE_REGISTRY_IPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <vector> #include <boost/asio/detail/service_registry.hpp> #include <boost/asio/detail/throw_exception.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { service_registry::service_registry(execution_context& owner) : owner_(owner), first_service_(0) { } service_registry::~service_registry() { } void service_registry::shutdown_services() { execution_context::service* service = first_service_; while (service) { service->shutdown(); service = service->next_; } } void service_registry::destroy_services() { while (first_service_) { execution_context::service* next_service = first_service_->next_; destroy(first_service_); first_service_ = next_service; } } void service_registry::notify_fork(execution_context::fork_event fork_ev) { // Make a copy of all of the services while holding the lock. We don't want // to hold the lock while calling into each service, as it may try to call // back into this class. std::vector<execution_context::service> services; { boost::asio::detail::mutex::scoped_lock lock(mutex_); execution_context::service service = first_service_; while (service) { services.push_back(service); service = service->next_; } } // If processing the fork_prepare event, we want to go in reverse order of // service registration, which happens to be the existing order of the // services in the vector. For the other events we want to go in the other // direction. std::size_t num_services = services.size(); if (fork_ev == execution_context::fork_prepare) for (std::size_t i = 0; i < num_services; ++i) services[i]->notify_fork(fork_ev); else for (std::size_t i = num_services; i > 0; --i) services[i - 1]->notify_fork(fork_ev); } void service_registry::init_key_from_id(execution_context::service::key& key, const execution_context::id& id) { key.type_info_ = 0; key.id_ = &id; } bool service_registry::keys_match( const execution_context::service::key& key1, const execution_context::service::key& key2) { if (key1.id_ && key2.id_) if (key1.id_ == key2.id_) return true; if (key1.type_info_ && key2.type_info_) if (key1.type_info_ == key2.type_info_) return true; return false; } void service_registry::destroy(execution_context::service* service) { delete service; } execution_context::service* service_registry::do_use_service( const execution_context::service::key& key, factory_type factory, void* owner) { boost::asio::detail::mutex::scoped_lock lock(mutex_); // First see if there is an existing service object with the given key. execution_context::service* service = first_service_; while (service) { if (keys_match(service->key_, key)) return service; service = service->next_; } // Create a new service object. The service registry's mutex is not locked // at this time to allow for nested calls into this function from the new // service's constructor. lock.unlock(); auto_service_ptr new_service = { factory(owner) }; new_service.ptr_->key_ = key; lock.lock(); // Check that nobody else created another service object of the same type // while the lock was released. service = first_service_; while (service) { if (keys_match(service->key_, key)) return service; service = service->next_; } // Service was successfully initialised, pass ownership to registry. new_service.ptr_->next_ = first_service_; first_service_ = new_service.ptr_; new_service.ptr_ = 0; return first_service_; } void service_registry::do_add_service( const execution_context::service::key& key, execution_context::service* new_service) { if (&owner_ != &new_service->context()) boost::asio::detail::throw_exception(invalid_service_owner()); boost::asio::detail::mutex::scoped_lock lock(mutex_); // Check if there is an existing service object with the given key. execution_context::service* service = first_service_; while (service) { if (keys_match(service->key_, key)) boost::asio::detail::throw_exception(service_already_exists()); service = service->next_; } // Take ownership of the service object. new_service->key_ = key; new_service->next_ = first_service_; first_service_ = new_service; } bool service_registry::do_has_service( const execution_context::service::key& key) const { boost::asio::detail::mutex::scoped_lock lock(mutex_); execution_context::service* service = first_service_; while (service) { if (keys_match(service->key_, key)) return true; service = service->next_; } return false; } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_IMPL_SERVICE_REGISTRY_IPP PK��h!\��4��impl/posix_event.ippnu��[��// // detail/impl/posix_event.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_POSIX_EVENT_IPP #define BOOST_ASIO_DETAIL_IMPL_POSIX_EVENT_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_HAS_PTHREADS) #include <boost/asio/detail/posix_event.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { posix_event::posix_event() : state_(0) { #if (defined(__MACH__) && defined(__APPLE__)) \ \|\| (defined(__ANDROID__) && (__ANDROID_API__ < 21)) int error = ::pthread_cond_init(&cond_, 0); #else // (defined(__MACH__) && defined(__APPLE__)) // \|\| (defined(__ANDROID__) && (__ANDROID_API__ < 21)) ::pthread_condattr_t attr; ::pthread_condattr_init(&attr); int error = ::pthread_condattr_setclock(&attr, CLOCK_MONOTONIC); if (error == 0) error = ::pthread_cond_init(&cond_, &attr); #endif // (defined(__MACH__) && defined(__APPLE__)) // \|\| (defined(__ANDROID__) && (__ANDROID_API__ < 21)) boost::system::error_code ec(error, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "event"); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_PTHREADS) #endif // BOOST_ASIO_DETAIL_IMPL_POSIX_EVENT_IPP PK��h!\z��= �� impl/dev_poll_reactor.hppnu��[��// // detail/impl/dev_poll_reactor.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_DEV_POLL_REACTOR_HPP #define BOOST_ASIO_DETAIL_IMPL_DEV_POLL_REACTOR_HPP #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_HAS_DEV_POLL) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Time_Traits> void dev_poll_reactor::add_timer_queue(timer_queue<Time_Traits>& queue) { do_add_timer_queue(queue); } template <typename Time_Traits> void dev_poll_reactor::remove_timer_queue(timer_queue<Time_Traits>& queue) { do_remove_timer_queue(queue); } template <typename Time_Traits> void dev_poll_reactor::schedule_timer(timer_queue<Time_Traits>& queue, const typename Time_Traits::time_type& time, typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op) { boost::asio::detail::mutex::scoped_lock lock(mutex_); if (shutdown_) { scheduler_.post_immediate_completion(op, false); return; } bool earliest = queue.enqueue_timer(time, timer, op); scheduler_.work_started(); if (earliest) interrupter_.interrupt(); } template <typename Time_Traits> std::size_t dev_poll_reactor::cancel_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& timer, std::size_t max_cancelled) { boost::asio::detail::mutex::scoped_lock lock(mutex_); op_queue<operation> ops; std::size_t n = queue.cancel_timer(timer, ops, max_cancelled); lock.unlock(); scheduler_.post_deferred_completions(ops); return n; } template <typename Time_Traits> void dev_poll_reactor::move_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& target, typename timer_queue<Time_Traits>::per_timer_data& source) { boost::asio::detail::mutex::scoped_lock lock(mutex_); op_queue<operation> ops; queue.cancel_timer(target, ops); queue.move_timer(target, source); lock.unlock(); scheduler_.post_deferred_completions(ops); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_DEV_POLL) #endif // BOOST_ASIO_DETAIL_IMPL_DEV_POLL_REACTOR_HPP PK��h!\��:��impl/win_mutex.ippnu��[��// // detail/impl/win_mutex.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_WIN_MUTEX_IPP #define BOOST_ASIO_DETAIL_IMPL_WIN_MUTEX_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_WINDOWS) #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/detail/win_mutex.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { win_mutex::win_mutex() { int error = do_init(); boost::system::error_code ec(error, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "mutex"); } int win_mutex::do_init() { #if defined(__MINGW32__) // Not sure if MinGW supports structured exception handling, so for now // we'll just call the Windows API and hope. # if defined(UNDER_CE) ::InitializeCriticalSection(&crit_section_); # elif defined(BOOST_ASIO_WINDOWS_APP) if (!::InitializeCriticalSectionEx(&crit_section_, 0, 0)) return ::GetLastError(); # else if (!::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000)) return ::GetLastError(); # endif return 0; #else __try { # if defined(UNDER_CE) ::InitializeCriticalSection(&crit_section_); # elif defined(BOOST_ASIO_WINDOWS_APP) if (!::InitializeCriticalSectionEx(&crit_section_, 0, 0)) return ::GetLastError(); # else if (!::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000)) return ::GetLastError(); # endif } __except(GetExceptionCode() == STATUS_NO_MEMORY ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) { return ERROR_OUTOFMEMORY; } return 0; #endif } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS) #endif // BOOST_ASIO_DETAIL_IMPL_WIN_MUTEX_IPP PK��h!\$�� impl/kqueue_reactor.hppnu��[��// // detail/impl/kqueue_reactor.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2005 Stefan Arentz (stefan at soze 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_DETAIL_IMPL_KQUEUE_REACTOR_HPP #define BOOST_ASIO_DETAIL_IMPL_KQUEUE_REACTOR_HPP #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_HAS_KQUEUE) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Time_Traits> void kqueue_reactor::add_timer_queue(timer_queue<Time_Traits>& queue) { do_add_timer_queue(queue); } // Remove a timer queue from the reactor. template <typename Time_Traits> void kqueue_reactor::remove_timer_queue(timer_queue<Time_Traits>& queue) { do_remove_timer_queue(queue); } template <typename Time_Traits> void kqueue_reactor::schedule_timer(timer_queue<Time_Traits>& queue, const typename Time_Traits::time_type& time, typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op) { mutex::scoped_lock lock(mutex_); if (shutdown_) { scheduler_.post_immediate_completion(op, false); return; } bool earliest = queue.enqueue_timer(time, timer, op); scheduler_.work_started(); if (earliest) interrupt(); } template <typename Time_Traits> std::size_t kqueue_reactor::cancel_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& timer, std::size_t max_cancelled) { mutex::scoped_lock lock(mutex_); op_queue<operation> ops; std::size_t n = queue.cancel_timer(timer, ops, max_cancelled); lock.unlock(); scheduler_.post_deferred_completions(ops); return n; } template <typename Time_Traits> void kqueue_reactor::move_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& target, typename timer_queue<Time_Traits>::per_timer_data& source) { mutex::scoped_lock lock(mutex_); op_queue<operation> ops; queue.cancel_timer(target, ops); queue.move_timer(target, source); lock.unlock(); scheduler_.post_deferred_completions(ops); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_KQUEUE) #endif // BOOST_ASIO_DETAIL_IMPL_KQUEUE_REACTOR_HPP PK��h!\��impl/socket_ops.ippnu��[��// // detail/impl/socket_ops.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_SOCKET_OPS_IPP #define BOOST_ASIO_DETAIL_SOCKET_OPS_IPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <cctype> #include <cstdio> #include <cstdlib> #include <cstring> #include <cerrno> #include <new> #include <boost/asio/detail/assert.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/error.hpp> #if defined(BOOST_ASIO_WINDOWS_RUNTIME) # include <codecvt> # include <locale> # include <string> #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) \ \|\| defined(__MACH__) && defined(__APPLE__) # if defined(BOOST_ASIO_HAS_PTHREADS) # include <pthread.h> # endif // defined(BOOST_ASIO_HAS_PTHREADS) #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) // \|\| defined(__MACH__) && defined(__APPLE__) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { namespace socket_ops { #if !defined(BOOST_ASIO_WINDOWS_RUNTIME) #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) struct msghdr { int msg_namelen; }; #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) #if defined(__hpux) // HP-UX doesn't declare these functions extern "C", so they are declared again // here to avoid linker errors about undefined symbols. extern "C" char* if_indextoname(unsigned int, char); extern "C" unsigned int if_nametoindex(const char); #endif // defined(__hpux) #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) inline void clear_last_error() { #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) WSASetLastError(0); #else errno = 0; #endif } #if !defined(BOOST_ASIO_WINDOWS_RUNTIME) inline void get_last_error( boost::system::error_code& ec, bool is_error_condition) { if (!is_error_condition) { ec.assign(0, ec.category()); } else { #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) ec = boost::system::error_code(WSAGetLastError(), boost::asio::error::get_system_category()); #else ec = boost::system::error_code(errno, boost::asio::error::get_system_category()); #endif } } template <typename SockLenType> inline socket_type call_accept(SockLenType msghdr::, socket_type s, socket_addr_type addr, std::size_t* addrlen) { SockLenType tmp_addrlen = addrlen ? (SockLenType)addrlen : 0; socket_type result = ::accept(s, addr, addrlen ? &tmp_addrlen : 0); if (addrlen) addrlen = (std::size_t)tmp_addrlen; return result; } socket_type accept(socket_type s, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return invalid_socket; } socket_type new_s = call_accept(&msghdr::msg_namelen, s, addr, addrlen); get_last_error(ec, new_s == invalid_socket); if (new_s == invalid_socket) return new_s; #if defined(__MACH__) && defined(__APPLE__) \|\| defined(__FreeBSD__) int optval = 1; int result = ::setsockopt(new_s, SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval)); get_last_error(ec, result != 0); if (result != 0) { ::close(new_s); return invalid_socket; } #endif ec.assign(0, ec.category()); return new_s; } socket_type sync_accept(socket_type s, state_type state, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec) { // Accept a socket. for (;;) { // Try to complete the operation without blocking. socket_type new_socket = socket_ops::accept(s, addr, addrlen, ec); // Check if operation succeeded. if (new_socket != invalid_socket) return new_socket; // Operation failed. if (ec == boost::asio::error::would_block \|\| ec == boost::asio::error::try_again) { if (state & user_set_non_blocking) return invalid_socket; // Fall through to retry operation. } else if (ec == boost::asio::error::connection_aborted) { if (state & enable_connection_aborted) return invalid_socket; // Fall through to retry operation. } #if defined(EPROTO) else if (ec.value() == EPROTO) { if (state & enable_connection_aborted) return invalid_socket; // Fall through to retry operation. } #endif // defined(EPROTO) else return invalid_socket; // Wait for socket to become ready. if (socket_ops::poll_read(s, 0, -1, ec) < 0) return invalid_socket; } } #if defined(BOOST_ASIO_HAS_IOCP) void complete_iocp_accept(socket_type s, void* output_buffer, DWORD address_length, socket_addr_type* addr, std::size_t* addrlen, socket_type new_socket, boost::system::error_code& ec) { // Map non-portable errors to their portable counterparts. if (ec.value() == ERROR_NETNAME_DELETED) ec = boost::asio::error::connection_aborted; if (!ec) { // Get the address of the peer. if (addr && addrlen) { LPSOCKADDR local_addr = 0; int local_addr_length = 0; LPSOCKADDR remote_addr = 0; int remote_addr_length = 0; GetAcceptExSockaddrs(output_buffer, 0, address_length, address_length, &local_addr, &local_addr_length, &remote_addr, &remote_addr_length); if (static_cast<std::size_t>(remote_addr_length) > addrlen) { ec = boost::asio::error::invalid_argument; } else { using namespace std; // For memcpy. memcpy(addr, remote_addr, remote_addr_length); addrlen = static_cast<std::size_t>(remote_addr_length); } } // Need to set the SO_UPDATE_ACCEPT_CONTEXT option so that getsockname // and getpeername will work on the accepted socket. SOCKET update_ctx_param = s; socket_ops::state_type state = 0; socket_ops::setsockopt(new_socket, state, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, &update_ctx_param, sizeof(SOCKET), ec); } } #else // defined(BOOST_ASIO_HAS_IOCP) bool non_blocking_accept(socket_type s, state_type state, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec, socket_type& new_socket) { for (;;) { // Accept the waiting connection. new_socket = socket_ops::accept(s, addr, addrlen, ec); // Check if operation succeeded. if (new_socket != invalid_socket) return true; // Retry operation if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Operation failed. if (ec == boost::asio::error::would_block \|\| ec == boost::asio::error::try_again) { // Fall through to retry operation. } else if (ec == boost::asio::error::connection_aborted) { if (state & enable_connection_aborted) return true; // Fall through to retry operation. } #if defined(EPROTO) else if (ec.value() == EPROTO) { if (state & enable_connection_aborted) return true; // Fall through to retry operation. } #endif // defined(EPROTO) else return true; return false; } } #endif // defined(BOOST_ASIO_HAS_IOCP) template <typename SockLenType> inline int call_bind(SockLenType msghdr::, socket_type s, const socket_addr_type addr, std::size_t addrlen) { return ::bind(s, addr, (SockLenType)addrlen); } int bind(socket_type s, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return socket_error_retval; } int result = call_bind(&msghdr::msg_namelen, s, addr, addrlen); get_last_error(ec, result != 0); return result; } int close(socket_type s, state_type& state, bool destruction, boost::system::error_code& ec) { int result = 0; if (s != invalid_socket) { // We don't want the destructor to block, so set the socket to linger in // the background. If the user doesn't like this behaviour then they need // to explicitly close the socket. if (destruction && (state & user_set_linger)) { ::linger opt; opt.l_onoff = 0; opt.l_linger = 0; boost::system::error_code ignored_ec; socket_ops::setsockopt(s, state, SOL_SOCKET, SO_LINGER, &opt, sizeof(opt), ignored_ec); } #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) result = ::closesocket(s); #else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) result = ::close(s); #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) get_last_error(ec, result != 0); if (result != 0 && (ec == boost::asio::error::would_block \|\| ec == boost::asio::error::try_again)) { // According to UNIX Network Programming Vol. 1, it is possible for // close() to fail with EWOULDBLOCK under certain circumstances. What // isn't clear is the state of the descriptor after this error. The one // current OS where this behaviour is seen, Windows, says that the socket // remains open. Therefore we'll put the descriptor back into blocking // mode and have another attempt at closing it. #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) ioctl_arg_type arg = 0; ::ioctlsocket(s, FIONBIO, &arg); #else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) # if defined(__SYMBIAN32__) \|\| defined(__EMSCRIPTEN__) int flags = ::fcntl(s, F_GETFL, 0); if (flags >= 0) ::fcntl(s, F_SETFL, flags & ~O_NONBLOCK); # else // defined(__SYMBIAN32__) \|\| defined(__EMSCRIPTEN__) ioctl_arg_type arg = 0; ::ioctl(s, FIONBIO, &arg); # endif // defined(__SYMBIAN32__) \|\| defined(__EMSCRIPTEN__) #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) state &= ~non_blocking; #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) result = ::closesocket(s); #else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) result = ::close(s); #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) get_last_error(ec, result != 0); } } return result; } bool set_user_non_blocking(socket_type s, state_type& state, bool value, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return false; } #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) ioctl_arg_type arg = (value ? 1 : 0); int result = ::ioctlsocket(s, FIONBIO, &arg); get_last_error(ec, result < 0); #elif defined(__SYMBIAN32__) \|\| defined(__EMSCRIPTEN__) int result = ::fcntl(s, F_GETFL, 0); get_last_error(ec, result < 0); if (result >= 0) { int flag = (value ? (result \| O_NONBLOCK) : (result & ~O_NONBLOCK)); result = ::fcntl(s, F_SETFL, flag); get_last_error(ec, result < 0); } #else ioctl_arg_type arg = (value ? 1 : 0); int result = ::ioctl(s, FIONBIO, &arg); get_last_error(ec, result < 0); #endif if (result >= 0) { if (value) state \|= user_set_non_blocking; else { // Clearing the user-set non-blocking mode always overrides any // internally-set non-blocking flag. Any subsequent asynchronous // operations will need to re-enable non-blocking I/O. state &= ~(user_set_non_blocking \| internal_non_blocking); } return true; } return false; } bool set_internal_non_blocking(socket_type s, state_type& state, bool value, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return false; } if (!value && (state & user_set_non_blocking)) { // It does not make sense to clear the internal non-blocking flag if the // user still wants non-blocking behaviour. Return an error and let the // caller figure out whether to update the user-set non-blocking flag. ec = boost::asio::error::invalid_argument; return false; } #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) ioctl_arg_type arg = (value ? 1 : 0); int result = ::ioctlsocket(s, FIONBIO, &arg); get_last_error(ec, result < 0); #elif defined(__SYMBIAN32__) \|\| defined(__EMSCRIPTEN__) int result = ::fcntl(s, F_GETFL, 0); get_last_error(ec, result < 0); if (result >= 0) { int flag = (value ? (result \| O_NONBLOCK) : (result & ~O_NONBLOCK)); result = ::fcntl(s, F_SETFL, flag); get_last_error(ec, result < 0); } #else ioctl_arg_type arg = (value ? 1 : 0); int result = ::ioctl(s, FIONBIO, &arg); get_last_error(ec, result < 0); #endif if (result >= 0) { if (value) state \|= internal_non_blocking; else state &= ~internal_non_blocking; return true; } return false; } int shutdown(socket_type s, int what, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return socket_error_retval; } int result = ::shutdown(s, what); get_last_error(ec, result != 0); return result; } template <typename SockLenType> inline int call_connect(SockLenType msghdr::, socket_type s, const socket_addr_type addr, std::size_t addrlen) { return ::connect(s, addr, (SockLenType)addrlen); } int connect(socket_type s, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return socket_error_retval; } int result = call_connect(&msghdr::msg_namelen, s, addr, addrlen); get_last_error(ec, result != 0); #if defined(__linux__) if (result != 0 && ec == boost::asio::error::try_again) ec = boost::asio::error::no_buffer_space; #endif // defined(__linux__) return result; } void sync_connect(socket_type s, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec) { // Perform the connect operation. socket_ops::connect(s, addr, addrlen, ec); if (ec != boost::asio::error::in_progress && ec != boost::asio::error::would_block) { // The connect operation finished immediately. return; } // Wait for socket to become ready. if (socket_ops::poll_connect(s, -1, ec) < 0) return; // Get the error code from the connect operation. int connect_error = 0; size_t connect_error_len = sizeof(connect_error); if (socket_ops::getsockopt(s, 0, SOL_SOCKET, SO_ERROR, &connect_error, &connect_error_len, ec) == socket_error_retval) return; // Return the result of the connect operation. ec = boost::system::error_code(connect_error, boost::asio::error::get_system_category()); } #if defined(BOOST_ASIO_HAS_IOCP) void complete_iocp_connect(socket_type s, boost::system::error_code& ec) { // Map non-portable errors to their portable counterparts. switch (ec.value()) { case ERROR_CONNECTION_REFUSED: ec = boost::asio::error::connection_refused; break; case ERROR_NETWORK_UNREACHABLE: ec = boost::asio::error::network_unreachable; break; case ERROR_HOST_UNREACHABLE: ec = boost::asio::error::host_unreachable; break; case ERROR_SEM_TIMEOUT: ec = boost::asio::error::timed_out; break; default: break; } if (!ec) { // Need to set the SO_UPDATE_CONNECT_CONTEXT option so that getsockname // and getpeername will work on the connected socket. socket_ops::state_type state = 0; const int so_update_connect_context = 0x7010; socket_ops::setsockopt(s, state, SOL_SOCKET, so_update_connect_context, 0, 0, ec); } } #endif // defined(BOOST_ASIO_HAS_IOCP) bool non_blocking_connect(socket_type s, boost::system::error_code& ec) { // Check if the connect operation has finished. This is required since we may // get spurious readiness notifications from the reactor. #if defined(BOOST_ASIO_WINDOWS) \ \|\| defined(__CYGWIN__) \ \|\| defined(__SYMBIAN32__) fd_set write_fds; FD_ZERO(&write_fds); FD_SET(s, &write_fds); fd_set except_fds; FD_ZERO(&except_fds); FD_SET(s, &except_fds); timeval zero_timeout; zero_timeout.tv_sec = 0; zero_timeout.tv_usec = 0; int ready = ::select(s + 1, 0, &write_fds, &except_fds, &zero_timeout); #else // defined(BOOST_ASIO_WINDOWS) // \|\| defined(__CYGWIN__) // \|\| defined(__SYMBIAN32__) pollfd fds; fds.fd = s; fds.events = POLLOUT; fds.revents = 0; int ready = ::poll(&fds, 1, 0); #endif // defined(BOOST_ASIO_WINDOWS) // \|\| defined(__CYGWIN__) // \|\| defined(__SYMBIAN32__) if (ready == 0) { // The asynchronous connect operation is still in progress. return false; } // Get the error code from the connect operation. int connect_error = 0; size_t connect_error_len = sizeof(connect_error); if (socket_ops::getsockopt(s, 0, SOL_SOCKET, SO_ERROR, &connect_error, &connect_error_len, ec) == 0) { if (connect_error) { ec = boost::system::error_code(connect_error, boost::asio::error::get_system_category()); } else ec.assign(0, ec.category()); } return true; } int socketpair(int af, int type, int protocol, socket_type sv[2], boost::system::error_code& ec) { #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) (void)(af); (void)(type); (void)(protocol); (void)(sv); ec = boost::asio::error::operation_not_supported; return socket_error_retval; #else int result = ::socketpair(af, type, protocol, sv); get_last_error(ec, result != 0); return result; #endif } bool sockatmark(socket_type s, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return false; } #if defined(SIOCATMARK) ioctl_arg_type value = 0; # if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) int result = ::ioctlsocket(s, SIOCATMARK, &value); # else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) int result = ::ioctl(s, SIOCATMARK, &value); # endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) get_last_error(ec, result < 0); # if defined(ENOTTY) if (ec.value() == ENOTTY) ec = boost::asio::error::not_socket; # endif // defined(ENOTTY) #else // defined(SIOCATMARK) int value = ::sockatmark(s); get_last_error(ec, result < 0); #endif // defined(SIOCATMARK) return ec ? false : value != 0; } size_t available(socket_type s, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return 0; } ioctl_arg_type value = 0; #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) int result = ::ioctlsocket(s, FIONREAD, &value); #else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) int result = ::ioctl(s, FIONREAD, &value); #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) get_last_error(ec, result < 0); #if defined(ENOTTY) if (ec.value() == ENOTTY) ec = boost::asio::error::not_socket; #endif // defined(ENOTTY) return ec ? static_cast<size_t>(0) : static_cast<size_t>(value); } int listen(socket_type s, int backlog, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return socket_error_retval; } int result = ::listen(s, backlog); get_last_error(ec, result != 0); return result; } inline void init_buf_iov_base(void& base, void addr) { base = addr; } template <typename T> inline void init_buf_iov_base(T& base, void* addr) { base = static_cast<T>(addr); } #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) typedef WSABUF buf; #else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) typedef iovec buf; #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) void init_buf(buf& b, void* data, size_t size) { #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) b.buf = static_cast<char>(data); b.len = static_cast<u_long>(size); #else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) init_buf_iov_base(b.iov_base, data); b.iov_len = size; #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) } void init_buf(buf& b, const void data, size_t size) { #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) b.buf = static_cast<char>(const_cast<void>(data)); b.len = static_cast<u_long>(size); #else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) init_buf_iov_base(b.iov_base, const_cast<void>(data)); b.iov_len = size; #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) } inline void init_msghdr_msg_name(void& name, socket_addr_type* addr) { name = addr; } inline void init_msghdr_msg_name(void& name, const socket_addr_type addr) { name = const_cast<socket_addr_type>(addr); } template <typename T> inline void init_msghdr_msg_name(T& name, socket_addr_type addr) { name = reinterpret_cast<T>(addr); } template <typename T> inline void init_msghdr_msg_name(T& name, const socket_addr_type* addr) { name = reinterpret_cast<T>(const_cast<socket_addr_type>(addr)); } signed_size_type recv(socket_type s, buf bufs, size_t count, int flags, boost::system::error_code& ec) { #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) // Receive some data. DWORD recv_buf_count = static_cast<DWORD>(count); DWORD bytes_transferred = 0; DWORD recv_flags = flags; int result = ::WSARecv(s, bufs, recv_buf_count, &bytes_transferred, &recv_flags, 0, 0); get_last_error(ec, true); if (ec.value() == ERROR_NETNAME_DELETED) ec = boost::asio::error::connection_reset; else if (ec.value() == ERROR_PORT_UNREACHABLE) ec = boost::asio::error::connection_refused; else if (ec.value() == WSAEMSGSIZE \|\| ec.value() == ERROR_MORE_DATA) result = 0; if (result != 0) return socket_error_retval; ec.assign(0, ec.category()); return bytes_transferred; #else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) msghdr msg = msghdr(); msg.msg_iov = bufs; msg.msg_iovlen = static_cast<int>(count); signed_size_type result = ::recvmsg(s, &msg, flags); get_last_error(ec, result < 0); return result; #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) } signed_size_type recv1(socket_type s, void* data, size_t size, int flags, boost::system::error_code& ec) { #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) // Receive some data. WSABUF buf; buf.buf = const_cast<char>(static_cast<const char>(data)); buf.len = static_cast<ULONG>(size); DWORD bytes_transferred = 0; DWORD recv_flags = flags; int result = ::WSARecv(s, &buf, 1, &bytes_transferred, &recv_flags, 0, 0); get_last_error(ec, true); if (ec.value() == ERROR_NETNAME_DELETED) ec = boost::asio::error::connection_reset; else if (ec.value() == ERROR_PORT_UNREACHABLE) ec = boost::asio::error::connection_refused; else if (ec.value() == WSAEMSGSIZE \|\| ec.value() == ERROR_MORE_DATA) result = 0; if (result != 0) return socket_error_retval; ec.assign(0, ec.category()); return bytes_transferred; #else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) signed_size_type result = ::recv(s, static_cast<char>(data), size, flags); get_last_error(ec, result < 0); return result; #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) } size_t sync_recv(socket_type s, state_type state, buf bufs, size_t count, int flags, bool all_empty, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return 0; } // A request to read 0 bytes on a stream is a no-op. if (all_empty && (state & stream_oriented)) { ec.assign(0, ec.category()); return 0; } // Read some data. for (;;) { // Try to complete the operation without blocking. signed_size_type bytes = socket_ops::recv(s, bufs, count, flags, ec); // Check for EOF. if ((state & stream_oriented) && bytes == 0) { ec = boost::asio::error::eof; return 0; } // Check if operation succeeded. if (bytes >= 0) return bytes; // Operation failed. if ((state & user_set_non_blocking) \|\| (ec != boost::asio::error::would_block && ec != boost::asio::error::try_again)) return 0; // Wait for socket to become ready. if (socket_ops::poll_read(s, 0, -1, ec) < 0) return 0; } } size_t sync_recv1(socket_type s, state_type state, void* data, size_t size, int flags, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return 0; } // A request to read 0 bytes on a stream is a no-op. if (size == 0 && (state & stream_oriented)) { ec.assign(0, ec.category()); return 0; } // Read some data. for (;;) { // Try to complete the operation without blocking. signed_size_type bytes = socket_ops::recv1(s, data, size, flags, ec); // Check for EOF. if ((state & stream_oriented) && bytes == 0) { ec = boost::asio::error::eof; return 0; } // Check if operation succeeded. if (bytes >= 0) return bytes; // Operation failed. if ((state & user_set_non_blocking) \|\| (ec != boost::asio::error::would_block && ec != boost::asio::error::try_again)) return 0; // Wait for socket to become ready. if (socket_ops::poll_read(s, 0, -1, ec) < 0) return 0; } } #if defined(BOOST_ASIO_HAS_IOCP) void complete_iocp_recv(state_type state, const weak_cancel_token_type& cancel_token, bool all_empty, boost::system::error_code& ec, size_t bytes_transferred) { // Map non-portable errors to their portable counterparts. if (ec.value() == ERROR_NETNAME_DELETED) { if (cancel_token.expired()) ec = boost::asio::error::operation_aborted; else ec = boost::asio::error::connection_reset; } else if (ec.value() == ERROR_PORT_UNREACHABLE) { ec = boost::asio::error::connection_refused; } else if (ec.value() == WSAEMSGSIZE \|\| ec.value() == ERROR_MORE_DATA) { ec.assign(0, ec.category()); } // Check for connection closed. else if (!ec && bytes_transferred == 0 && (state & stream_oriented) != 0 && !all_empty) { ec = boost::asio::error::eof; } } #else // defined(BOOST_ASIO_HAS_IOCP) bool non_blocking_recv(socket_type s, buf* bufs, size_t count, int flags, bool is_stream, boost::system::error_code& ec, size_t& bytes_transferred) { for (;;) { // Read some data. signed_size_type bytes = socket_ops::recv(s, bufs, count, flags, ec); // Check for end of stream. if (is_stream && bytes == 0) { ec = boost::asio::error::eof; return true; } // Check if operation succeeded. if (bytes >= 0) { bytes_transferred = bytes; return true; } // Retry operation if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block \|\| ec == boost::asio::error::try_again) return false; // Operation failed. bytes_transferred = 0; return true; } } bool non_blocking_recv1(socket_type s, void* data, size_t size, int flags, bool is_stream, boost::system::error_code& ec, size_t& bytes_transferred) { for (;;) { // Read some data. signed_size_type bytes = socket_ops::recv1(s, data, size, flags, ec); // Check for end of stream. if (is_stream && bytes == 0) { ec = boost::asio::error::eof; return true; } // Check if operation succeeded. if (bytes >= 0) { bytes_transferred = bytes; return true; } // Retry operation if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block \|\| ec == boost::asio::error::try_again) return false; // Operation failed. bytes_transferred = 0; return true; } } #endif // defined(BOOST_ASIO_HAS_IOCP) signed_size_type recvfrom(socket_type s, buf* bufs, size_t count, int flags, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec) { #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) // Receive some data. DWORD recv_buf_count = static_cast<DWORD>(count); DWORD bytes_transferred = 0; DWORD recv_flags = flags; int tmp_addrlen = (int)addrlen; int result = ::WSARecvFrom(s, bufs, recv_buf_count, &bytes_transferred, &recv_flags, addr, &tmp_addrlen, 0, 0); get_last_error(ec, true); addrlen = (std::size_t)tmp_addrlen; if (ec.value() == ERROR_NETNAME_DELETED) ec = boost::asio::error::connection_reset; else if (ec.value() == ERROR_PORT_UNREACHABLE) ec = boost::asio::error::connection_refused; else if (ec.value() == WSAEMSGSIZE \|\| ec.value() == ERROR_MORE_DATA) result = 0; if (result != 0) return socket_error_retval; ec.assign(0, ec.category()); return bytes_transferred; #else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) msghdr msg = msghdr(); init_msghdr_msg_name(msg.msg_name, addr); msg.msg_namelen = static_cast<int>(addrlen); msg.msg_iov = bufs; msg.msg_iovlen = static_cast<int>(count); signed_size_type result = ::recvmsg(s, &msg, flags); get_last_error(ec, result < 0); addrlen = msg.msg_namelen; return result; #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) } template <typename SockLenType> inline signed_size_type call_recvfrom(SockLenType msghdr::, socket_type s, void data, size_t size, int flags, socket_addr_type* addr, std::size_t* addrlen) { SockLenType tmp_addrlen = addrlen ? (SockLenType)addrlen : 0; signed_size_type result = ::recvfrom(s, static_cast<char>(data), size, flags, addr, addrlen ? &tmp_addrlen : 0); if (addrlen) addrlen = (std::size_t)tmp_addrlen; return result; } signed_size_type recvfrom1(socket_type s, void data, size_t size, int flags, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec) { #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) // Receive some data. WSABUF buf; buf.buf = static_cast<char>(data); buf.len = static_cast<ULONG>(size); DWORD bytes_transferred = 0; DWORD recv_flags = flags; int tmp_addrlen = (int)addrlen; int result = ::WSARecvFrom(s, &buf, 1, &bytes_transferred, &recv_flags, addr, &tmp_addrlen, 0, 0); get_last_error(ec, true); addrlen = (std::size_t)tmp_addrlen; if (ec.value() == ERROR_NETNAME_DELETED) ec = boost::asio::error::connection_reset; else if (ec.value() == ERROR_PORT_UNREACHABLE) ec = boost::asio::error::connection_refused; else if (ec.value() == WSAEMSGSIZE \|\| ec.value() == ERROR_MORE_DATA) result = 0; if (result != 0) return socket_error_retval; ec.assign(0, ec.category()); return bytes_transferred; #else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) signed_size_type result = call_recvfrom(&msghdr::msg_namelen, s, data, size, flags, addr, addrlen); get_last_error(ec, result < 0); return result; #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) } size_t sync_recvfrom(socket_type s, state_type state, buf bufs, size_t count, int flags, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return 0; } // Read some data. for (;;) { // Try to complete the operation without blocking. signed_size_type bytes = socket_ops::recvfrom( s, bufs, count, flags, addr, addrlen, ec); // Check if operation succeeded. if (bytes >= 0) return bytes; // Operation failed. if ((state & user_set_non_blocking) \|\| (ec != boost::asio::error::would_block && ec != boost::asio::error::try_again)) return 0; // Wait for socket to become ready. if (socket_ops::poll_read(s, 0, -1, ec) < 0) return 0; } } size_t sync_recvfrom1(socket_type s, state_type state, void* data, size_t size, int flags, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return 0; } // Read some data. for (;;) { // Try to complete the operation without blocking. signed_size_type bytes = socket_ops::recvfrom1( s, data, size, flags, addr, addrlen, ec); // Check if operation succeeded. if (bytes >= 0) return bytes; // Operation failed. if ((state & user_set_non_blocking) \|\| (ec != boost::asio::error::would_block && ec != boost::asio::error::try_again)) return 0; // Wait for socket to become ready. if (socket_ops::poll_read(s, 0, -1, ec) < 0) return 0; } } #if defined(BOOST_ASIO_HAS_IOCP) void complete_iocp_recvfrom( const weak_cancel_token_type& cancel_token, boost::system::error_code& ec) { // Map non-portable errors to their portable counterparts. if (ec.value() == ERROR_NETNAME_DELETED) { if (cancel_token.expired()) ec = boost::asio::error::operation_aborted; else ec = boost::asio::error::connection_reset; } else if (ec.value() == ERROR_PORT_UNREACHABLE) { ec = boost::asio::error::connection_refused; } else if (ec.value() == WSAEMSGSIZE \|\| ec.value() == ERROR_MORE_DATA) { ec.assign(0, ec.category()); } } #else // defined(BOOST_ASIO_HAS_IOCP) bool non_blocking_recvfrom(socket_type s, buf* bufs, size_t count, int flags, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec, size_t& bytes_transferred) { for (;;) { // Read some data. signed_size_type bytes = socket_ops::recvfrom( s, bufs, count, flags, addr, addrlen, ec); // Check if operation succeeded. if (bytes >= 0) { bytes_transferred = bytes; return true; } // Retry operation if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block \|\| ec == boost::asio::error::try_again) return false; // Operation failed. bytes_transferred = 0; return true; } } bool non_blocking_recvfrom1(socket_type s, void* data, size_t size, int flags, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec, size_t& bytes_transferred) { for (;;) { // Read some data. signed_size_type bytes = socket_ops::recvfrom1( s, data, size, flags, addr, addrlen, ec); // Check if operation succeeded. if (bytes >= 0) { bytes_transferred = bytes; return true; } // Retry operation if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block \|\| ec == boost::asio::error::try_again) return false; // Operation failed. bytes_transferred = 0; return true; } } #endif // defined(BOOST_ASIO_HAS_IOCP) signed_size_type recvmsg(socket_type s, buf* bufs, size_t count, int in_flags, int& out_flags, boost::system::error_code& ec) { #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) out_flags = 0; return socket_ops::recv(s, bufs, count, in_flags, ec); #else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) msghdr msg = msghdr(); msg.msg_iov = bufs; msg.msg_iovlen = static_cast<int>(count); signed_size_type result = ::recvmsg(s, &msg, in_flags); get_last_error(ec, result < 0); if (result >= 0) out_flags = msg.msg_flags; else out_flags = 0; return result; #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) } size_t sync_recvmsg(socket_type s, state_type state, buf* bufs, size_t count, int in_flags, int& out_flags, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return 0; } // Read some data. for (;;) { // Try to complete the operation without blocking. signed_size_type bytes = socket_ops::recvmsg( s, bufs, count, in_flags, out_flags, ec); // Check if operation succeeded. if (bytes >= 0) return bytes; // Operation failed. if ((state & user_set_non_blocking) \|\| (ec != boost::asio::error::would_block && ec != boost::asio::error::try_again)) return 0; // Wait for socket to become ready. if (socket_ops::poll_read(s, 0, -1, ec) < 0) return 0; } } #if defined(BOOST_ASIO_HAS_IOCP) void complete_iocp_recvmsg( const weak_cancel_token_type& cancel_token, boost::system::error_code& ec) { // Map non-portable errors to their portable counterparts. if (ec.value() == ERROR_NETNAME_DELETED) { if (cancel_token.expired()) ec = boost::asio::error::operation_aborted; else ec = boost::asio::error::connection_reset; } else if (ec.value() == ERROR_PORT_UNREACHABLE) { ec = boost::asio::error::connection_refused; } else if (ec.value() == WSAEMSGSIZE \|\| ec.value() == ERROR_MORE_DATA) { ec.assign(0, ec.category()); } } #else // defined(BOOST_ASIO_HAS_IOCP) bool non_blocking_recvmsg(socket_type s, buf* bufs, size_t count, int in_flags, int& out_flags, boost::system::error_code& ec, size_t& bytes_transferred) { for (;;) { // Read some data. signed_size_type bytes = socket_ops::recvmsg( s, bufs, count, in_flags, out_flags, ec); // Check if operation succeeded. if (bytes >= 0) { bytes_transferred = bytes; return true; } // Retry operation if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block \|\| ec == boost::asio::error::try_again) return false; // Operation failed. bytes_transferred = 0; return true; } } #endif // defined(BOOST_ASIO_HAS_IOCP) signed_size_type send(socket_type s, const buf* bufs, size_t count, int flags, boost::system::error_code& ec) { #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) // Send the data. DWORD send_buf_count = static_cast<DWORD>(count); DWORD bytes_transferred = 0; DWORD send_flags = flags; int result = ::WSASend(s, const_cast<buf>(bufs), send_buf_count, &bytes_transferred, send_flags, 0, 0); get_last_error(ec, true); if (ec.value() == ERROR_NETNAME_DELETED) ec = boost::asio::error::connection_reset; else if (ec.value() == ERROR_PORT_UNREACHABLE) ec = boost::asio::error::connection_refused; if (result != 0) return socket_error_retval; ec.assign(0, ec.category()); return bytes_transferred; #else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) msghdr msg = msghdr(); msg.msg_iov = const_cast<buf>(bufs); msg.msg_iovlen = static_cast<int>(count); #if defined(BOOST_ASIO_HAS_MSG_NOSIGNAL) flags \|= MSG_NOSIGNAL; #endif // defined(BOOST_ASIO_HAS_MSG_NOSIGNAL) signed_size_type result = ::sendmsg(s, &msg, flags); get_last_error(ec, result < 0); return result; #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) } signed_size_type send1(socket_type s, const void* data, size_t size, int flags, boost::system::error_code& ec) { #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) // Send the data. WSABUF buf; buf.buf = const_cast<char>(static_cast<const char>(data)); buf.len = static_cast<ULONG>(size); DWORD bytes_transferred = 0; DWORD send_flags = flags; int result = ::WSASend(s, &buf, 1, &bytes_transferred, send_flags, 0, 0); get_last_error(ec, true); if (ec.value() == ERROR_NETNAME_DELETED) ec = boost::asio::error::connection_reset; else if (ec.value() == ERROR_PORT_UNREACHABLE) ec = boost::asio::error::connection_refused; if (result != 0) return socket_error_retval; ec.assign(0, ec.category()); return bytes_transferred; #else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) #if defined(BOOST_ASIO_HAS_MSG_NOSIGNAL) flags \|= MSG_NOSIGNAL; #endif // defined(BOOST_ASIO_HAS_MSG_NOSIGNAL) signed_size_type result = ::send(s, static_cast<const char>(data), size, flags); get_last_error(ec, result < 0); return result; #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) } size_t sync_send(socket_type s, state_type state, const buf bufs, size_t count, int flags, bool all_empty, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return 0; } // A request to write 0 bytes to a stream is a no-op. if (all_empty && (state & stream_oriented)) { ec.assign(0, ec.category()); return 0; } // Read some data. for (;;) { // Try to complete the operation without blocking. signed_size_type bytes = socket_ops::send(s, bufs, count, flags, ec); // Check if operation succeeded. if (bytes >= 0) return bytes; // Operation failed. if ((state & user_set_non_blocking) \|\| (ec != boost::asio::error::would_block && ec != boost::asio::error::try_again)) return 0; // Wait for socket to become ready. if (socket_ops::poll_write(s, 0, -1, ec) < 0) return 0; } } size_t sync_send1(socket_type s, state_type state, const void* data, size_t size, int flags, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return 0; } // A request to write 0 bytes to a stream is a no-op. if (size == 0 && (state & stream_oriented)) { ec.assign(0, ec.category()); return 0; } // Read some data. for (;;) { // Try to complete the operation without blocking. signed_size_type bytes = socket_ops::send1(s, data, size, flags, ec); // Check if operation succeeded. if (bytes >= 0) return bytes; // Operation failed. if ((state & user_set_non_blocking) \|\| (ec != boost::asio::error::would_block && ec != boost::asio::error::try_again)) return 0; // Wait for socket to become ready. if (socket_ops::poll_write(s, 0, -1, ec) < 0) return 0; } } #if defined(BOOST_ASIO_HAS_IOCP) void complete_iocp_send( const weak_cancel_token_type& cancel_token, boost::system::error_code& ec) { // Map non-portable errors to their portable counterparts. if (ec.value() == ERROR_NETNAME_DELETED) { if (cancel_token.expired()) ec = boost::asio::error::operation_aborted; else ec = boost::asio::error::connection_reset; } else if (ec.value() == ERROR_PORT_UNREACHABLE) { ec = boost::asio::error::connection_refused; } } #else // defined(BOOST_ASIO_HAS_IOCP) bool non_blocking_send(socket_type s, const buf* bufs, size_t count, int flags, boost::system::error_code& ec, size_t& bytes_transferred) { for (;;) { // Write some data. signed_size_type bytes = socket_ops::send(s, bufs, count, flags, ec); // Check if operation succeeded. if (bytes >= 0) { bytes_transferred = bytes; return true; } // Retry operation if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block \|\| ec == boost::asio::error::try_again) return false; // Operation failed. bytes_transferred = 0; return true; } } bool non_blocking_send1(socket_type s, const void* data, size_t size, int flags, boost::system::error_code& ec, size_t& bytes_transferred) { for (;;) { // Write some data. signed_size_type bytes = socket_ops::send1(s, data, size, flags, ec); // Check if operation succeeded. if (bytes >= 0) { bytes_transferred = bytes; return true; } // Retry operation if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block \|\| ec == boost::asio::error::try_again) return false; // Operation failed. bytes_transferred = 0; return true; } } #endif // defined(BOOST_ASIO_HAS_IOCP) signed_size_type sendto(socket_type s, const buf* bufs, size_t count, int flags, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec) { #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) // Send the data. DWORD send_buf_count = static_cast<DWORD>(count); DWORD bytes_transferred = 0; int result = ::WSASendTo(s, const_cast<buf>(bufs), send_buf_count, &bytes_transferred, flags, addr, static_cast<int>(addrlen), 0, 0); get_last_error(ec, true); if (ec.value() == ERROR_NETNAME_DELETED) ec = boost::asio::error::connection_reset; else if (ec.value() == ERROR_PORT_UNREACHABLE) ec = boost::asio::error::connection_refused; if (result != 0) return socket_error_retval; ec.assign(0, ec.category()); return bytes_transferred; #else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) msghdr msg = msghdr(); init_msghdr_msg_name(msg.msg_name, addr); msg.msg_namelen = static_cast<int>(addrlen); msg.msg_iov = const_cast<buf>(bufs); msg.msg_iovlen = static_cast<int>(count); #if defined(BOOST_ASIO_HAS_MSG_NOSIGNAL) flags \|= MSG_NOSIGNAL; #endif // defined(BOOST_ASIO_HAS_MSG_NOSIGNAL) signed_size_type result = ::sendmsg(s, &msg, flags); get_last_error(ec, result < 0); return result; #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) } template <typename SockLenType> inline signed_size_type call_sendto(SockLenType msghdr::, socket_type s, const void data, size_t size, int flags, const socket_addr_type* addr, std::size_t addrlen) { return ::sendto(s, static_cast<char>(const_cast<void>(data)), size, flags, addr, (SockLenType)addrlen); } signed_size_type sendto1(socket_type s, const void* data, size_t size, int flags, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec) { #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) // Send the data. WSABUF buf; buf.buf = const_cast<char>(static_cast<const char>(data)); buf.len = static_cast<ULONG>(size); DWORD bytes_transferred = 0; int result = ::WSASendTo(s, &buf, 1, &bytes_transferred, flags, addr, static_cast<int>(addrlen), 0, 0); get_last_error(ec, true); if (ec.value() == ERROR_NETNAME_DELETED) ec = boost::asio::error::connection_reset; else if (ec.value() == ERROR_PORT_UNREACHABLE) ec = boost::asio::error::connection_refused; if (result != 0) return socket_error_retval; ec.assign(0, ec.category()); return bytes_transferred; #else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) #if defined(BOOST_ASIO_HAS_MSG_NOSIGNAL) flags \|= MSG_NOSIGNAL; #endif // defined(BOOST_ASIO_HAS_MSG_NOSIGNAL) signed_size_type result = call_sendto(&msghdr::msg_namelen, s, data, size, flags, addr, addrlen); get_last_error(ec, result < 0); return result; #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) } size_t sync_sendto(socket_type s, state_type state, const buf* bufs, size_t count, int flags, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return 0; } // Write some data. for (;;) { // Try to complete the operation without blocking. signed_size_type bytes = socket_ops::sendto( s, bufs, count, flags, addr, addrlen, ec); // Check if operation succeeded. if (bytes >= 0) return bytes; // Operation failed. if ((state & user_set_non_blocking) \|\| (ec != boost::asio::error::would_block && ec != boost::asio::error::try_again)) return 0; // Wait for socket to become ready. if (socket_ops::poll_write(s, 0, -1, ec) < 0) return 0; } } size_t sync_sendto1(socket_type s, state_type state, const void* data, size_t size, int flags, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return 0; } // Write some data. for (;;) { // Try to complete the operation without blocking. signed_size_type bytes = socket_ops::sendto1( s, data, size, flags, addr, addrlen, ec); // Check if operation succeeded. if (bytes >= 0) return bytes; // Operation failed. if ((state & user_set_non_blocking) \|\| (ec != boost::asio::error::would_block && ec != boost::asio::error::try_again)) return 0; // Wait for socket to become ready. if (socket_ops::poll_write(s, 0, -1, ec) < 0) return 0; } } #if !defined(BOOST_ASIO_HAS_IOCP) bool non_blocking_sendto(socket_type s, const buf* bufs, size_t count, int flags, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec, size_t& bytes_transferred) { for (;;) { // Write some data. signed_size_type bytes = socket_ops::sendto( s, bufs, count, flags, addr, addrlen, ec); // Check if operation succeeded. if (bytes >= 0) { bytes_transferred = bytes; return true; } // Retry operation if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block \|\| ec == boost::asio::error::try_again) return false; // Operation failed. bytes_transferred = 0; return true; } } bool non_blocking_sendto1(socket_type s, const void* data, size_t size, int flags, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec, size_t& bytes_transferred) { for (;;) { // Write some data. signed_size_type bytes = socket_ops::sendto1( s, data, size, flags, addr, addrlen, ec); // Check if operation succeeded. if (bytes >= 0) { bytes_transferred = bytes; return true; } // Retry operation if interrupted by signal. if (ec == boost::asio::error::interrupted) continue; // Check if we need to run the operation again. if (ec == boost::asio::error::would_block \|\| ec == boost::asio::error::try_again) return false; // Operation failed. bytes_transferred = 0; return true; } } #endif // !defined(BOOST_ASIO_HAS_IOCP) socket_type socket(int af, int type, int protocol, boost::system::error_code& ec) { #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) socket_type s = ::WSASocketW(af, type, protocol, 0, 0, WSA_FLAG_OVERLAPPED); get_last_error(ec, s == invalid_socket); if (s == invalid_socket) return s; if (af == BOOST_ASIO_OS_DEF(AF_INET6)) { // Try to enable the POSIX default behaviour of having IPV6_V6ONLY set to // false. This will only succeed on Windows Vista and later versions of // Windows, where a dual-stack IPv4/v6 implementation is available. DWORD optval = 0; ::setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, reinterpret_cast<const char>(&optval), sizeof(optval)); } return s; #elif defined(__MACH__) && defined(__APPLE__) \|\| defined(__FreeBSD__) socket_type s = ::socket(af, type, protocol); get_last_error(ec, s < 0); int optval = 1; int result = ::setsockopt(s, SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval)); get_last_error(ec, result != 0); if (result != 0) { ::close(s); return invalid_socket; } return s; #else int s = ::socket(af, type, protocol); get_last_error(ec, s < 0); return s; #endif } template <typename SockLenType> inline int call_setsockopt(SockLenType msghdr::, socket_type s, int level, int optname, const void* optval, std::size_t optlen) { return ::setsockopt(s, level, optname, (const char)optval, (SockLenType)optlen); } int setsockopt(socket_type s, state_type& state, int level, int optname, const void optval, std::size_t optlen, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return socket_error_retval; } if (level == custom_socket_option_level && optname == always_fail_option) { ec = boost::asio::error::invalid_argument; return socket_error_retval; } if (level == custom_socket_option_level && optname == enable_connection_aborted_option) { if (optlen != sizeof(int)) { ec = boost::asio::error::invalid_argument; return socket_error_retval; } if (static_cast<const int>(optval)) state \|= enable_connection_aborted; else state &= ~enable_connection_aborted; ec.assign(0, ec.category()); return 0; } if (level == SOL_SOCKET && optname == SO_LINGER) state \|= user_set_linger; #if defined(__BORLANDC__) // Mysteriously, using the getsockopt and setsockopt functions directly with // Borland C++ results in incorrect values being set and read. The bug can be // worked around by using function addresses resolved with GetProcAddress. if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32")) { typedef int (WSAAPI sso_t)(SOCKET, int, int, const char, int); if (sso_t sso = (sso_t)::GetProcAddress(winsock_module, "setsockopt")) { int result = sso(s, level, optname, reinterpret_cast<const char>(optval), static_cast<int>(optlen)); get_last_error(ec, result != 0); return result; } } ec = boost::asio::error::fault; return socket_error_retval; #else // defined(__BORLANDC__) int result = call_setsockopt(&msghdr::msg_namelen, s, level, optname, optval, optlen); get_last_error(ec, result != 0); if (result == 0) { #if defined(__MACH__) && defined(__APPLE__) \ \|\| defined(__NetBSD__) \|\| defined(__FreeBSD__) \ \|\| defined(__OpenBSD__) \|\| defined(__QNX__) // To implement portable behaviour for SO_REUSEADDR with UDP sockets we // need to also set SO_REUSEPORT on BSD-based platforms. if ((state & datagram_oriented) && level == SOL_SOCKET && optname == SO_REUSEADDR) { call_setsockopt(&msghdr::msg_namelen, s, SOL_SOCKET, SO_REUSEPORT, optval, optlen); } #endif } return result; #endif // defined(__BORLANDC__) } template <typename SockLenType> inline int call_getsockopt(SockLenType msghdr::, socket_type s, int level, int optname, void* optval, std::size_t* optlen) { SockLenType tmp_optlen = (SockLenType)optlen; int result = ::getsockopt(s, level, optname, (char)optval, &tmp_optlen); optlen = (std::size_t)tmp_optlen; return result; } int getsockopt(socket_type s, state_type state, int level, int optname, void optval, size_t* optlen, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return socket_error_retval; } if (level == custom_socket_option_level && optname == always_fail_option) { ec = boost::asio::error::invalid_argument; return socket_error_retval; } if (level == custom_socket_option_level && optname == enable_connection_aborted_option) { if (optlen != sizeof(int)) { ec = boost::asio::error::invalid_argument; return socket_error_retval; } static_cast<int>(optval) = (state & enable_connection_aborted) ? 1 : 0; ec.assign(0, ec.category()); return 0; } #if defined(__BORLANDC__) // Mysteriously, using the getsockopt and setsockopt functions directly with // Borland C++ results in incorrect values being set and read. The bug can be // worked around by using function addresses resolved with GetProcAddress. if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32")) { typedef int (WSAAPI gso_t)(SOCKET, int, int, char, int); if (gso_t gso = (gso_t)::GetProcAddress(winsock_module, "getsockopt")) { int tmp_optlen = static_cast<int>(optlen); int result = gso(s, level, optname, reinterpret_cast<char>(optval), &tmp_optlen); get_last_error(ec, result != 0); optlen = static_cast<size_t>(tmp_optlen); if (result != 0 && level == IPPROTO_IPV6 && optname == IPV6_V6ONLY && ec.value() == WSAENOPROTOOPT && optlen == sizeof(DWORD)) { // Dual-stack IPv4/v6 sockets, and the IPV6_V6ONLY socket option, are // only supported on Windows Vista and later. To simplify program logic // we will fake success of getting this option and specify that the // value is non-zero (i.e. true). This corresponds to the behavior of // IPv6 sockets on Windows platforms pre-Vista. static_cast<DWORD>(optval) = 1; ec.assign(0, ec.category()); } return result; } } ec = boost::asio::error::fault; return socket_error_retval; #elif defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) int result = call_getsockopt(&msghdr::msg_namelen, s, level, optname, optval, optlen); get_last_error(ec, result != 0); if (result != 0 && level == IPPROTO_IPV6 && optname == IPV6_V6ONLY && ec.value() == WSAENOPROTOOPT && optlen == sizeof(DWORD)) { // Dual-stack IPv4/v6 sockets, and the IPV6_V6ONLY socket option, are only // supported on Windows Vista and later. To simplify program logic we will // fake success of getting this option and specify that the value is // non-zero (i.e. true). This corresponds to the behavior of IPv6 sockets // on Windows platforms pre-Vista. static_cast<DWORD>(optval) = 1; ec.assign(0, ec.category()); } return result; #else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) int result = call_getsockopt(&msghdr::msg_namelen, s, level, optname, optval, optlen); get_last_error(ec, result != 0); #if defined(__linux__) if (result == 0 && level == SOL_SOCKET && optlen == sizeof(int) && (optname == SO_SNDBUF \|\| optname == SO_RCVBUF)) { // On Linux, setting SO_SNDBUF or SO_RCVBUF to N actually causes the kernel // to set the buffer size to N2. Linux puts additional stuff into the // buffers so that only about half is actually available to the application. // The retrieved value is divided by 2 here to make it appear as though the // correct value has been set. static_cast<int>(optval) /= 2; } #endif // defined(__linux__) return result; #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) } template <typename SockLenType> inline int call_getpeername(SockLenType msghdr::, socket_type s, socket_addr_type* addr, std::size_t* addrlen) { SockLenType tmp_addrlen = (SockLenType)addrlen; int result = ::getpeername(s, addr, &tmp_addrlen); addrlen = (std::size_t)tmp_addrlen; return result; } int getpeername(socket_type s, socket_addr_type* addr, std::size_t* addrlen, bool cached, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return socket_error_retval; } #if defined(BOOST_ASIO_WINDOWS) && !defined(BOOST_ASIO_WINDOWS_APP) \ \|\| defined(__CYGWIN__) if (cached) { // Check if socket is still connected. DWORD connect_time = 0; size_t connect_time_len = sizeof(connect_time); if (socket_ops::getsockopt(s, 0, SOL_SOCKET, SO_CONNECT_TIME, &connect_time, &connect_time_len, ec) == socket_error_retval) { return socket_error_retval; } if (connect_time == 0xFFFFFFFF) { ec = boost::asio::error::not_connected; return socket_error_retval; } // The cached value is still valid. ec.assign(0, ec.category()); return 0; } #else // defined(BOOST_ASIO_WINDOWS) && !defined(BOOST_ASIO_WINDOWS_APP) // \|\| defined(__CYGWIN__) (void)cached; #endif // defined(BOOST_ASIO_WINDOWS) && !defined(BOOST_ASIO_WINDOWS_APP) // \|\| defined(__CYGWIN__) int result = call_getpeername(&msghdr::msg_namelen, s, addr, addrlen); get_last_error(ec, result != 0); return result; } template <typename SockLenType> inline int call_getsockname(SockLenType msghdr::, socket_type s, socket_addr_type addr, std::size_t* addrlen) { SockLenType tmp_addrlen = (SockLenType)addrlen; int result = ::getsockname(s, addr, &tmp_addrlen); addrlen = (std::size_t)tmp_addrlen; return result; } int getsockname(socket_type s, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return socket_error_retval; } int result = call_getsockname(&msghdr::msg_namelen, s, addr, addrlen); get_last_error(ec, result != 0); return result; } int ioctl(socket_type s, state_type& state, int cmd, ioctl_arg_type* arg, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return socket_error_retval; } #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) int result = ::ioctlsocket(s, cmd, arg); #elif defined(__MACH__) && defined(__APPLE__) \ \|\| defined(__NetBSD__) \|\| defined(__FreeBSD__) \|\| defined(__OpenBSD__) int result = ::ioctl(s, static_cast<unsigned int>(cmd), arg); #else int result = ::ioctl(s, cmd, arg); #endif get_last_error(ec, result < 0); if (result >= 0) { // When updating the non-blocking mode we always perform the ioctl syscall, // even if the flags would otherwise indicate that the socket is already in // the correct state. This ensures that the underlying socket is put into // the state that has been requested by the user. If the ioctl syscall was // successful then we need to update the flags to match. if (cmd == static_cast<int>(FIONBIO)) { if (arg) { state \|= user_set_non_blocking; } else { // Clearing the non-blocking mode always overrides any internally-set // non-blocking flag. Any subsequent asynchronous operations will need // to re-enable non-blocking I/O. state &= ~(user_set_non_blocking \| internal_non_blocking); } } } return result; } int select(int nfds, fd_set readfds, fd_set* writefds, fd_set* exceptfds, timeval* timeout, boost::system::error_code& ec) { #if defined(__EMSCRIPTEN__) exceptfds = 0; #endif // defined(__EMSCRIPTEN__) #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) if (!readfds && !writefds && !exceptfds && timeout) { DWORD milliseconds = timeout->tv_sec * 1000 + timeout->tv_usec / 1000; if (milliseconds == 0) milliseconds = 1; // Force context switch. ::Sleep(milliseconds); ec.assign(0, ec.category()); return 0; } // The select() call allows timeout values measured in microseconds, but the // system clock (as wrapped by boost::posix_time::microsec_clock) typically // has a resolution of 10 milliseconds. This can lead to a spinning select // reactor, meaning increased CPU usage, when waiting for the earliest // scheduled timeout if it's less than 10 milliseconds away. To avoid a tight // spin we'll use a minimum timeout of 1 millisecond. if (timeout && timeout->tv_sec == 0 && timeout->tv_usec > 0 && timeout->tv_usec < 1000) timeout->tv_usec = 1000; #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) #if defined(__hpux) && defined(__SELECT) timespec ts; ts.tv_sec = timeout ? timeout->tv_sec : 0; ts.tv_nsec = timeout ? timeout->tv_usec * 1000 : 0; int result = ::pselect(nfds, readfds, writefds, exceptfds, timeout ? &ts : 0, 0); #else int result = ::select(nfds, readfds, writefds, exceptfds, timeout); #endif get_last_error(ec, result < 0); return result; } int poll_read(socket_type s, state_type state, int msec, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return socket_error_retval; } #if defined(BOOST_ASIO_WINDOWS) \ \|\| defined(__CYGWIN__) \ \|\| defined(__SYMBIAN32__) fd_set fds; FD_ZERO(&fds); FD_SET(s, &fds); timeval timeout_obj; timeval* timeout; if (state & user_set_non_blocking) { timeout_obj.tv_sec = 0; timeout_obj.tv_usec = 0; timeout = &timeout_obj; } else if (msec >= 0) { timeout_obj.tv_sec = msec / 1000; timeout_obj.tv_usec = (msec % 1000) * 1000; timeout = &timeout_obj; } else timeout = 0; int result = ::select(s + 1, &fds, 0, 0, timeout); get_last_error(ec, result < 0); #else // defined(BOOST_ASIO_WINDOWS) // \|\| defined(__CYGWIN__) // \|\| defined(__SYMBIAN32__) pollfd fds; fds.fd = s; fds.events = POLLIN; fds.revents = 0; int timeout = (state & user_set_non_blocking) ? 0 : msec; int result = ::poll(&fds, 1, timeout); get_last_error(ec, result < 0); #endif // defined(BOOST_ASIO_WINDOWS) // \|\| defined(__CYGWIN__) // \|\| defined(__SYMBIAN32__) if (result == 0) if (state & user_set_non_blocking) ec = boost::asio::error::would_block; return result; } int poll_write(socket_type s, state_type state, int msec, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return socket_error_retval; } #if defined(BOOST_ASIO_WINDOWS) \ \|\| defined(__CYGWIN__) \ \|\| defined(__SYMBIAN32__) fd_set fds; FD_ZERO(&fds); FD_SET(s, &fds); timeval timeout_obj; timeval* timeout; if (state & user_set_non_blocking) { timeout_obj.tv_sec = 0; timeout_obj.tv_usec = 0; timeout = &timeout_obj; } else if (msec >= 0) { timeout_obj.tv_sec = msec / 1000; timeout_obj.tv_usec = (msec % 1000) * 1000; timeout = &timeout_obj; } else timeout = 0; int result = ::select(s + 1, 0, &fds, 0, timeout); get_last_error(ec, result < 0); #else // defined(BOOST_ASIO_WINDOWS) // \|\| defined(__CYGWIN__) // \|\| defined(__SYMBIAN32__) pollfd fds; fds.fd = s; fds.events = POLLOUT; fds.revents = 0; int timeout = (state & user_set_non_blocking) ? 0 : msec; int result = ::poll(&fds, 1, timeout); get_last_error(ec, result < 0); #endif // defined(BOOST_ASIO_WINDOWS) // \|\| defined(__CYGWIN__) // \|\| defined(__SYMBIAN32__) if (result == 0) if (state & user_set_non_blocking) ec = boost::asio::error::would_block; return result; } int poll_error(socket_type s, state_type state, int msec, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return socket_error_retval; } #if defined(BOOST_ASIO_WINDOWS) \ \|\| defined(__CYGWIN__) \ \|\| defined(__SYMBIAN32__) fd_set fds; FD_ZERO(&fds); FD_SET(s, &fds); timeval timeout_obj; timeval* timeout; if (state & user_set_non_blocking) { timeout_obj.tv_sec = 0; timeout_obj.tv_usec = 0; timeout = &timeout_obj; } else if (msec >= 0) { timeout_obj.tv_sec = msec / 1000; timeout_obj.tv_usec = (msec % 1000) * 1000; timeout = &timeout_obj; } else timeout = 0; int result = ::select(s + 1, 0, 0, &fds, timeout); get_last_error(ec, result < 0); #else // defined(BOOST_ASIO_WINDOWS) // \|\| defined(__CYGWIN__) // \|\| defined(__SYMBIAN32__) pollfd fds; fds.fd = s; fds.events = POLLPRI \| POLLERR \| POLLHUP; fds.revents = 0; int timeout = (state & user_set_non_blocking) ? 0 : msec; int result = ::poll(&fds, 1, timeout); get_last_error(ec, result < 0); #endif // defined(BOOST_ASIO_WINDOWS) // \|\| defined(__CYGWIN__) // \|\| defined(__SYMBIAN32__) if (result == 0) if (state & user_set_non_blocking) ec = boost::asio::error::would_block; return result; } int poll_connect(socket_type s, int msec, boost::system::error_code& ec) { if (s == invalid_socket) { ec = boost::asio::error::bad_descriptor; return socket_error_retval; } #if defined(BOOST_ASIO_WINDOWS) \ \|\| defined(__CYGWIN__) \ \|\| defined(__SYMBIAN32__) fd_set write_fds; FD_ZERO(&write_fds); FD_SET(s, &write_fds); fd_set except_fds; FD_ZERO(&except_fds); FD_SET(s, &except_fds); timeval timeout_obj; timeval* timeout; if (msec >= 0) { timeout_obj.tv_sec = msec / 1000; timeout_obj.tv_usec = (msec % 1000) * 1000; timeout = &timeout_obj; } else timeout = 0; int result = ::select(s + 1, 0, &write_fds, &except_fds, timeout); get_last_error(ec, result < 0); return result; #else // defined(BOOST_ASIO_WINDOWS) // \|\| defined(__CYGWIN__) // \|\| defined(__SYMBIAN32__) pollfd fds; fds.fd = s; fds.events = POLLOUT; fds.revents = 0; int result = ::poll(&fds, 1, msec); get_last_error(ec, result < 0); return result; #endif // defined(BOOST_ASIO_WINDOWS) // \|\| defined(__CYGWIN__) // \|\| defined(__SYMBIAN32__) } #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) const char* inet_ntop(int af, const void* src, char* dest, size_t length, unsigned long scope_id, boost::system::error_code& ec) { clear_last_error(); #if defined(BOOST_ASIO_WINDOWS_RUNTIME) using namespace std; // For sprintf. const unsigned char* bytes = static_cast<const unsigned char>(src); if (af == BOOST_ASIO_OS_DEF(AF_INET)) { sprintf_s(dest, length, "%u.%u.%u.%u", bytes[0], bytes[1], bytes[2], bytes[3]); return dest; } else if (af == BOOST_ASIO_OS_DEF(AF_INET6)) { size_t n = 0, b = 0, z = 0; while (n < length && b < 16) { if (bytes[b] == 0 && bytes[b + 1] == 0 && z == 0) { do b += 2; while (b < 16 && bytes[b] == 0 && bytes[b + 1] == 0); n += sprintf_s(dest + n, length - n, ":%s", b < 16 ? "" : ":"), ++z; } else { n += sprintf_s(dest + n, length - n, "%s%x", b ? ":" : "", (static_cast<u_long_type>(bytes[b]) << 8) \| bytes[b + 1]); b += 2; } } if (scope_id) n += sprintf_s(dest + n, length - n, "%%%lu", scope_id); return dest; } else { ec = boost::asio::error::address_family_not_supported; return 0; } #elif defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) using namespace std; // For memcpy. if (af != BOOST_ASIO_OS_DEF(AF_INET) && af != BOOST_ASIO_OS_DEF(AF_INET6)) { ec = boost::asio::error::address_family_not_supported; return 0; } union { socket_addr_type base; sockaddr_storage_type storage; sockaddr_in4_type v4; sockaddr_in6_type v6; } address; DWORD address_length; if (af == BOOST_ASIO_OS_DEF(AF_INET)) { address_length = sizeof(sockaddr_in4_type); address.v4.sin_family = BOOST_ASIO_OS_DEF(AF_INET); address.v4.sin_port = 0; memcpy(&address.v4.sin_addr, src, sizeof(in4_addr_type)); } else // AF_INET6 { address_length = sizeof(sockaddr_in6_type); address.v6.sin6_family = BOOST_ASIO_OS_DEF(AF_INET6); address.v6.sin6_port = 0; address.v6.sin6_flowinfo = 0; address.v6.sin6_scope_id = scope_id; memcpy(&address.v6.sin6_addr, src, sizeof(in6_addr_type)); } DWORD string_length = static_cast<DWORD>(length); #if defined(BOOST_NO_ANSI_APIS) \|\| (defined(_MSC_VER) && (_MSC_VER >= 1800)) LPWSTR string_buffer = (LPWSTR)_alloca(length sizeof(WCHAR)); int result = ::WSAAddressToStringW(&address.base, address_length, 0, string_buffer, &string_length); get_last_error(ec, true); ::WideCharToMultiByte(CP_ACP, 0, string_buffer, -1, dest, static_cast<int>(length), 0, 0); #else int result = ::WSAAddressToStringA(&address.base, address_length, 0, dest, &string_length); get_last_error(ec, true); #endif // Windows may set error code on success. if (result != socket_error_retval) ec.assign(0, ec.category()); // Windows may not set an error code on failure. else if (result == socket_error_retval && !ec) ec = boost::asio::error::invalid_argument; return result == socket_error_retval ? 0 : dest; #else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) const char* result = ::inet_ntop(af, src, dest, static_cast<int>(length)); get_last_error(ec, true); if (result == 0 && !ec) ec = boost::asio::error::invalid_argument; if (result != 0 && af == BOOST_ASIO_OS_DEF(AF_INET6) && scope_id != 0) { using namespace std; // For strcat and sprintf. char if_name[(IF_NAMESIZE > 21 ? IF_NAMESIZE : 21) + 1] = "%"; const in6_addr_type* ipv6_address = static_cast<const in6_addr_type>(src); bool is_link_local = ((ipv6_address->s6_addr[0] == 0xfe) && ((ipv6_address->s6_addr[1] & 0xc0) == 0x80)); bool is_multicast_link_local = ((ipv6_address->s6_addr[0] == 0xff) && ((ipv6_address->s6_addr[1] & 0x0f) == 0x02)); if ((!is_link_local && !is_multicast_link_local) \|\| if_indextoname(static_cast<unsigned>(scope_id), if_name + 1) == 0) sprintf(if_name + 1, "%lu", scope_id); strcat(dest, if_name); } return result; #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) } int inet_pton(int af, const char src, void* dest, unsigned long* scope_id, boost::system::error_code& ec) { clear_last_error(); #if defined(BOOST_ASIO_WINDOWS_RUNTIME) using namespace std; // For sscanf. unsigned char* bytes = static_cast<unsigned char>(dest); if (af == BOOST_ASIO_OS_DEF(AF_INET)) { unsigned int b0, b1, b2, b3; if (sscanf_s(src, "%u.%u.%u.%u", &b0, &b1, &b2, &b3) != 4) { ec = boost::asio::error::invalid_argument; return -1; } if (b0 > 255 \|\| b1 > 255 \|\| b2 > 255 \|\| b3 > 255) { ec = boost::asio::error::invalid_argument; return -1; } bytes[0] = static_cast<unsigned char>(b0); bytes[1] = static_cast<unsigned char>(b1); bytes[2] = static_cast<unsigned char>(b2); bytes[3] = static_cast<unsigned char>(b3); ec.assign(0, ec.category()); return 1; } else if (af == BOOST_ASIO_OS_DEF(AF_INET6)) { unsigned char bytes = static_cast<unsigned char>(dest); std::memset(bytes, 0, 16); unsigned char back_bytes[16] = { 0 }; int num_front_bytes = 0, num_back_bytes = 0; const char p = src; enum { fword, fcolon, bword, scope, done } state = fword; unsigned long current_word = 0; while (state != done) { if (current_word > 0xFFFF) { ec = boost::asio::error::invalid_argument; return -1; } switch (state) { case fword: if (p >= '0' && p <= '9') current_word = current_word * 16 + p++ - '0'; else if (p >= 'a' && p <= 'f') current_word = current_word 16 + p++ - 'a' + 10; else if (p >= 'A' && p <= 'F') current_word = current_word 16 + p++ - 'A' + 10; else { if (num_front_bytes == 16) { ec = boost::asio::error::invalid_argument; return -1; } bytes[num_front_bytes++] = (current_word >> 8) & 0xFF; bytes[num_front_bytes++] = current_word & 0xFF; current_word = 0; if (p == ':') state = fcolon, ++p; else if (p == '%') state = scope, ++p; else if (p == 0) state = done; else { ec = boost::asio::error::invalid_argument; return -1; } } break; case fcolon: if (p == ':') state = bword, ++p; else state = fword; break; case bword: if (p >= '0' && p <= '9') current_word = current_word 16 + p++ - '0'; else if (p >= 'a' && p <= 'f') current_word = current_word 16 + p++ - 'a' + 10; else if (p >= 'A' && p <= 'F') current_word = current_word 16 + p++ - 'A' + 10; else { if (num_front_bytes + num_back_bytes == 16) { ec = boost::asio::error::invalid_argument; return -1; } back_bytes[num_back_bytes++] = (current_word >> 8) & 0xFF; back_bytes[num_back_bytes++] = current_word & 0xFF; current_word = 0; if (p == ':') state = bword, ++p; else if (p == '%') state = scope, ++p; else if (p == 0) state = done; else { ec = boost::asio::error::invalid_argument; return -1; } } break; case scope: if (p >= '0' && p <= '9') current_word = current_word * 10 + p++ - '0'; else if (p == 0) scope_id = current_word, state = done; else { ec = boost::asio::error::invalid_argument; return -1; } break; default: break; } } for (int i = 0; i < num_back_bytes; ++i) bytes[16 - num_back_bytes + i] = back_bytes[i]; ec.assign(0, ec.category()); return 1; } else { ec = boost::asio::error::address_family_not_supported; return -1; } #elif defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) using namespace std; // For memcpy and strcmp. if (af != BOOST_ASIO_OS_DEF(AF_INET) && af != BOOST_ASIO_OS_DEF(AF_INET6)) { ec = boost::asio::error::address_family_not_supported; return -1; } union { socket_addr_type base; sockaddr_storage_type storage; sockaddr_in4_type v4; sockaddr_in6_type v6; } address; int address_length = sizeof(sockaddr_storage_type); #if defined(BOOST_NO_ANSI_APIS) \|\| (defined(_MSC_VER) && (_MSC_VER >= 1800)) int num_wide_chars = static_cast<int>(strlen(src)) + 1; LPWSTR wide_buffer = (LPWSTR)_alloca(num_wide_chars sizeof(WCHAR)); ::MultiByteToWideChar(CP_ACP, 0, src, -1, wide_buffer, num_wide_chars); int result = ::WSAStringToAddressW(wide_buffer, af, 0, &address.base, &address_length); get_last_error(ec, true); #else int result = ::WSAStringToAddressA(const_cast<char>(src), af, 0, &address.base, &address_length); get_last_error(ec, true); #endif if (af == BOOST_ASIO_OS_DEF(AF_INET)) { if (result != socket_error_retval) { memcpy(dest, &address.v4.sin_addr, sizeof(in4_addr_type)); ec.assign(0, ec.category()); } else if (strcmp(src, "255.255.255.255") == 0) { static_cast<in4_addr_type>(dest)->s_addr = INADDR_NONE; ec.assign(0, ec.category()); } } else // AF_INET6 { if (result != socket_error_retval) { memcpy(dest, &address.v6.sin6_addr, sizeof(in6_addr_type)); if (scope_id) scope_id = address.v6.sin6_scope_id; ec.assign(0, ec.category()); } } // Windows may not set an error code on failure. if (result == socket_error_retval && !ec) ec = boost::asio::error::invalid_argument; if (result != socket_error_retval) ec.assign(0, ec.category()); return result == socket_error_retval ? -1 : 1; #else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) using namespace std; // For strchr, memcpy and atoi. // On some platforms, inet_pton fails if an address string contains a scope // id. Detect and remove the scope id before passing the string to inet_pton. const bool is_v6 = (af == BOOST_ASIO_OS_DEF(AF_INET6)); const char if_name = is_v6 ? strchr(src, '%') : 0; char src_buf[max_addr_v6_str_len + 1]; const char* src_ptr = src; if (if_name != 0) { if (if_name - src > max_addr_v6_str_len) { ec = boost::asio::error::invalid_argument; return 0; } memcpy(src_buf, src, if_name - src); src_buf[if_name - src] = 0; src_ptr = src_buf; } int result = ::inet_pton(af, src_ptr, dest); get_last_error(ec, true); if (result <= 0 && !ec) ec = boost::asio::error::invalid_argument; if (result > 0 && is_v6 && scope_id) { using namespace std; // For strchr and atoi. scope_id = 0; if (if_name != 0) { in6_addr_type ipv6_address = static_cast<in6_addr_type>(dest); bool is_link_local = ((ipv6_address->s6_addr[0] == 0xfe) && ((ipv6_address->s6_addr[1] & 0xc0) == 0x80)); bool is_multicast_link_local = ((ipv6_address->s6_addr[0] == 0xff) && ((ipv6_address->s6_addr[1] & 0x0f) == 0x02)); if (is_link_local \|\| is_multicast_link_local) scope_id = if_nametoindex(if_name + 1); if (scope_id == 0) scope_id = atoi(if_name + 1); } } return result; #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) } int gethostname(char* name, int namelen, boost::system::error_code& ec) { #if defined(BOOST_ASIO_WINDOWS_RUNTIME) try { using namespace Windows::Foundation::Collections; using namespace Windows::Networking; using namespace Windows::Networking::Connectivity; IVectorView<HostName^>^ hostnames = NetworkInformation::GetHostNames(); for (unsigned i = 0; i < hostnames->Size; ++i) { HostName^ hostname = hostnames->GetAt(i); if (hostname->Type == HostNameType::DomainName) { std::wstring_convert<std::codecvt_utf8<wchar_t>> converter; std::string raw_name = converter.to_bytes(hostname->RawName->Data()); if (namelen > 0 && raw_name.size() < static_cast<std::size_t>(namelen)) { strcpy_s(name, namelen, raw_name.c_str()); return 0; } } } return -1; } catch (Platform::Exception^ e) { ec = boost::system::error_code(e->HResult, boost::system::system_category()); return -1; } #else // defined(BOOST_ASIO_WINDOWS_RUNTIME) int result = ::gethostname(name, namelen); get_last_error(ec, result != 0); return result; #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) } #if !defined(BOOST_ASIO_WINDOWS_RUNTIME) #if !defined(BOOST_ASIO_HAS_GETADDRINFO) // The following functions are only needed for emulation of getaddrinfo and // getnameinfo. inline boost::system::error_code translate_netdb_error(int error) { switch (error) { case 0: return boost::system::error_code(); case HOST_NOT_FOUND: return boost::asio::error::host_not_found; case TRY_AGAIN: return boost::asio::error::host_not_found_try_again; case NO_RECOVERY: return boost::asio::error::no_recovery; case NO_DATA: return boost::asio::error::no_data; default: BOOST_ASIO_ASSERT(false); return boost::asio::error::invalid_argument; } } inline hostent* gethostbyaddr(const char* addr, int length, int af, hostent* result, char* buffer, int buflength, boost::system::error_code& ec) { #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) (void)(buffer); (void)(buflength); hostent* retval = ::gethostbyaddr(addr, length, af); get_last_error(ec, !retval); if (!retval) return 0; result = retval; return retval; #elif defined(__sun) \|\| defined(__QNX__) int error = 0; hostent* retval = ::gethostbyaddr_r(addr, length, af, result, buffer, buflength, &error); get_last_error(ec, !retval); if (error) ec = translate_netdb_error(error); return retval; #elif defined(__MACH__) && defined(__APPLE__) (void)(buffer); (void)(buflength); int error = 0; hostent* retval = ::getipnodebyaddr(addr, length, af, &error); get_last_error(ec, !retval); if (error) ec = translate_netdb_error(error); if (!retval) return 0; result = retval; return retval; #else hostent* retval = 0; int error = 0; clear_last_error(); ::gethostbyaddr_r(addr, length, af, result, buffer, buflength, &retval, &error); get_last_error(ec, true); if (error) ec = translate_netdb_error(error); return retval; #endif } inline hostent* gethostbyname(const char* name, int af, struct hostent* result, char* buffer, int buflength, int ai_flags, boost::system::error_code& ec) { #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) (void)(buffer); (void)(buflength); (void)(ai_flags); if (af != BOOST_ASIO_OS_DEF(AF_INET)) { ec = boost::asio::error::address_family_not_supported; return 0; } hostent* retval = ::gethostbyname(name); get_last_error(ec, !retval); if (!retval) return 0; result = retval; return result; #elif defined(__sun) \|\| defined(__QNX__) (void)(ai_flags); if (af != BOOST_ASIO_OS_DEF(AF_INET)) { ec = boost::asio::error::address_family_not_supported; return 0; } int error = 0; hostent* retval = ::gethostbyname_r(name, result, buffer, buflength, &error); get_last_error(ec, !retval); if (error) ec = translate_netdb_error(error); return retval; #elif defined(__MACH__) && defined(__APPLE__) (void)(buffer); (void)(buflength); int error = 0; hostent* retval = ::getipnodebyname(name, af, ai_flags, &error); get_last_error(ec, !retval); if (error) ec = translate_netdb_error(error); if (!retval) return 0; result = retval; return retval; #else (void)(ai_flags); if (af != BOOST_ASIO_OS_DEF(AF_INET)) { ec = boost::asio::error::address_family_not_supported; return 0; } hostent* retval = 0; int error = 0; clear_last_error(); ::gethostbyname_r(name, result, buffer, buflength, &retval, &error); get_last_error(ec, true); if (error) ec = translate_netdb_error(error); return retval; #endif } inline void freehostent(hostent* h) { #if defined(__MACH__) && defined(__APPLE__) if (h) ::freehostent(h); #else (void)(h); #endif } // Emulation of getaddrinfo based on implementation in: // Stevens, W. R., UNIX Network Programming Vol. 1, 2nd Ed., Prentice-Hall 1998. struct gai_search { const char* host; int family; }; inline int gai_nsearch(const char* host, const addrinfo_type* hints, gai_search (&search)[2]) { int search_count = 0; if (host == 0 \|\| host[0] == '\0') { if (hints->ai_flags & AI_PASSIVE) { // No host and AI_PASSIVE implies wildcard bind. switch (hints->ai_family) { case BOOST_ASIO_OS_DEF(AF_INET): search[search_count].host = "0.0.0.0"; search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET); ++search_count; break; case BOOST_ASIO_OS_DEF(AF_INET6): search[search_count].host = "0::0"; search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6); ++search_count; break; case BOOST_ASIO_OS_DEF(AF_UNSPEC): search[search_count].host = "0::0"; search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6); ++search_count; search[search_count].host = "0.0.0.0"; search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET); ++search_count; break; default: break; } } else { // No host and not AI_PASSIVE means connect to local host. switch (hints->ai_family) { case BOOST_ASIO_OS_DEF(AF_INET): search[search_count].host = "localhost"; search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET); ++search_count; break; case BOOST_ASIO_OS_DEF(AF_INET6): search[search_count].host = "localhost"; search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6); ++search_count; break; case BOOST_ASIO_OS_DEF(AF_UNSPEC): search[search_count].host = "localhost"; search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6); ++search_count; search[search_count].host = "localhost"; search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET); ++search_count; break; default: break; } } } else { // Host is specified. switch (hints->ai_family) { case BOOST_ASIO_OS_DEF(AF_INET): search[search_count].host = host; search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET); ++search_count; break; case BOOST_ASIO_OS_DEF(AF_INET6): search[search_count].host = host; search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6); ++search_count; break; case BOOST_ASIO_OS_DEF(AF_UNSPEC): search[search_count].host = host; search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET6); ++search_count; search[search_count].host = host; search[search_count].family = BOOST_ASIO_OS_DEF(AF_INET); ++search_count; break; default: break; } } return search_count; } template <typename T> inline T* gai_alloc(std::size_t size = sizeof(T)) { using namespace std; T* p = static_cast<T>(::operator new(size, std::nothrow)); if (p) memset(p, 0, size); return p; } inline void gai_free(void p) { ::operator delete(p); } inline void gai_strcpy(char* target, const char* source, std::size_t max_size) { using namespace std; #if defined(BOOST_ASIO_HAS_SECURE_RTL) strcpy_s(target, max_size, source); #else // defined(BOOST_ASIO_HAS_SECURE_RTL) target = 0; if (max_size > 0) strncat(target, source, max_size - 1); #endif // defined(BOOST_ASIO_HAS_SECURE_RTL) } enum { gai_clone_flag = 1 << 30 }; inline int gai_aistruct(addrinfo_type** next, const addrinfo_type* hints, const void* addr, int family) { using namespace std; addrinfo_type* ai = gai_alloc<addrinfo_type>(); if (ai == 0) return EAI_MEMORY; ai->ai_next = 0; *next = ai; next = &ai->ai_next; ai->ai_canonname = 0; ai->ai_socktype = hints->ai_socktype; if (ai->ai_socktype == 0) ai->ai_flags \|= gai_clone_flag; ai->ai_protocol = hints->ai_protocol; ai->ai_family = family; switch (ai->ai_family) { case BOOST_ASIO_OS_DEF(AF_INET): { sockaddr_in4_type* sinptr = gai_alloc<sockaddr_in4_type>(); if (sinptr == 0) return EAI_MEMORY; sinptr->sin_family = BOOST_ASIO_OS_DEF(AF_INET); memcpy(&sinptr->sin_addr, addr, sizeof(in4_addr_type)); ai->ai_addr = reinterpret_cast<sockaddr>(sinptr); ai->ai_addrlen = sizeof(sockaddr_in4_type); break; } case BOOST_ASIO_OS_DEF(AF_INET6): { sockaddr_in6_type sin6ptr = gai_alloc<sockaddr_in6_type>(); if (sin6ptr == 0) return EAI_MEMORY; sin6ptr->sin6_family = BOOST_ASIO_OS_DEF(AF_INET6); memcpy(&sin6ptr->sin6_addr, addr, sizeof(in6_addr_type)); ai->ai_addr = reinterpret_cast<sockaddr>(sin6ptr); ai->ai_addrlen = sizeof(sockaddr_in6_type); break; } default: break; } return 0; } inline addrinfo_type gai_clone(addrinfo_type* ai) { using namespace std; addrinfo_type* new_ai = gai_alloc<addrinfo_type>(); if (new_ai == 0) return new_ai; new_ai->ai_next = ai->ai_next; ai->ai_next = new_ai; new_ai->ai_flags = 0; new_ai->ai_family = ai->ai_family; new_ai->ai_socktype = ai->ai_socktype; new_ai->ai_protocol = ai->ai_protocol; new_ai->ai_canonname = 0; new_ai->ai_addrlen = ai->ai_addrlen; new_ai->ai_addr = gai_alloc<sockaddr>(ai->ai_addrlen); memcpy(new_ai->ai_addr, ai->ai_addr, ai->ai_addrlen); return new_ai; } inline int gai_port(addrinfo_type* aihead, int port, int socktype) { int num_found = 0; for (addrinfo_type* ai = aihead; ai; ai = ai->ai_next) { if (ai->ai_flags & gai_clone_flag) { if (ai->ai_socktype != 0) { ai = gai_clone(ai); if (ai == 0) return -1; // ai now points to newly cloned entry. } } else if (ai->ai_socktype != socktype) { // Ignore if mismatch on socket type. continue; } ai->ai_socktype = socktype; switch (ai->ai_family) { case BOOST_ASIO_OS_DEF(AF_INET): { sockaddr_in4_type* sinptr = reinterpret_cast<sockaddr_in4_type>(ai->ai_addr); sinptr->sin_port = port; ++num_found; break; } case BOOST_ASIO_OS_DEF(AF_INET6): { sockaddr_in6_type sin6ptr = reinterpret_cast<sockaddr_in6_type>(ai->ai_addr); sin6ptr->sin6_port = port; ++num_found; break; } default: break; } } return num_found; } inline int gai_serv(addrinfo_type aihead, const addrinfo_type* hints, const char* serv) { using namespace std; int num_found = 0; if ( #if defined(AI_NUMERICSERV) (hints->ai_flags & AI_NUMERICSERV) \|\| #endif isdigit(static_cast<unsigned char>(serv[0]))) { int port = htons(atoi(serv)); if (hints->ai_socktype) { // Caller specifies socket type. int rc = gai_port(aihead, port, hints->ai_socktype); if (rc < 0) return EAI_MEMORY; num_found += rc; } else { // Caller does not specify socket type. int rc = gai_port(aihead, port, SOCK_STREAM); if (rc < 0) return EAI_MEMORY; num_found += rc; rc = gai_port(aihead, port, SOCK_DGRAM); if (rc < 0) return EAI_MEMORY; num_found += rc; } } else { // Try service name with TCP first, then UDP. if (hints->ai_socktype == 0 \|\| hints->ai_socktype == SOCK_STREAM) { servent* sptr = getservbyname(serv, "tcp"); if (sptr != 0) { int rc = gai_port(aihead, sptr->s_port, SOCK_STREAM); if (rc < 0) return EAI_MEMORY; num_found += rc; } } if (hints->ai_socktype == 0 \|\| hints->ai_socktype == SOCK_DGRAM) { servent* sptr = getservbyname(serv, "udp"); if (sptr != 0) { int rc = gai_port(aihead, sptr->s_port, SOCK_DGRAM); if (rc < 0) return EAI_MEMORY; num_found += rc; } } } if (num_found == 0) { if (hints->ai_socktype == 0) { // All calls to getservbyname() failed. return EAI_NONAME; } else { // Service not supported for socket type. return EAI_SERVICE; } } return 0; } inline int gai_echeck(const char* host, const char* service, int flags, int family, int socktype, int protocol) { (void)(flags); (void)(protocol); // Host or service must be specified. if (host == 0 \|\| host[0] == '\0') if (service == 0 \|\| service[0] == '\0') return EAI_NONAME; // Check combination of family and socket type. switch (family) { case BOOST_ASIO_OS_DEF(AF_UNSPEC): break; case BOOST_ASIO_OS_DEF(AF_INET): case BOOST_ASIO_OS_DEF(AF_INET6): if (service != 0 && service[0] != '\0') if (socktype != 0 && socktype != SOCK_STREAM && socktype != SOCK_DGRAM) return EAI_SOCKTYPE; break; default: return EAI_FAMILY; } return 0; } inline void freeaddrinfo_emulation(addrinfo_type* aihead) { addrinfo_type* ai = aihead; while (ai) { gai_free(ai->ai_addr); gai_free(ai->ai_canonname); addrinfo_type* ainext = ai->ai_next; gai_free(ai); ai = ainext; } } inline int getaddrinfo_emulation(const char* host, const char* service, const addrinfo_type* hintsp, addrinfo_type** result) { // Set up linked list of addrinfo structures. addrinfo_type* aihead = 0; addrinfo_type** ainext = &aihead; char* canon = 0; // Supply default hints if not specified by caller. addrinfo_type hints = addrinfo_type(); hints.ai_family = BOOST_ASIO_OS_DEF(AF_UNSPEC); if (hintsp) hints = hintsp; // If the resolution is not specifically for AF_INET6, remove the AI_V4MAPPED // and AI_ALL flags. #if defined(AI_V4MAPPED) if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_INET6)) hints.ai_flags &= ~AI_V4MAPPED; #endif #if defined(AI_ALL) if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_INET6)) hints.ai_flags &= ~AI_ALL; #endif // Basic error checking. int rc = gai_echeck(host, service, hints.ai_flags, hints.ai_family, hints.ai_socktype, hints.ai_protocol); if (rc != 0) { freeaddrinfo_emulation(aihead); return rc; } gai_search search[2]; int search_count = gai_nsearch(host, &hints, search); for (gai_search sptr = search; sptr < search + search_count; ++sptr) { // Check for IPv4 dotted decimal string. in4_addr_type inaddr; boost::system::error_code ec; if (socket_ops::inet_pton(BOOST_ASIO_OS_DEF(AF_INET), sptr->host, &inaddr, 0, ec) == 1) { if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_UNSPEC) && hints.ai_family != BOOST_ASIO_OS_DEF(AF_INET)) { freeaddrinfo_emulation(aihead); gai_free(canon); return EAI_FAMILY; } if (sptr->family == BOOST_ASIO_OS_DEF(AF_INET)) { rc = gai_aistruct(&ainext, &hints, &inaddr, BOOST_ASIO_OS_DEF(AF_INET)); if (rc != 0) { freeaddrinfo_emulation(aihead); gai_free(canon); return rc; } } continue; } // Check for IPv6 hex string. in6_addr_type in6addr; if (socket_ops::inet_pton(BOOST_ASIO_OS_DEF(AF_INET6), sptr->host, &in6addr, 0, ec) == 1) { if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_UNSPEC) && hints.ai_family != BOOST_ASIO_OS_DEF(AF_INET6)) { freeaddrinfo_emulation(aihead); gai_free(canon); return EAI_FAMILY; } if (sptr->family == BOOST_ASIO_OS_DEF(AF_INET6)) { rc = gai_aistruct(&ainext, &hints, &in6addr, BOOST_ASIO_OS_DEF(AF_INET6)); if (rc != 0) { freeaddrinfo_emulation(aihead); gai_free(canon); return rc; } } continue; } // Look up hostname. hostent hent; char hbuf[8192] = ""; hostent* hptr = socket_ops::gethostbyname(sptr->host, sptr->family, &hent, hbuf, sizeof(hbuf), hints.ai_flags, ec); if (hptr == 0) { if (search_count == 2) { // Failure is OK if there are multiple searches. continue; } freeaddrinfo_emulation(aihead); gai_free(canon); if (ec == boost::asio::error::host_not_found) return EAI_NONAME; if (ec == boost::asio::error::host_not_found_try_again) return EAI_AGAIN; if (ec == boost::asio::error::no_recovery) return EAI_FAIL; if (ec == boost::asio::error::no_data) return EAI_NONAME; return EAI_NONAME; } // Check for address family mismatch if one was specified. if (hints.ai_family != BOOST_ASIO_OS_DEF(AF_UNSPEC) && hints.ai_family != hptr->h_addrtype) { freeaddrinfo_emulation(aihead); gai_free(canon); socket_ops::freehostent(hptr); return EAI_FAMILY; } // Save canonical name first time. if (host != 0 && host[0] != '\0' && hptr->h_name && hptr->h_name[0] && (hints.ai_flags & AI_CANONNAME) && canon == 0) { std::size_t canon_len = strlen(hptr->h_name) + 1; canon = gai_alloc<char>(canon_len); if (canon == 0) { freeaddrinfo_emulation(aihead); socket_ops::freehostent(hptr); return EAI_MEMORY; } gai_strcpy(canon, hptr->h_name, canon_len); } // Create an addrinfo structure for each returned address. for (char** ap = hptr->h_addr_list; ap; ++ap) { rc = gai_aistruct(&ainext, &hints, ap, hptr->h_addrtype); if (rc != 0) { freeaddrinfo_emulation(aihead); gai_free(canon); socket_ops::freehostent(hptr); return EAI_FAMILY; } } socket_ops::freehostent(hptr); } // Check if we found anything. if (aihead == 0) { gai_free(canon); return EAI_NONAME; } // Return canonical name in first entry. if (host != 0 && host[0] != '\0' && (hints.ai_flags & AI_CANONNAME)) { if (canon) { aihead->ai_canonname = canon; canon = 0; } else { std::size_t canonname_len = strlen(search[0].host) + 1; aihead->ai_canonname = gai_alloc<char>(canonname_len); if (aihead->ai_canonname == 0) { freeaddrinfo_emulation(aihead); return EAI_MEMORY; } gai_strcpy(aihead->ai_canonname, search[0].host, canonname_len); } } gai_free(canon); // Process the service name. if (service != 0 && service[0] != '\0') { rc = gai_serv(aihead, &hints, service); if (rc != 0) { freeaddrinfo_emulation(aihead); return rc; } } // Return result to caller. result = aihead; return 0; } inline boost::system::error_code getnameinfo_emulation( const socket_addr_type sa, std::size_t salen, char* host, std::size_t hostlen, char* serv, std::size_t servlen, int flags, boost::system::error_code& ec) { using namespace std; const char* addr; size_t addr_len; unsigned short port; switch (sa->sa_family) { case BOOST_ASIO_OS_DEF(AF_INET): if (salen != sizeof(sockaddr_in4_type)) { return ec = boost::asio::error::invalid_argument; } addr = reinterpret_cast<const char>( &reinterpret_cast<const sockaddr_in4_type>(sa)->sin_addr); addr_len = sizeof(in4_addr_type); port = reinterpret_cast<const sockaddr_in4_type>(sa)->sin_port; break; case BOOST_ASIO_OS_DEF(AF_INET6): if (salen != sizeof(sockaddr_in6_type)) { return ec = boost::asio::error::invalid_argument; } addr = reinterpret_cast<const char>( &reinterpret_cast<const sockaddr_in6_type>(sa)->sin6_addr); addr_len = sizeof(in6_addr_type); port = reinterpret_cast<const sockaddr_in6_type>(sa)->sin6_port; break; default: return ec = boost::asio::error::address_family_not_supported; } if (host && hostlen > 0) { if (flags & NI_NUMERICHOST) { if (socket_ops::inet_ntop(sa->sa_family, addr, host, hostlen, 0, ec) == 0) { return ec; } } else { hostent hent; char hbuf[8192] = ""; hostent* hptr = socket_ops::gethostbyaddr(addr, static_cast<int>(addr_len), sa->sa_family, &hent, hbuf, sizeof(hbuf), ec); if (hptr && hptr->h_name && hptr->h_name[0] != '\0') { if (flags & NI_NOFQDN) { char* dot = strchr(hptr->h_name, '.'); if (dot) { dot = 0; } } gai_strcpy(host, hptr->h_name, hostlen); socket_ops::freehostent(hptr); } else { socket_ops::freehostent(hptr); if (flags & NI_NAMEREQD) { return ec = boost::asio::error::host_not_found; } if (socket_ops::inet_ntop(sa->sa_family, addr, host, hostlen, 0, ec) == 0) { return ec; } } } } if (serv && servlen > 0) { if (flags & NI_NUMERICSERV) { if (servlen < 6) { return ec = boost::asio::error::no_buffer_space; } #if defined(BOOST_ASIO_HAS_SECURE_RTL) sprintf_s(serv, servlen, "%u", ntohs(port)); #else // defined(BOOST_ASIO_HAS_SECURE_RTL) sprintf(serv, "%u", ntohs(port)); #endif // defined(BOOST_ASIO_HAS_SECURE_RTL) } else { #if defined(BOOST_ASIO_HAS_PTHREADS) static ::pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; ::pthread_mutex_lock(&mutex); #endif // defined(BOOST_ASIO_HAS_PTHREADS) servent sptr = ::getservbyport(port, (flags & NI_DGRAM) ? "udp" : 0); if (sptr && sptr->s_name && sptr->s_name[0] != '\0') { gai_strcpy(serv, sptr->s_name, servlen); } else { if (servlen < 6) { return ec = boost::asio::error::no_buffer_space; } #if defined(BOOST_ASIO_HAS_SECURE_RTL) sprintf_s(serv, servlen, "%u", ntohs(port)); #else // defined(BOOST_ASIO_HAS_SECURE_RTL) sprintf(serv, "%u", ntohs(port)); #endif // defined(BOOST_ASIO_HAS_SECURE_RTL) } #if defined(BOOST_ASIO_HAS_PTHREADS) ::pthread_mutex_unlock(&mutex); #endif // defined(BOOST_ASIO_HAS_PTHREADS) } } ec.assign(0, ec.category()); return ec; } #endif // !defined(BOOST_ASIO_HAS_GETADDRINFO) inline boost::system::error_code translate_addrinfo_error(int error) { switch (error) { case 0: return boost::system::error_code(); case EAI_AGAIN: return boost::asio::error::host_not_found_try_again; case EAI_BADFLAGS: return boost::asio::error::invalid_argument; case EAI_FAIL: return boost::asio::error::no_recovery; case EAI_FAMILY: return boost::asio::error::address_family_not_supported; case EAI_MEMORY: return boost::asio::error::no_memory; case EAI_NONAME: #if defined(EAI_ADDRFAMILY) case EAI_ADDRFAMILY: #endif #if defined(EAI_NODATA) && (EAI_NODATA != EAI_NONAME) case EAI_NODATA: #endif return boost::asio::error::host_not_found; case EAI_SERVICE: return boost::asio::error::service_not_found; case EAI_SOCKTYPE: return boost::asio::error::socket_type_not_supported; default: // Possibly the non-portable EAI_SYSTEM. #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) return boost::system::error_code( WSAGetLastError(), boost::asio::error::get_system_category()); #else return boost::system::error_code( errno, boost::asio::error::get_system_category()); #endif } } boost::system::error_code getaddrinfo(const char* host, const char* service, const addrinfo_type& hints, addrinfo_type** result, boost::system::error_code& ec) { host = (host && host) ? host : 0; service = (service && service) ? service : 0; clear_last_error(); #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) # if defined(BOOST_ASIO_HAS_GETADDRINFO) // Building for Windows XP, Windows Server 2003, or later. int error = ::getaddrinfo(host, service, &hints, result); return ec = translate_addrinfo_error(error); # else // Building for Windows 2000 or earlier. typedef int (WSAAPI gai_t)(const char, const char, const addrinfo_type, addrinfo_type*); if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32")) { if (gai_t gai = (gai_t)::GetProcAddress(winsock_module, "getaddrinfo")) { int error = gai(host, service, &hints, result); return ec = translate_addrinfo_error(error); } } int error = getaddrinfo_emulation(host, service, &hints, result); return ec = translate_addrinfo_error(error); # endif #elif !defined(BOOST_ASIO_HAS_GETADDRINFO) int error = getaddrinfo_emulation(host, service, &hints, result); return ec = translate_addrinfo_error(error); #else int error = ::getaddrinfo(host, service, &hints, result); #if defined(__MACH__) && defined(__APPLE__) using namespace std; // For isdigit and atoi. if (error == 0 && service && isdigit(static_cast<unsigned char>(service[0]))) { u_short_type port = host_to_network_short(atoi(service)); for (addrinfo_type ai = result; ai; ai = ai->ai_next) { switch (ai->ai_family) { case BOOST_ASIO_OS_DEF(AF_INET): { sockaddr_in4_type sinptr = reinterpret_cast<sockaddr_in4_type>(ai->ai_addr); if (sinptr->sin_port == 0) sinptr->sin_port = port; break; } case BOOST_ASIO_OS_DEF(AF_INET6): { sockaddr_in6_type sin6ptr = reinterpret_cast<sockaddr_in6_type>(ai->ai_addr); if (sin6ptr->sin6_port == 0) sin6ptr->sin6_port = port; break; } default: break; } } } #endif return ec = translate_addrinfo_error(error); #endif } boost::system::error_code background_getaddrinfo( const weak_cancel_token_type& cancel_token, const char host, const char* service, const addrinfo_type& hints, addrinfo_type** result, boost::system::error_code& ec) { if (cancel_token.expired()) ec = boost::asio::error::operation_aborted; else socket_ops::getaddrinfo(host, service, hints, result, ec); return ec; } void freeaddrinfo(addrinfo_type* ai) { #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) # if defined(BOOST_ASIO_HAS_GETADDRINFO) // Building for Windows XP, Windows Server 2003, or later. ::freeaddrinfo(ai); # else // Building for Windows 2000 or earlier. typedef int (WSAAPI fai_t)(addrinfo_type); if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32")) { if (fai_t fai = (fai_t)::GetProcAddress(winsock_module, "freeaddrinfo")) { fai(ai); return; } } freeaddrinfo_emulation(ai); # endif #elif !defined(BOOST_ASIO_HAS_GETADDRINFO) freeaddrinfo_emulation(ai); #else ::freeaddrinfo(ai); #endif } boost::system::error_code getnameinfo(const socket_addr_type* addr, std::size_t addrlen, char* host, std::size_t hostlen, char* serv, std::size_t servlen, int flags, boost::system::error_code& ec) { #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) # if defined(BOOST_ASIO_HAS_GETADDRINFO) // Building for Windows XP, Windows Server 2003, or later. clear_last_error(); int error = ::getnameinfo(addr, static_cast<socklen_t>(addrlen), host, static_cast<DWORD>(hostlen), serv, static_cast<DWORD>(servlen), flags); return ec = translate_addrinfo_error(error); # else // Building for Windows 2000 or earlier. typedef int (WSAAPI gni_t)(const socket_addr_type, int, char, DWORD, char, DWORD, int); if (HMODULE winsock_module = ::GetModuleHandleA("ws2_32")) { if (gni_t gni = (gni_t)::GetProcAddress(winsock_module, "getnameinfo")) { clear_last_error(); int error = gni(addr, static_cast<int>(addrlen), host, static_cast<DWORD>(hostlen), serv, static_cast<DWORD>(servlen), flags); return ec = translate_addrinfo_error(error); } } clear_last_error(); return getnameinfo_emulation(addr, addrlen, host, hostlen, serv, servlen, flags, ec); # endif #elif !defined(BOOST_ASIO_HAS_GETADDRINFO) using namespace std; // For memcpy. sockaddr_storage_type tmp_addr; memcpy(&tmp_addr, addr, addrlen); addr = reinterpret_cast<socket_addr_type>(&tmp_addr); clear_last_error(); return getnameinfo_emulation(addr, addrlen, host, hostlen, serv, servlen, flags, ec); #else clear_last_error(); int error = ::getnameinfo(addr, addrlen, host, hostlen, serv, servlen, flags); return ec = translate_addrinfo_error(error); #endif } boost::system::error_code sync_getnameinfo( const socket_addr_type addr, std::size_t addrlen, char* host, std::size_t hostlen, char* serv, std::size_t servlen, int sock_type, boost::system::error_code& ec) { // First try resolving with the service name. If that fails try resolving // but allow the service to be returned as a number. int flags = (sock_type == SOCK_DGRAM) ? NI_DGRAM : 0; socket_ops::getnameinfo(addr, addrlen, host, hostlen, serv, servlen, flags, ec); if (ec) { socket_ops::getnameinfo(addr, addrlen, host, hostlen, serv, servlen, flags \| NI_NUMERICSERV, ec); } return ec; } boost::system::error_code background_getnameinfo( const weak_cancel_token_type& cancel_token, const socket_addr_type* addr, std::size_t addrlen, char* host, std::size_t hostlen, char* serv, std::size_t servlen, int sock_type, boost::system::error_code& ec) { if (cancel_token.expired()) { ec = boost::asio::error::operation_aborted; } else { // First try resolving with the service name. If that fails try resolving // but allow the service to be returned as a number. int flags = (sock_type == SOCK_DGRAM) ? NI_DGRAM : 0; socket_ops::getnameinfo(addr, addrlen, host, hostlen, serv, servlen, flags, ec); if (ec) { socket_ops::getnameinfo(addr, addrlen, host, hostlen, serv, servlen, flags \| NI_NUMERICSERV, ec); } } return ec; } #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) u_long_type network_to_host_long(u_long_type value) { #if defined(BOOST_ASIO_WINDOWS_RUNTIME) unsigned char* value_p = reinterpret_cast<unsigned char>(&value); u_long_type result = (static_cast<u_long_type>(value_p[0]) << 24) \| (static_cast<u_long_type>(value_p[1]) << 16) \| (static_cast<u_long_type>(value_p[2]) << 8) \| static_cast<u_long_type>(value_p[3]); return result; #else // defined(BOOST_ASIO_WINDOWS_RUNTIME) return ntohl(value); #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) } u_long_type host_to_network_long(u_long_type value) { #if defined(BOOST_ASIO_WINDOWS_RUNTIME) u_long_type result; unsigned char result_p = reinterpret_cast<unsigned char>(&result); result_p[0] = static_cast<unsigned char>((value >> 24) & 0xFF); result_p[1] = static_cast<unsigned char>((value >> 16) & 0xFF); result_p[2] = static_cast<unsigned char>((value >> 8) & 0xFF); result_p[3] = static_cast<unsigned char>(value & 0xFF); return result; #else // defined(BOOST_ASIO_WINDOWS_RUNTIME) return htonl(value); #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) } u_short_type network_to_host_short(u_short_type value) { #if defined(BOOST_ASIO_WINDOWS_RUNTIME) unsigned char value_p = reinterpret_cast<unsigned char>(&value); u_short_type result = (static_cast<u_short_type>(value_p[0]) << 8) \| static_cast<u_short_type>(value_p[1]); return result; #else // defined(BOOST_ASIO_WINDOWS_RUNTIME) return ntohs(value); #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) } u_short_type host_to_network_short(u_short_type value) { #if defined(BOOST_ASIO_WINDOWS_RUNTIME) u_short_type result; unsigned char result_p = reinterpret_cast<unsigned char>(&result); result_p[0] = static_cast<unsigned char>((value >> 8) & 0xFF); result_p[1] = static_cast<unsigned char>(value & 0xFF); return result; #else // defined(BOOST_ASIO_WINDOWS_RUNTIME) return htons(value); #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) } } // namespace socket_ops } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_SOCKET_OPS_IPP PK��h!\��7��$��impl/reactive_descriptor_service.ippnu��[��// // detail/impl/reactive_descriptor_service.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_REACTIVE_DESCRIPTOR_SERVICE_IPP #define BOOST_ASIO_DETAIL_IMPL_REACTIVE_DESCRIPTOR_SERVICE_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_WINDOWS) \ && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ && !defined(__CYGWIN__) #include <boost/asio/error.hpp> #include <boost/asio/detail/reactive_descriptor_service.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { reactive_descriptor_service::reactive_descriptor_service( execution_context& context) : execution_context_service_base<reactive_descriptor_service>(context), reactor_(boost::asio::use_service<reactor>(context)) { reactor_.init_task(); } void reactive_descriptor_service::shutdown() { } void reactive_descriptor_service::construct( reactive_descriptor_service::implementation_type& impl) { impl.descriptor_ = -1; impl.state_ = 0; } void reactive_descriptor_service::move_construct( reactive_descriptor_service::implementation_type& impl, reactive_descriptor_service::implementation_type& other_impl) BOOST_ASIO_NOEXCEPT { impl.descriptor_ = other_impl.descriptor_; other_impl.descriptor_ = -1; impl.state_ = other_impl.state_; other_impl.state_ = 0; reactor_.move_descriptor(impl.descriptor_, impl.reactor_data_, other_impl.reactor_data_); } void reactive_descriptor_service::move_assign( reactive_descriptor_service::implementation_type& impl, reactive_descriptor_service& other_service, reactive_descriptor_service::implementation_type& other_impl) { destroy(impl); impl.descriptor_ = other_impl.descriptor_; other_impl.descriptor_ = -1; impl.state_ = other_impl.state_; other_impl.state_ = 0; other_service.reactor_.move_descriptor(impl.descriptor_, impl.reactor_data_, other_impl.reactor_data_); } void reactive_descriptor_service::destroy( reactive_descriptor_service::implementation_type& impl) { if (is_open(impl)) { BOOST_ASIO_HANDLER_OPERATION((reactor_.context(), "descriptor", &impl, impl.descriptor_, "close")); reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_, (impl.state_ & descriptor_ops::possible_dup) == 0); boost::system::error_code ignored_ec; descriptor_ops::close(impl.descriptor_, impl.state_, ignored_ec); reactor_.cleanup_descriptor_data(impl.reactor_data_); } } boost::system::error_code reactive_descriptor_service::assign( reactive_descriptor_service::implementation_type& impl, const native_handle_type& native_descriptor, boost::system::error_code& ec) { if (is_open(impl)) { ec = boost::asio::error::already_open; return ec; } if (int err = reactor_.register_descriptor( native_descriptor, impl.reactor_data_)) { ec = boost::system::error_code(err, boost::asio::error::get_system_category()); return ec; } impl.descriptor_ = native_descriptor; impl.state_ = descriptor_ops::possible_dup; ec = boost::system::error_code(); return ec; } boost::system::error_code reactive_descriptor_service::close( reactive_descriptor_service::implementation_type& impl, boost::system::error_code& ec) { if (is_open(impl)) { BOOST_ASIO_HANDLER_OPERATION((reactor_.context(), "descriptor", &impl, impl.descriptor_, "close")); reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_, (impl.state_ & descriptor_ops::possible_dup) == 0); descriptor_ops::close(impl.descriptor_, impl.state_, ec); reactor_.cleanup_descriptor_data(impl.reactor_data_); } else { ec = boost::system::error_code(); } // The descriptor is closed by the OS even if close() returns an error. // // (Actually, POSIX says the state of the descriptor is unspecified. On // Linux the descriptor is apparently closed anyway; e.g. see // http://lkml.org/lkml/2005/9/10/129 // We'll just have to assume that other OSes follow the same behaviour.) construct(impl); return ec; } reactive_descriptor_service::native_handle_type reactive_descriptor_service::release( reactive_descriptor_service::implementation_type& impl) { native_handle_type descriptor = impl.descriptor_; if (is_open(impl)) { BOOST_ASIO_HANDLER_OPERATION((reactor_.context(), "descriptor", &impl, impl.descriptor_, "release")); reactor_.deregister_descriptor(impl.descriptor_, impl.reactor_data_, false); reactor_.cleanup_descriptor_data(impl.reactor_data_); construct(impl); } return descriptor; } boost::system::error_code reactive_descriptor_service::cancel( reactive_descriptor_service::implementation_type& impl, boost::system::error_code& ec) { if (!is_open(impl)) { ec = boost::asio::error::bad_descriptor; return ec; } BOOST_ASIO_HANDLER_OPERATION((reactor_.context(), "descriptor", &impl, impl.descriptor_, "cancel")); reactor_.cancel_ops(impl.descriptor_, impl.reactor_data_); ec = boost::system::error_code(); return ec; } void reactive_descriptor_service::start_op( reactive_descriptor_service::implementation_type& impl, int op_type, reactor_op op, bool is_continuation, bool is_non_blocking, bool noop) { if (!noop) { if ((impl.state_ & descriptor_ops::non_blocking) \|\| descriptor_ops::set_internal_non_blocking( impl.descriptor_, impl.state_, true, op->ec_)) { reactor_.start_op(op_type, impl.descriptor_, impl.reactor_data_, op, is_continuation, is_non_blocking); return; } } reactor_.post_immediate_completion(op, is_continuation); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // !defined(BOOST_ASIO_WINDOWS) // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) // && !defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_IMPL_REACTIVE_DESCRIPTOR_SERVICE_IPP PK��h!\ JR3��R3��impl/dev_poll_reactor.ippnu��[��// // detail/impl/dev_poll_reactor.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_DEV_POLL_REACTOR_IPP #define BOOST_ASIO_DETAIL_IMPL_DEV_POLL_REACTOR_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_HAS_DEV_POLL) #include <boost/asio/detail/dev_poll_reactor.hpp> #include <boost/asio/detail/assert.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { dev_poll_reactor::dev_poll_reactor(boost::asio::execution_context& ctx) : boost::asio::detail::execution_context_service_base<dev_poll_reactor>(ctx), scheduler_(use_service<scheduler>(ctx)), mutex_(), dev_poll_fd_(do_dev_poll_create()), interrupter_(), shutdown_(false) { // Add the interrupter's descriptor to /dev/poll. ::pollfd ev = { 0, 0, 0 }; ev.fd = interrupter_.read_descriptor(); ev.events = POLLIN \| POLLERR; ev.revents = 0; ::write(dev_poll_fd_, &ev, sizeof(ev)); } dev_poll_reactor::~dev_poll_reactor() { shutdown(); ::close(dev_poll_fd_); } void dev_poll_reactor::shutdown() { boost::asio::detail::mutex::scoped_lock lock(mutex_); shutdown_ = true; lock.unlock(); op_queue<operation> ops; for (int i = 0; i < max_ops; ++i) op_queue_[i].get_all_operations(ops); timer_queues_.get_all_timers(ops); scheduler_.abandon_operations(ops); } void dev_poll_reactor::notify_fork( boost::asio::execution_context::fork_event fork_ev) { if (fork_ev == boost::asio::execution_context::fork_child) { detail::mutex::scoped_lock lock(mutex_); if (dev_poll_fd_ != -1) ::close(dev_poll_fd_); dev_poll_fd_ = -1; dev_poll_fd_ = do_dev_poll_create(); interrupter_.recreate(); // Add the interrupter's descriptor to /dev/poll. ::pollfd ev = { 0, 0, 0 }; ev.fd = interrupter_.read_descriptor(); ev.events = POLLIN \| POLLERR; ev.revents = 0; ::write(dev_poll_fd_, &ev, sizeof(ev)); // Re-register all descriptors with /dev/poll. The changes will be written // to the /dev/poll descriptor the next time the reactor is run. for (int i = 0; i < max_ops; ++i) { reactor_op_queue<socket_type>::iterator iter = op_queue_[i].begin(); reactor_op_queue<socket_type>::iterator end = op_queue_[i].end(); for (; iter != end; ++iter) { ::pollfd& pending_ev = add_pending_event_change(iter->first); pending_ev.events \|= POLLERR \| POLLHUP; switch (i) { case read_op: pending_ev.events \|= POLLIN; break; case write_op: pending_ev.events \|= POLLOUT; break; case except_op: pending_ev.events \|= POLLPRI; break; default: break; } } } interrupter_.interrupt(); } } void dev_poll_reactor::init_task() { scheduler_.init_task(); } int dev_poll_reactor::register_descriptor(socket_type, per_descriptor_data&) { return 0; } int dev_poll_reactor::register_internal_descriptor(int op_type, socket_type descriptor, per_descriptor_data&, reactor_op* op) { boost::asio::detail::mutex::scoped_lock lock(mutex_); op_queue_[op_type].enqueue_operation(descriptor, op); ::pollfd& ev = add_pending_event_change(descriptor); ev.events = POLLERR \| POLLHUP; switch (op_type) { case read_op: ev.events \|= POLLIN; break; case write_op: ev.events \|= POLLOUT; break; case except_op: ev.events \|= POLLPRI; break; default: break; } interrupter_.interrupt(); return 0; } void dev_poll_reactor::move_descriptor(socket_type, dev_poll_reactor::per_descriptor_data&, dev_poll_reactor::per_descriptor_data&) { } void dev_poll_reactor::start_op(int op_type, socket_type descriptor, dev_poll_reactor::per_descriptor_data&, reactor_op* op, bool is_continuation, bool allow_speculative) { boost::asio::detail::mutex::scoped_lock lock(mutex_); if (shutdown_) { post_immediate_completion(op, is_continuation); return; } if (allow_speculative) { if (op_type != read_op \|\| !op_queue_[except_op].has_operation(descriptor)) { if (!op_queue_[op_type].has_operation(descriptor)) { if (op->perform()) { lock.unlock(); scheduler_.post_immediate_completion(op, is_continuation); return; } } } } bool first = op_queue_[op_type].enqueue_operation(descriptor, op); scheduler_.work_started(); if (first) { ::pollfd& ev = add_pending_event_change(descriptor); ev.events = POLLERR \| POLLHUP; if (op_type == read_op \|\| op_queue_[read_op].has_operation(descriptor)) ev.events \|= POLLIN; if (op_type == write_op \|\| op_queue_[write_op].has_operation(descriptor)) ev.events \|= POLLOUT; if (op_type == except_op \|\| op_queue_[except_op].has_operation(descriptor)) ev.events \|= POLLPRI; interrupter_.interrupt(); } } void dev_poll_reactor::cancel_ops(socket_type descriptor, dev_poll_reactor::per_descriptor_data&) { boost::asio::detail::mutex::scoped_lock lock(mutex_); cancel_ops_unlocked(descriptor, boost::asio::error::operation_aborted); } void dev_poll_reactor::deregister_descriptor(socket_type descriptor, dev_poll_reactor::per_descriptor_data&, bool) { boost::asio::detail::mutex::scoped_lock lock(mutex_); // Remove the descriptor from /dev/poll. ::pollfd& ev = add_pending_event_change(descriptor); ev.events = POLLREMOVE; interrupter_.interrupt(); // Cancel any outstanding operations associated with the descriptor. cancel_ops_unlocked(descriptor, boost::asio::error::operation_aborted); } void dev_poll_reactor::deregister_internal_descriptor( socket_type descriptor, dev_poll_reactor::per_descriptor_data&) { boost::asio::detail::mutex::scoped_lock lock(mutex_); // Remove the descriptor from /dev/poll. Since this function is only called // during a fork, we can apply the change immediately. ::pollfd ev = { 0, 0, 0 }; ev.fd = descriptor; ev.events = POLLREMOVE; ev.revents = 0; ::write(dev_poll_fd_, &ev, sizeof(ev)); // Destroy all operations associated with the descriptor. op_queue<operation> ops; boost::system::error_code ec; for (int i = 0; i < max_ops; ++i) op_queue_[i].cancel_operations(descriptor, ops, ec); } void dev_poll_reactor::cleanup_descriptor_data( dev_poll_reactor::per_descriptor_data&) { } void dev_poll_reactor::run(long usec, op_queue<operation>& ops) { boost::asio::detail::mutex::scoped_lock lock(mutex_); // We can return immediately if there's no work to do and the reactor is // not supposed to block. if (usec == 0 && op_queue_[read_op].empty() && op_queue_[write_op].empty() && op_queue_[except_op].empty() && timer_queues_.all_empty()) return; // Write the pending event registration changes to the /dev/poll descriptor. std::size_t events_size = sizeof(::pollfd) * pending_event_changes_.size(); if (events_size > 0) { errno = 0; int result = ::write(dev_poll_fd_, &pending_event_changes_[0], events_size); if (result != static_cast<int>(events_size)) { boost::system::error_code ec = boost::system::error_code( errno, boost::asio::error::get_system_category()); for (std::size_t i = 0; i < pending_event_changes_.size(); ++i) { int descriptor = pending_event_changes_[i].fd; for (int j = 0; j < max_ops; ++j) op_queue_[j].cancel_operations(descriptor, ops, ec); } } pending_event_changes_.clear(); pending_event_change_index_.clear(); } // Calculate timeout. int timeout; if (usec == 0) timeout = 0; else { timeout = (usec < 0) ? -1 : ((usec - 1) / 1000 + 1); timeout = get_timeout(timeout); } lock.unlock(); // Block on the /dev/poll descriptor. ::pollfd events[128] = { { 0, 0, 0 } }; ::dvpoll dp = { 0, 0, 0 }; dp.dp_fds = events; dp.dp_nfds = 128; dp.dp_timeout = timeout; int num_events = ::ioctl(dev_poll_fd_, DP_POLL, &dp); lock.lock(); // Dispatch the waiting events. for (int i = 0; i < num_events; ++i) { int descriptor = events[i].fd; if (descriptor == interrupter_.read_descriptor()) { interrupter_.reset(); } else { bool more_reads = false; bool more_writes = false; bool more_except = false; // Exception operations must be processed first to ensure that any // out-of-band data is read before normal data. if (events[i].events & (POLLPRI \| POLLERR \| POLLHUP)) more_except = op_queue_[except_op].perform_operations(descriptor, ops); else more_except = op_queue_[except_op].has_operation(descriptor); if (events[i].events & (POLLIN \| POLLERR \| POLLHUP)) more_reads = op_queue_[read_op].perform_operations(descriptor, ops); else more_reads = op_queue_[read_op].has_operation(descriptor); if (events[i].events & (POLLOUT \| POLLERR \| POLLHUP)) more_writes = op_queue_[write_op].perform_operations(descriptor, ops); else more_writes = op_queue_[write_op].has_operation(descriptor); if ((events[i].events & (POLLERR \| POLLHUP)) != 0 && !more_except && !more_reads && !more_writes) { // If we have an event and no operations associated with the // descriptor then we need to delete the descriptor from /dev/poll. // The poll operation can produce POLLHUP or POLLERR events when there // is no operation pending, so if we do not remove the descriptor we // can end up in a tight polling loop. ::pollfd ev = { 0, 0, 0 }; ev.fd = descriptor; ev.events = POLLREMOVE; ev.revents = 0; ::write(dev_poll_fd_, &ev, sizeof(ev)); } else { ::pollfd ev = { 0, 0, 0 }; ev.fd = descriptor; ev.events = POLLERR \| POLLHUP; if (more_reads) ev.events \|= POLLIN; if (more_writes) ev.events \|= POLLOUT; if (more_except) ev.events \|= POLLPRI; ev.revents = 0; int result = ::write(dev_poll_fd_, &ev, sizeof(ev)); if (result != sizeof(ev)) { boost::system::error_code ec(errno, boost::asio::error::get_system_category()); for (int j = 0; j < max_ops; ++j) op_queue_[j].cancel_operations(descriptor, ops, ec); } } } } timer_queues_.get_ready_timers(ops); } void dev_poll_reactor::interrupt() { interrupter_.interrupt(); } int dev_poll_reactor::do_dev_poll_create() { int fd = ::open("/dev/poll", O_RDWR); if (fd == -1) { boost::system::error_code ec(errno, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "/dev/poll"); } return fd; } void dev_poll_reactor::do_add_timer_queue(timer_queue_base& queue) { mutex::scoped_lock lock(mutex_); timer_queues_.insert(&queue); } void dev_poll_reactor::do_remove_timer_queue(timer_queue_base& queue) { mutex::scoped_lock lock(mutex_); timer_queues_.erase(&queue); } int dev_poll_reactor::get_timeout(int msec) { // By default we will wait no longer than 5 minutes. This will ensure that // any changes to the system clock are detected after no longer than this. const int max_msec = 5 * 60 * 1000; return timer_queues_.wait_duration_msec( (msec < 0 \|\| max_msec < msec) ? max_msec : msec); } void dev_poll_reactor::cancel_ops_unlocked(socket_type descriptor, const boost::system::error_code& ec) { bool need_interrupt = false; op_queue<operation> ops; for (int i = 0; i < max_ops; ++i) need_interrupt = op_queue_[i].cancel_operations( descriptor, ops, ec) \|\| need_interrupt; scheduler_.post_deferred_completions(ops); if (need_interrupt) interrupter_.interrupt(); } ::pollfd& dev_poll_reactor::add_pending_event_change(int descriptor) { hash_map<int, std::size_t>::iterator iter = pending_event_change_index_.find(descriptor); if (iter == pending_event_change_index_.end()) { std::size_t index = pending_event_changes_.size(); pending_event_changes_.reserve(pending_event_changes_.size() + 1); pending_event_change_index_.insert(std::make_pair(descriptor, index)); pending_event_changes_.push_back(::pollfd()); pending_event_changes_[index].fd = descriptor; pending_event_changes_[index].revents = 0; return pending_event_changes_[index]; } else { return pending_event_changes_[iter->second]; } } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_DEV_POLL) #endif // BOOST_ASIO_DETAIL_IMPL_DEV_POLL_REACTOR_IPP PK��h!\��0��0��"��impl/win_object_handle_service.ippnu��[��// // detail/impl/win_object_handle_service.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2011 Boris Schaeling (boris@highscore.de) // // 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_DETAIL_IMPL_WIN_OBJECT_HANDLE_SERVICE_IPP #define BOOST_ASIO_DETAIL_IMPL_WIN_OBJECT_HANDLE_SERVICE_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_HAS_WINDOWS_OBJECT_HANDLE) #include <boost/asio/detail/win_object_handle_service.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { win_object_handle_service::win_object_handle_service(execution_context& context) : execution_context_service_base<win_object_handle_service>(context), scheduler_(boost::asio::use_service<scheduler_impl>(context)), mutex_(), impl_list_(0), shutdown_(false) { } void win_object_handle_service::shutdown() { mutex::scoped_lock lock(mutex_); // Setting this flag to true prevents new objects from being registered, and // new asynchronous wait operations from being started. We only need to worry // about cleaning up the operations that are currently in progress. shutdown_ = true; op_queue<operation> ops; for (implementation_type* impl = impl_list_; impl; impl = impl->next_) ops.push(impl->op_queue_); lock.unlock(); scheduler_.abandon_operations(ops); } void win_object_handle_service::construct( win_object_handle_service::implementation_type& impl) { impl.handle_ = INVALID_HANDLE_VALUE; impl.wait_handle_ = INVALID_HANDLE_VALUE; impl.owner_ = this; // Insert implementation into linked list of all implementations. mutex::scoped_lock lock(mutex_); if (!shutdown_) { impl.next_ = impl_list_; impl.prev_ = 0; if (impl_list_) impl_list_->prev_ = &impl; impl_list_ = &impl; } } void win_object_handle_service::move_construct( win_object_handle_service::implementation_type& impl, win_object_handle_service::implementation_type& other_impl) { mutex::scoped_lock lock(mutex_); // Insert implementation into linked list of all implementations. if (!shutdown_) { impl.next_ = impl_list_; impl.prev_ = 0; if (impl_list_) impl_list_->prev_ = &impl; impl_list_ = &impl; } impl.handle_ = other_impl.handle_; other_impl.handle_ = INVALID_HANDLE_VALUE; impl.wait_handle_ = other_impl.wait_handle_; other_impl.wait_handle_ = INVALID_HANDLE_VALUE; impl.op_queue_.push(other_impl.op_queue_); impl.owner_ = this; // We must not hold the lock while calling UnregisterWaitEx. This is because // the registered callback function might be invoked while we are waiting for // UnregisterWaitEx to complete. lock.unlock(); if (impl.wait_handle_ != INVALID_HANDLE_VALUE) ::UnregisterWaitEx(impl.wait_handle_, INVALID_HANDLE_VALUE); if (!impl.op_queue_.empty()) register_wait_callback(impl, lock); } void win_object_handle_service::move_assign( win_object_handle_service::implementation_type& impl, win_object_handle_service& other_service, win_object_handle_service::implementation_type& other_impl) { boost::system::error_code ignored_ec; close(impl, ignored_ec); mutex::scoped_lock lock(mutex_); if (this != &other_service) { // Remove implementation from linked list of all implementations. if (impl_list_ == &impl) impl_list_ = impl.next_; if (impl.prev_) impl.prev_->next_ = impl.next_; if (impl.next_) impl.next_->prev_= impl.prev_; impl.next_ = 0; impl.prev_ = 0; } impl.handle_ = other_impl.handle_; other_impl.handle_ = INVALID_HANDLE_VALUE; impl.wait_handle_ = other_impl.wait_handle_; other_impl.wait_handle_ = INVALID_HANDLE_VALUE; impl.op_queue_.push(other_impl.op_queue_); impl.owner_ = this; if (this != &other_service) { // Insert implementation into linked list of all implementations. impl.next_ = other_service.impl_list_; impl.prev_ = 0; if (other_service.impl_list_) other_service.impl_list_->prev_ = &impl; other_service.impl_list_ = &impl; } // We must not hold the lock while calling UnregisterWaitEx. This is because // the registered callback function might be invoked while we are waiting for // UnregisterWaitEx to complete. lock.unlock(); if (impl.wait_handle_ != INVALID_HANDLE_VALUE) ::UnregisterWaitEx(impl.wait_handle_, INVALID_HANDLE_VALUE); if (!impl.op_queue_.empty()) register_wait_callback(impl, lock); } void win_object_handle_service::destroy( win_object_handle_service::implementation_type& impl) { mutex::scoped_lock lock(mutex_); // Remove implementation from linked list of all implementations. if (impl_list_ == &impl) impl_list_ = impl.next_; if (impl.prev_) impl.prev_->next_ = impl.next_; if (impl.next_) impl.next_->prev_= impl.prev_; impl.next_ = 0; impl.prev_ = 0; if (is_open(impl)) { BOOST_ASIO_HANDLER_OPERATION((scheduler_.context(), "object_handle", &impl, reinterpret_cast<uintmax_t>(impl.wait_handle_), "close")); HANDLE wait_handle = impl.wait_handle_; impl.wait_handle_ = INVALID_HANDLE_VALUE; op_queue<operation> ops; while (wait_op* op = impl.op_queue_.front()) { op->ec_ = boost::asio::error::operation_aborted; impl.op_queue_.pop(); ops.push(op); } // We must not hold the lock while calling UnregisterWaitEx. This is // because the registered callback function might be invoked while we are // waiting for UnregisterWaitEx to complete. lock.unlock(); if (wait_handle != INVALID_HANDLE_VALUE) ::UnregisterWaitEx(wait_handle, INVALID_HANDLE_VALUE); ::CloseHandle(impl.handle_); impl.handle_ = INVALID_HANDLE_VALUE; scheduler_.post_deferred_completions(ops); } } boost::system::error_code win_object_handle_service::assign( win_object_handle_service::implementation_type& impl, const native_handle_type& handle, boost::system::error_code& ec) { if (is_open(impl)) { ec = boost::asio::error::already_open; return ec; } impl.handle_ = handle; ec = boost::system::error_code(); return ec; } boost::system::error_code win_object_handle_service::close( win_object_handle_service::implementation_type& impl, boost::system::error_code& ec) { if (is_open(impl)) { BOOST_ASIO_HANDLER_OPERATION((scheduler_.context(), "object_handle", &impl, reinterpret_cast<uintmax_t>(impl.wait_handle_), "close")); mutex::scoped_lock lock(mutex_); HANDLE wait_handle = impl.wait_handle_; impl.wait_handle_ = INVALID_HANDLE_VALUE; op_queue<operation> completed_ops; while (wait_op* op = impl.op_queue_.front()) { impl.op_queue_.pop(); op->ec_ = boost::asio::error::operation_aborted; completed_ops.push(op); } // We must not hold the lock while calling UnregisterWaitEx. This is // because the registered callback function might be invoked while we are // waiting for UnregisterWaitEx to complete. lock.unlock(); if (wait_handle != INVALID_HANDLE_VALUE) ::UnregisterWaitEx(wait_handle, INVALID_HANDLE_VALUE); if (::CloseHandle(impl.handle_)) { impl.handle_ = INVALID_HANDLE_VALUE; ec = boost::system::error_code(); } else { DWORD last_error = ::GetLastError(); ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); } scheduler_.post_deferred_completions(completed_ops); } else { ec = boost::system::error_code(); } return ec; } boost::system::error_code win_object_handle_service::cancel( win_object_handle_service::implementation_type& impl, boost::system::error_code& ec) { if (is_open(impl)) { BOOST_ASIO_HANDLER_OPERATION((scheduler_.context(), "object_handle", &impl, reinterpret_cast<uintmax_t>(impl.wait_handle_), "cancel")); mutex::scoped_lock lock(mutex_); HANDLE wait_handle = impl.wait_handle_; impl.wait_handle_ = INVALID_HANDLE_VALUE; op_queue<operation> completed_ops; while (wait_op* op = impl.op_queue_.front()) { op->ec_ = boost::asio::error::operation_aborted; impl.op_queue_.pop(); completed_ops.push(op); } // We must not hold the lock while calling UnregisterWaitEx. This is // because the registered callback function might be invoked while we are // waiting for UnregisterWaitEx to complete. lock.unlock(); if (wait_handle != INVALID_HANDLE_VALUE) ::UnregisterWaitEx(wait_handle, INVALID_HANDLE_VALUE); ec = boost::system::error_code(); scheduler_.post_deferred_completions(completed_ops); } else { ec = boost::asio::error::bad_descriptor; } return ec; } void win_object_handle_service::wait( win_object_handle_service::implementation_type& impl, boost::system::error_code& ec) { switch (::WaitForSingleObject(impl.handle_, INFINITE)) { case WAIT_FAILED: { DWORD last_error = ::GetLastError(); ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); break; } case WAIT_OBJECT_0: case WAIT_ABANDONED: default: ec = boost::system::error_code(); break; } } void win_object_handle_service::start_wait_op( win_object_handle_service::implementation_type& impl, wait_op* op) { scheduler_.work_started(); if (is_open(impl)) { mutex::scoped_lock lock(mutex_); if (!shutdown_) { impl.op_queue_.push(op); // Only the first operation to be queued gets to register a wait callback. // Subsequent operations have to wait for the first to finish. if (impl.op_queue_.front() == op) register_wait_callback(impl, lock); } else { lock.unlock(); scheduler_.post_deferred_completion(op); } } else { op->ec_ = boost::asio::error::bad_descriptor; scheduler_.post_deferred_completion(op); } } void win_object_handle_service::register_wait_callback( win_object_handle_service::implementation_type& impl, mutex::scoped_lock& lock) { lock.lock(); if (!RegisterWaitForSingleObject(&impl.wait_handle_, impl.handle_, &win_object_handle_service::wait_callback, &impl, INFINITE, WT_EXECUTEONLYONCE)) { DWORD last_error = ::GetLastError(); boost::system::error_code ec(last_error, boost::asio::error::get_system_category()); op_queue<operation> completed_ops; while (wait_op* op = impl.op_queue_.front()) { op->ec_ = ec; impl.op_queue_.pop(); completed_ops.push(op); } lock.unlock(); scheduler_.post_deferred_completions(completed_ops); } } void win_object_handle_service::wait_callback(PVOID param, BOOLEAN) { implementation_type* impl = static_cast<implementation_type>(param); mutex::scoped_lock lock(impl->owner_->mutex_); if (impl->wait_handle_ != INVALID_HANDLE_VALUE) { ::UnregisterWaitEx(impl->wait_handle_, NULL); impl->wait_handle_ = INVALID_HANDLE_VALUE; } if (wait_op op = impl->op_queue_.front()) { op_queue<operation> completed_ops; op->ec_ = boost::system::error_code(); impl->op_queue_.pop(); completed_ops.push(op); if (!impl->op_queue_.empty()) { if (!RegisterWaitForSingleObject(&impl->wait_handle_, impl->handle_, &win_object_handle_service::wait_callback, param, INFINITE, WT_EXECUTEONLYONCE)) { DWORD last_error = ::GetLastError(); boost::system::error_code ec(last_error, boost::asio::error::get_system_category()); while ((op = impl->op_queue_.front()) != 0) { op->ec_ = ec; impl->op_queue_.pop(); completed_ops.push(op); } } } scheduler_impl& sched = impl->owner_->scheduler_; lock.unlock(); sched.post_deferred_completions(completed_ops); } } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE) #endif // BOOST_ASIO_DETAIL_IMPL_WIN_OBJECT_HANDLE_SERVICE_IPP PK��h!\ԕ��impl/win_thread.ippnu��[��// // detail/impl/win_thread.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_WIN_THREAD_IPP #define BOOST_ASIO_DETAIL_IMPL_WIN_THREAD_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_WINDOWS) \ && !defined(BOOST_ASIO_WINDOWS_APP) \ && !defined(UNDER_CE) #include <process.h> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/detail/win_thread.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { win_thread::~win_thread() { ::CloseHandle(thread_); // The exit_event_ handle is deliberately allowed to leak here since it // is an error for the owner of an internal thread not to join() it. } void win_thread::join() { HANDLE handles[2] = { exit_event_, thread_ }; ::WaitForMultipleObjects(2, handles, FALSE, INFINITE); ::CloseHandle(exit_event_); if (terminate_threads()) { ::TerminateThread(thread_, 0); } else { ::QueueUserAPC(apc_function, thread_, 0); ::WaitForSingleObject(thread_, INFINITE); } } std::size_t win_thread::hardware_concurrency() { SYSTEM_INFO system_info; ::GetSystemInfo(&system_info); return system_info.dwNumberOfProcessors; } void win_thread::start_thread(func_base* arg, unsigned int stack_size) { ::HANDLE entry_event = 0; arg->entry_event_ = entry_event = ::CreateEventW(0, true, false, 0); if (!entry_event) { DWORD last_error = ::GetLastError(); delete arg; boost::system::error_code ec(last_error, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "thread.entry_event"); } arg->exit_event_ = exit_event_ = ::CreateEventW(0, true, false, 0); if (!exit_event_) { DWORD last_error = ::GetLastError(); delete arg; boost::system::error_code ec(last_error, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "thread.exit_event"); } unsigned int thread_id = 0; thread_ = reinterpret_cast<HANDLE>(::_beginthreadex(0, stack_size, win_thread_function, arg, 0, &thread_id)); if (!thread_) { DWORD last_error = ::GetLastError(); delete arg; if (entry_event) ::CloseHandle(entry_event); if (exit_event_) ::CloseHandle(exit_event_); boost::system::error_code ec(last_error, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "thread"); } if (entry_event) { ::WaitForSingleObject(entry_event, INFINITE); ::CloseHandle(entry_event); } } unsigned int __stdcall win_thread_function(void* arg) { win_thread::auto_func_base_ptr func = { static_cast<win_thread::func_base>(arg) }; ::SetEvent(func.ptr->entry_event_); func.ptr->run(); // Signal that the thread has finished its work, but rather than returning go // to sleep to put the thread into a well known state. If the thread is being // joined during global object destruction then it may be killed using // TerminateThread (to avoid a deadlock in DllMain). Otherwise, the SleepEx // call will be interrupted using QueueUserAPC and the thread will shut down // cleanly. HANDLE exit_event = func.ptr->exit_event_; delete func.ptr; func.ptr = 0; ::SetEvent(exit_event); ::SleepEx(INFINITE, TRUE); return 0; } #if defined(WINVER) && (WINVER < 0x0500) void __stdcall apc_function(ULONG) {} #else void __stdcall apc_function(ULONG_PTR) {} #endif } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS) // && !defined(BOOST_ASIO_WINDOWS_APP) // && !defined(UNDER_CE) #endif // BOOST_ASIO_DETAIL_IMPL_WIN_THREAD_IPP PK��h!\��4��4��impl/win_static_mutex.ippnu��[��// // detail/impl/win_static_mutex.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_WIN_STATIC_MUTEX_IPP #define BOOST_ASIO_DETAIL_IMPL_WIN_STATIC_MUTEX_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_WINDOWS) #include <cstdio> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/detail/win_static_mutex.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { void win_static_mutex::init() { int error = do_init(); boost::system::error_code ec(error, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "static_mutex"); } int win_static_mutex::do_init() { using namespace std; // For sprintf. wchar_t mutex_name[128]; #if defined(BOOST_ASIO_HAS_SECURE_RTL) swprintf_s( #else // defined(BOOST_ASIO_HAS_SECURE_RTL) _snwprintf( #endif // defined(BOOST_ASIO_HAS_SECURE_RTL) mutex_name, 128, L"asio-58CCDC44-6264-4842-90C2-F3C545CB8AA7-%u-%p", static_cast<unsigned int>(::GetCurrentProcessId()), this); #if defined(BOOST_ASIO_WINDOWS_APP) HANDLE mutex = ::CreateMutexExW(0, mutex_name, CREATE_MUTEX_INITIAL_OWNER, 0); #else // defined(BOOST_ASIO_WINDOWS_APP) HANDLE mutex = ::CreateMutexW(0, TRUE, mutex_name); #endif // defined(BOOST_ASIO_WINDOWS_APP) DWORD last_error = ::GetLastError(); if (mutex == 0) return ::GetLastError(); if (last_error == ERROR_ALREADY_EXISTS) { #if defined(BOOST_ASIO_WINDOWS_APP) ::WaitForSingleObjectEx(mutex, INFINITE, false); #else // defined(BOOST_ASIO_WINDOWS_APP) ::WaitForSingleObject(mutex, INFINITE); #endif // defined(BOOST_ASIO_WINDOWS_APP) } if (initialised_) { ::ReleaseMutex(mutex); ::CloseHandle(mutex); return 0; } #if defined(__MINGW32__) // Not sure if MinGW supports structured exception handling, so for now // we'll just call the Windows API and hope. # if defined(UNDER_CE) ::InitializeCriticalSection(&crit_section_); # else if (!::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000)) { last_error = ::GetLastError(); ::ReleaseMutex(mutex); ::CloseHandle(mutex); return last_error; } # endif #else __try { # if defined(UNDER_CE) ::InitializeCriticalSection(&crit_section_); # elif defined(BOOST_ASIO_WINDOWS_APP) if (!::InitializeCriticalSectionEx(&crit_section_, 0, 0)) { last_error = ::GetLastError(); ::ReleaseMutex(mutex); ::CloseHandle(mutex); return last_error; } # else if (!::InitializeCriticalSectionAndSpinCount(&crit_section_, 0x80000000)) { last_error = ::GetLastError(); ::ReleaseMutex(mutex); ::CloseHandle(mutex); return last_error; } # endif } __except(GetExceptionCode() == STATUS_NO_MEMORY ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) { ::ReleaseMutex(mutex); ::CloseHandle(mutex); return ERROR_OUTOFMEMORY; } #endif initialised_ = true; ::ReleaseMutex(mutex); ::CloseHandle(mutex); return 0; } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS) #endif // BOOST_ASIO_DETAIL_IMPL_WIN_STATIC_MUTEX_IPP PK��h!\>�V��impl/posix_tss_ptr.ippnu��[��// // detail/impl/posix_tss_ptr.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_POSIX_TSS_PTR_IPP #define BOOST_ASIO_DETAIL_IMPL_POSIX_TSS_PTR_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_HAS_PTHREADS) #include <boost/asio/detail/posix_tss_ptr.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { void posix_tss_ptr_create(pthread_key_t& key) { int error = ::pthread_key_create(&key, 0); boost::system::error_code ec(error, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "tss"); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_PTHREADS) #endif // BOOST_ASIO_DETAIL_IMPL_POSIX_TSS_PTR_IPP PK��h!\�j'��impl/throw_error.ippnu��[��// // detail/impl/throw_error.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_THROW_ERROR_IPP #define BOOST_ASIO_DETAIL_IMPL_THROW_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/detail/throw_error.hpp> #include <boost/asio/detail/throw_exception.hpp> #include <boost/system/system_error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { void do_throw_error(const boost::system::error_code& err) { boost::system::system_error e(err); boost::asio::detail::throw_exception(e); } void do_throw_error(const boost::system::error_code& err, const char location) { boost::system::system_error e(err, location); boost::asio::detail::throw_exception(e); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_IMPL_THROW_ERROR_IPP PK��h!\ O@?�a��a��%��impl/win_iocp_socket_service_base.ippnu��[��// // detail/impl/win_iocp_socket_service_base.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_WIN_IOCP_SOCKET_SERVICE_BASE_IPP #define BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_SOCKET_SERVICE_BASE_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_HAS_IOCP) #include <boost/asio/detail/win_iocp_socket_service_base.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { win_iocp_socket_service_base::win_iocp_socket_service_base( execution_context& context) : context_(context), iocp_service_(use_service<win_iocp_io_context>(context)), reactor_(0), connect_ex_(0), nt_set_info_(0), mutex_(), impl_list_(0) { } void win_iocp_socket_service_base::base_shutdown() { // Close all implementations, causing all operations to complete. boost::asio::detail::mutex::scoped_lock lock(mutex_); base_implementation_type* impl = impl_list_; while (impl) { close_for_destruction(impl); impl = impl->next_; } } void win_iocp_socket_service_base::construct( win_iocp_socket_service_base::base_implementation_type& impl) { impl.socket_ = invalid_socket; impl.state_ = 0; impl.cancel_token_.reset(); #if defined(BOOST_ASIO_ENABLE_CANCELIO) impl.safe_cancellation_thread_id_ = 0; #endif // defined(BOOST_ASIO_ENABLE_CANCELIO) // Insert implementation into linked list of all implementations. boost::asio::detail::mutex::scoped_lock lock(mutex_); impl.next_ = impl_list_; impl.prev_ = 0; if (impl_list_) impl_list_->prev_ = &impl; impl_list_ = &impl; } void win_iocp_socket_service_base::base_move_construct( win_iocp_socket_service_base::base_implementation_type& impl, win_iocp_socket_service_base::base_implementation_type& other_impl) BOOST_ASIO_NOEXCEPT { impl.socket_ = other_impl.socket_; other_impl.socket_ = invalid_socket; impl.state_ = other_impl.state_; other_impl.state_ = 0; impl.cancel_token_ = other_impl.cancel_token_; other_impl.cancel_token_.reset(); #if defined(BOOST_ASIO_ENABLE_CANCELIO) impl.safe_cancellation_thread_id_ = other_impl.safe_cancellation_thread_id_; other_impl.safe_cancellation_thread_id_ = 0; #endif // defined(BOOST_ASIO_ENABLE_CANCELIO) // Insert implementation into linked list of all implementations. boost::asio::detail::mutex::scoped_lock lock(mutex_); impl.next_ = impl_list_; impl.prev_ = 0; if (impl_list_) impl_list_->prev_ = &impl; impl_list_ = &impl; } void win_iocp_socket_service_base::base_move_assign( win_iocp_socket_service_base::base_implementation_type& impl, win_iocp_socket_service_base& other_service, win_iocp_socket_service_base::base_implementation_type& other_impl) { close_for_destruction(impl); if (this != &other_service) { // Remove implementation from linked list of all implementations. boost::asio::detail::mutex::scoped_lock lock(mutex_); if (impl_list_ == &impl) impl_list_ = impl.next_; if (impl.prev_) impl.prev_->next_ = impl.next_; if (impl.next_) impl.next_->prev_= impl.prev_; impl.next_ = 0; impl.prev_ = 0; } impl.socket_ = other_impl.socket_; other_impl.socket_ = invalid_socket; impl.state_ = other_impl.state_; other_impl.state_ = 0; impl.cancel_token_ = other_impl.cancel_token_; other_impl.cancel_token_.reset(); #if defined(BOOST_ASIO_ENABLE_CANCELIO) impl.safe_cancellation_thread_id_ = other_impl.safe_cancellation_thread_id_; other_impl.safe_cancellation_thread_id_ = 0; #endif // defined(BOOST_ASIO_ENABLE_CANCELIO) if (this != &other_service) { // Insert implementation into linked list of all implementations. boost::asio::detail::mutex::scoped_lock lock(other_service.mutex_); impl.next_ = other_service.impl_list_; impl.prev_ = 0; if (other_service.impl_list_) other_service.impl_list_->prev_ = &impl; other_service.impl_list_ = &impl; } } void win_iocp_socket_service_base::destroy( win_iocp_socket_service_base::base_implementation_type& impl) { close_for_destruction(impl); // Remove implementation from linked list of all implementations. boost::asio::detail::mutex::scoped_lock lock(mutex_); if (impl_list_ == &impl) impl_list_ = impl.next_; if (impl.prev_) impl.prev_->next_ = impl.next_; if (impl.next_) impl.next_->prev_= impl.prev_; impl.next_ = 0; impl.prev_ = 0; } boost::system::error_code win_iocp_socket_service_base::close( win_iocp_socket_service_base::base_implementation_type& impl, boost::system::error_code& ec) { if (is_open(impl)) { BOOST_ASIO_HANDLER_OPERATION((iocp_service_.context(), "socket", &impl, impl.socket_, "close")); // Check if the reactor was created, in which case we need to close the // socket on the reactor as well to cancel any operations that might be // running there. select_reactor r = static_cast<select_reactor>( interlocked_compare_exchange_pointer( reinterpret_cast<void>(&reactor_), 0, 0)); if (r) r->deregister_descriptor(impl.socket_, impl.reactor_data_, true); socket_ops::close(impl.socket_, impl.state_, false, ec); if (r) r->cleanup_descriptor_data(impl.reactor_data_); } else { ec = boost::system::error_code(); } impl.socket_ = invalid_socket; impl.state_ = 0; impl.cancel_token_.reset(); #if defined(BOOST_ASIO_ENABLE_CANCELIO) impl.safe_cancellation_thread_id_ = 0; #endif // defined(BOOST_ASIO_ENABLE_CANCELIO) return ec; } socket_type win_iocp_socket_service_base::release( win_iocp_socket_service_base::base_implementation_type& impl, boost::system::error_code& ec) { if (!is_open(impl)) return invalid_socket; cancel(impl, ec); if (ec) return invalid_socket; nt_set_info_fn fn = get_nt_set_info(); if (fn == 0) { ec = boost::asio::error::operation_not_supported; return invalid_socket; } HANDLE sock_as_handle = reinterpret_cast<HANDLE>(impl.socket_); ULONG_PTR iosb[2] = { 0, 0 }; void info[2] = { 0, 0 }; if (fn(sock_as_handle, iosb, &info, sizeof(info), 61 /* FileReplaceCompletionInformation /)) { ec = boost::asio::error::operation_not_supported; return invalid_socket; } socket_type tmp = impl.socket_; impl.socket_ = invalid_socket; return tmp; } boost::system::error_code win_iocp_socket_service_base::cancel( win_iocp_socket_service_base::base_implementation_type& impl, boost::system::error_code& ec) { if (!is_open(impl)) { ec = boost::asio::error::bad_descriptor; return ec; } BOOST_ASIO_HANDLER_OPERATION((iocp_service_.context(), "socket", &impl, impl.socket_, "cancel")); if (FARPROC cancel_io_ex_ptr = ::GetProcAddress( ::GetModuleHandleA("KERNEL32"), "CancelIoEx")) { // The version of Windows supports cancellation from any thread. typedef BOOL (WINAPI cancel_io_ex_t)(HANDLE, LPOVERLAPPED); cancel_io_ex_t cancel_io_ex = reinterpret_cast<cancel_io_ex_t>( reinterpret_cast<void>(cancel_io_ex_ptr)); socket_type sock = impl.socket_; HANDLE sock_as_handle = reinterpret_cast<HANDLE>(sock); if (!cancel_io_ex(sock_as_handle, 0)) { DWORD last_error = ::GetLastError(); if (last_error == ERROR_NOT_FOUND) { // ERROR_NOT_FOUND means that there were no operations to be // cancelled. We swallow this error to match the behaviour on other // platforms. ec = boost::system::error_code(); } else { ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); } } else { ec = boost::system::error_code(); } } #if defined(BOOST_ASIO_ENABLE_CANCELIO) else if (impl.safe_cancellation_thread_id_ == 0) { // No operations have been started, so there's nothing to cancel. ec = boost::system::error_code(); } else if (impl.safe_cancellation_thread_id_ == ::GetCurrentThreadId()) { // Asynchronous operations have been started from the current thread only, // so it is safe to try to cancel them using CancelIo. socket_type sock = impl.socket_; HANDLE sock_as_handle = reinterpret_cast<HANDLE>(sock); if (!::CancelIo(sock_as_handle)) { DWORD last_error = ::GetLastError(); ec = boost::system::error_code(last_error, boost::asio::error::get_system_category()); } else { ec = boost::system::error_code(); } } else { // Asynchronous operations have been started from more than one thread, // so cancellation is not safe. ec = boost::asio::error::operation_not_supported; } #else // defined(BOOST_ASIO_ENABLE_CANCELIO) else { // Cancellation is not supported as CancelIo may not be used. ec = boost::asio::error::operation_not_supported; } #endif // defined(BOOST_ASIO_ENABLE_CANCELIO) // Cancel any operations started via the reactor. if (!ec) { select_reactor r = static_cast<select_reactor>( interlocked_compare_exchange_pointer( reinterpret_cast<void>(&reactor_), 0, 0)); if (r) r->cancel_ops(impl.socket_, impl.reactor_data_); } return ec; } boost::system::error_code win_iocp_socket_service_base::do_open( win_iocp_socket_service_base::base_implementation_type& impl, int family, int type, int protocol, boost::system::error_code& ec) { if (is_open(impl)) { ec = boost::asio::error::already_open; return ec; } socket_holder sock(socket_ops::socket(family, type, protocol, ec)); if (sock.get() == invalid_socket) return ec; HANDLE sock_as_handle = reinterpret_cast<HANDLE>(sock.get()); if (iocp_service_.register_handle(sock_as_handle, ec)) return ec; impl.socket_ = sock.release(); switch (type) { case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break; case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break; default: impl.state_ = 0; break; } impl.cancel_token_.reset(static_cast<void>(0), socket_ops::noop_deleter()); ec = boost::system::error_code(); return ec; } boost::system::error_code win_iocp_socket_service_base::do_assign( win_iocp_socket_service_base::base_implementation_type& impl, int type, socket_type native_socket, boost::system::error_code& ec) { if (is_open(impl)) { ec = boost::asio::error::already_open; return ec; } HANDLE sock_as_handle = reinterpret_cast<HANDLE>(native_socket); if (iocp_service_.register_handle(sock_as_handle, ec)) return ec; impl.socket_ = native_socket; switch (type) { case SOCK_STREAM: impl.state_ = socket_ops::stream_oriented; break; case SOCK_DGRAM: impl.state_ = socket_ops::datagram_oriented; break; default: impl.state_ = 0; break; } impl.cancel_token_.reset(static_cast<void>(0), socket_ops::noop_deleter()); ec = boost::system::error_code(); return ec; } void win_iocp_socket_service_base::start_send_op( win_iocp_socket_service_base::base_implementation_type& impl, WSABUF buffers, std::size_t buffer_count, socket_base::message_flags flags, bool noop, operation* op) { update_cancellation_thread_id(impl); iocp_service_.work_started(); if (noop) iocp_service_.on_completion(op); else if (!is_open(impl)) iocp_service_.on_completion(op, boost::asio::error::bad_descriptor); else { DWORD bytes_transferred = 0; int result = ::WSASend(impl.socket_, buffers, static_cast<DWORD>(buffer_count), &bytes_transferred, flags, op, 0); DWORD last_error = ::WSAGetLastError(); if (last_error == ERROR_PORT_UNREACHABLE) last_error = WSAECONNREFUSED; if (result != 0 && last_error != WSA_IO_PENDING) iocp_service_.on_completion(op, last_error, bytes_transferred); else iocp_service_.on_pending(op); } } void win_iocp_socket_service_base::start_send_to_op( win_iocp_socket_service_base::base_implementation_type& impl, WSABUF* buffers, std::size_t buffer_count, const socket_addr_type* addr, int addrlen, socket_base::message_flags flags, operation* op) { update_cancellation_thread_id(impl); iocp_service_.work_started(); if (!is_open(impl)) iocp_service_.on_completion(op, boost::asio::error::bad_descriptor); else { DWORD bytes_transferred = 0; int result = ::WSASendTo(impl.socket_, buffers, static_cast<DWORD>(buffer_count), &bytes_transferred, flags, addr, addrlen, op, 0); DWORD last_error = ::WSAGetLastError(); if (last_error == ERROR_PORT_UNREACHABLE) last_error = WSAECONNREFUSED; if (result != 0 && last_error != WSA_IO_PENDING) iocp_service_.on_completion(op, last_error, bytes_transferred); else iocp_service_.on_pending(op); } } void win_iocp_socket_service_base::start_receive_op( win_iocp_socket_service_base::base_implementation_type& impl, WSABUF* buffers, std::size_t buffer_count, socket_base::message_flags flags, bool noop, operation* op) { update_cancellation_thread_id(impl); iocp_service_.work_started(); if (noop) iocp_service_.on_completion(op); else if (!is_open(impl)) iocp_service_.on_completion(op, boost::asio::error::bad_descriptor); else { DWORD bytes_transferred = 0; DWORD recv_flags = flags; int result = ::WSARecv(impl.socket_, buffers, static_cast<DWORD>(buffer_count), &bytes_transferred, &recv_flags, op, 0); DWORD last_error = ::WSAGetLastError(); if (last_error == ERROR_NETNAME_DELETED) last_error = WSAECONNRESET; else if (last_error == ERROR_PORT_UNREACHABLE) last_error = WSAECONNREFUSED; if (result != 0 && last_error != WSA_IO_PENDING) iocp_service_.on_completion(op, last_error, bytes_transferred); else iocp_service_.on_pending(op); } } void win_iocp_socket_service_base::start_null_buffers_receive_op( win_iocp_socket_service_base::base_implementation_type& impl, socket_base::message_flags flags, reactor_op* op) { if ((impl.state_ & socket_ops::stream_oriented) != 0) { // For stream sockets on Windows, we may issue a 0-byte overlapped // WSARecv to wait until there is data available on the socket. ::WSABUF buf = { 0, 0 }; start_receive_op(impl, &buf, 1, flags, false, op); } else { start_reactor_op(impl, (flags & socket_base::message_out_of_band) ? select_reactor::except_op : select_reactor::read_op, op); } } void win_iocp_socket_service_base::start_receive_from_op( win_iocp_socket_service_base::base_implementation_type& impl, WSABUF* buffers, std::size_t buffer_count, socket_addr_type* addr, socket_base::message_flags flags, int* addrlen, operation* op) { update_cancellation_thread_id(impl); iocp_service_.work_started(); if (!is_open(impl)) iocp_service_.on_completion(op, boost::asio::error::bad_descriptor); else { DWORD bytes_transferred = 0; DWORD recv_flags = flags; int result = ::WSARecvFrom(impl.socket_, buffers, static_cast<DWORD>(buffer_count), &bytes_transferred, &recv_flags, addr, addrlen, op, 0); DWORD last_error = ::WSAGetLastError(); if (last_error == ERROR_PORT_UNREACHABLE) last_error = WSAECONNREFUSED; if (result != 0 && last_error != WSA_IO_PENDING) iocp_service_.on_completion(op, last_error, bytes_transferred); else iocp_service_.on_pending(op); } } void win_iocp_socket_service_base::start_accept_op( win_iocp_socket_service_base::base_implementation_type& impl, bool peer_is_open, socket_holder& new_socket, int family, int type, int protocol, void* output_buffer, DWORD address_length, operation* op) { update_cancellation_thread_id(impl); iocp_service_.work_started(); if (!is_open(impl)) iocp_service_.on_completion(op, boost::asio::error::bad_descriptor); else if (peer_is_open) iocp_service_.on_completion(op, boost::asio::error::already_open); else { boost::system::error_code ec; new_socket.reset(socket_ops::socket(family, type, protocol, ec)); if (new_socket.get() == invalid_socket) iocp_service_.on_completion(op, ec); else { DWORD bytes_read = 0; BOOL result = ::AcceptEx(impl.socket_, new_socket.get(), output_buffer, 0, address_length, address_length, &bytes_read, op); DWORD last_error = ::WSAGetLastError(); if (!result && last_error != WSA_IO_PENDING) iocp_service_.on_completion(op, last_error); else iocp_service_.on_pending(op); } } } void win_iocp_socket_service_base::restart_accept_op( socket_type s, socket_holder& new_socket, int family, int type, int protocol, void* output_buffer, DWORD address_length, operation* op) { new_socket.reset(); iocp_service_.work_started(); boost::system::error_code ec; new_socket.reset(socket_ops::socket(family, type, protocol, ec)); if (new_socket.get() == invalid_socket) iocp_service_.on_completion(op, ec); else { DWORD bytes_read = 0; BOOL result = ::AcceptEx(s, new_socket.get(), output_buffer, 0, address_length, address_length, &bytes_read, op); DWORD last_error = ::WSAGetLastError(); if (!result && last_error != WSA_IO_PENDING) iocp_service_.on_completion(op, last_error); else iocp_service_.on_pending(op); } } void win_iocp_socket_service_base::start_reactor_op( win_iocp_socket_service_base::base_implementation_type& impl, int op_type, reactor_op* op) { select_reactor& r = get_reactor(); update_cancellation_thread_id(impl); if (is_open(impl)) { r.start_op(op_type, impl.socket_, impl.reactor_data_, op, false, false); return; } else op->ec_ = boost::asio::error::bad_descriptor; iocp_service_.post_immediate_completion(op, false); } void win_iocp_socket_service_base::start_connect_op( win_iocp_socket_service_base::base_implementation_type& impl, int family, int type, const socket_addr_type* addr, std::size_t addrlen, win_iocp_socket_connect_op_base* op) { // If ConnectEx is available, use that. if (family == BOOST_ASIO_OS_DEF(AF_INET) \|\| family == BOOST_ASIO_OS_DEF(AF_INET6)) { if (connect_ex_fn connect_ex = get_connect_ex(impl, type)) { union address_union { socket_addr_type base; sockaddr_in4_type v4; sockaddr_in6_type v6; } a; using namespace std; // For memset. memset(&a, 0, sizeof(a)); a.base.sa_family = family; socket_ops::bind(impl.socket_, &a.base, family == BOOST_ASIO_OS_DEF(AF_INET) ? sizeof(a.v4) : sizeof(a.v6), op->ec_); if (op->ec_ && op->ec_ != boost::asio::error::invalid_argument) { iocp_service_.post_immediate_completion(op, false); return; } op->connect_ex_ = true; update_cancellation_thread_id(impl); iocp_service_.work_started(); BOOL result = connect_ex(impl.socket_, addr, static_cast<int>(addrlen), 0, 0, 0, op); DWORD last_error = ::WSAGetLastError(); if (!result && last_error != WSA_IO_PENDING) iocp_service_.on_completion(op, last_error); else iocp_service_.on_pending(op); return; } } // Otherwise, fall back to a reactor-based implementation. select_reactor& r = get_reactor(); update_cancellation_thread_id(impl); if ((impl.state_ & socket_ops::non_blocking) != 0 \|\| socket_ops::set_internal_non_blocking( impl.socket_, impl.state_, true, op->ec_)) { if (socket_ops::connect(impl.socket_, addr, addrlen, op->ec_) != 0) { if (op->ec_ == boost::asio::error::in_progress \|\| op->ec_ == boost::asio::error::would_block) { op->ec_ = boost::system::error_code(); r.start_op(select_reactor::connect_op, impl.socket_, impl.reactor_data_, op, false, false); return; } } } r.post_immediate_completion(op, false); } void win_iocp_socket_service_base::close_for_destruction( win_iocp_socket_service_base::base_implementation_type& impl) { if (is_open(impl)) { BOOST_ASIO_HANDLER_OPERATION((iocp_service_.context(), "socket", &impl, impl.socket_, "close")); // Check if the reactor was created, in which case we need to close the // socket on the reactor as well to cancel any operations that might be // running there. select_reactor* r = static_cast<select_reactor>( interlocked_compare_exchange_pointer( reinterpret_cast<void>(&reactor_), 0, 0)); if (r) r->deregister_descriptor(impl.socket_, impl.reactor_data_, true); boost::system::error_code ignored_ec; socket_ops::close(impl.socket_, impl.state_, true, ignored_ec); if (r) r->cleanup_descriptor_data(impl.reactor_data_); } impl.socket_ = invalid_socket; impl.state_ = 0; impl.cancel_token_.reset(); #if defined(BOOST_ASIO_ENABLE_CANCELIO) impl.safe_cancellation_thread_id_ = 0; #endif // defined(BOOST_ASIO_ENABLE_CANCELIO) } void win_iocp_socket_service_base::update_cancellation_thread_id( win_iocp_socket_service_base::base_implementation_type& impl) { #if defined(BOOST_ASIO_ENABLE_CANCELIO) if (impl.safe_cancellation_thread_id_ == 0) impl.safe_cancellation_thread_id_ = ::GetCurrentThreadId(); else if (impl.safe_cancellation_thread_id_ != ::GetCurrentThreadId()) impl.safe_cancellation_thread_id_ = ~DWORD(0); #else // defined(BOOST_ASIO_ENABLE_CANCELIO) (void)impl; #endif // defined(BOOST_ASIO_ENABLE_CANCELIO) } select_reactor& win_iocp_socket_service_base::get_reactor() { select_reactor r = static_cast<select_reactor>( interlocked_compare_exchange_pointer( reinterpret_cast<void>(&reactor_), 0, 0)); if (!r) { r = &(use_service<select_reactor>(context_)); interlocked_exchange_pointer(reinterpret_cast<void>(&reactor_), r); } return r; } win_iocp_socket_service_base::connect_ex_fn win_iocp_socket_service_base::get_connect_ex( win_iocp_socket_service_base::base_implementation_type& impl, int type) { #if defined(BOOST_ASIO_DISABLE_CONNECTEX) (void)impl; (void)type; return 0; #else // defined(BOOST_ASIO_DISABLE_CONNECTEX) if (type != BOOST_ASIO_OS_DEF(SOCK_STREAM) && type != BOOST_ASIO_OS_DEF(SOCK_SEQPACKET)) return 0; void* ptr = interlocked_compare_exchange_pointer(&connect_ex_, 0, 0); if (!ptr) { GUID guid = { 0x25a207b9, 0xddf3, 0x4660, { 0x8e, 0xe9, 0x76, 0xe5, 0x8c, 0x74, 0x06, 0x3e } }; DWORD bytes = 0; if (::WSAIoctl(impl.socket_, SIO_GET_EXTENSION_FUNCTION_POINTER, &guid, sizeof(guid), &ptr, sizeof(ptr), &bytes, 0, 0) != 0) { // Set connect_ex_ to a special value to indicate that ConnectEx is // unavailable. That way we won't bother trying to look it up again. ptr = this; } interlocked_exchange_pointer(&connect_ex_, ptr); } return reinterpret_cast<connect_ex_fn>(ptr == this ? 0 : ptr); #endif // defined(BOOST_ASIO_DISABLE_CONNECTEX) } win_iocp_socket_service_base::nt_set_info_fn win_iocp_socket_service_base::get_nt_set_info() { void* ptr = interlocked_compare_exchange_pointer(&nt_set_info_, 0, 0); if (!ptr) { if (HMODULE h = ::GetModuleHandleA("NTDLL.DLL")) ptr = reinterpret_cast<void>(GetProcAddress(h, "NtSetInformationFile")); // On failure, set nt_set_info_ to a special value to indicate that the // NtSetInformationFile function is unavailable. That way we won't bother // trying to look it up again. interlocked_exchange_pointer(&nt_set_info_, ptr ? ptr : this); } return reinterpret_cast<nt_set_info_fn>(ptr == this ? 0 : ptr); } void win_iocp_socket_service_base::interlocked_compare_exchange_pointer( void** dest, void* exch, void* cmp) { #if defined(_M_IX86) return reinterpret_cast<void>(InterlockedCompareExchange( reinterpret_cast<PLONG>(dest), reinterpret_cast<LONG>(exch), reinterpret_cast<LONG>(cmp))); #else return InterlockedCompareExchangePointer(dest, exch, cmp); #endif } void win_iocp_socket_service_base::interlocked_exchange_pointer( void** dest, void* val) { #if defined(_M_IX86) return reinterpret_cast<void>(InterlockedExchange( reinterpret_cast<PLONG>(dest), reinterpret_cast<LONG>(val))); #else return InterlockedExchangePointer(dest, val); #endif } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #endif // BOOST_ASIO_DETAIL_IMPL_WIN_IOCP_SOCKET_SERVICE_BASE_IPP PK��h!\FZ� �� impl/timer_queue_set.ippnu��[��// // detail/impl/timer_queue_set.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_TIMER_QUEUE_SET_IPP #define BOOST_ASIO_DETAIL_IMPL_TIMER_QUEUE_SET_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/detail/timer_queue_set.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { timer_queue_set::timer_queue_set() : first_(0) { } void timer_queue_set::insert(timer_queue_base q) { q->next_ = first_; first_ = q; } void timer_queue_set::erase(timer_queue_base* q) { if (first_) { if (q == first_) { first_ = q->next_; q->next_ = 0; return; } for (timer_queue_base* p = first_; p->next_; p = p->next_) { if (p->next_ == q) { p->next_ = q->next_; q->next_ = 0; return; } } } } bool timer_queue_set::all_empty() const { for (timer_queue_base* p = first_; p; p = p->next_) if (!p->empty()) return false; return true; } long timer_queue_set::wait_duration_msec(long max_duration) const { long min_duration = max_duration; for (timer_queue_base* p = first_; p; p = p->next_) min_duration = p->wait_duration_msec(min_duration); return min_duration; } long timer_queue_set::wait_duration_usec(long max_duration) const { long min_duration = max_duration; for (timer_queue_base* p = first_; p; p = p->next_) min_duration = p->wait_duration_usec(min_duration); return min_duration; } void timer_queue_set::get_ready_timers(op_queue<operation>& ops) { for (timer_queue_base* p = first_; p; p = p->next_) p->get_ready_timers(ops); } void timer_queue_set::get_all_timers(op_queue<operation>& ops) { for (timer_queue_base* p = first_; p; p = p->next_) p->get_all_timers(ops); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_IMPL_TIMER_QUEUE_SET_IPP PK��h!\PL��r��r��impl/null_event.ippnu��[��// // detail/impl/null_event.ipp // ~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IMPL_NULL_EVENT_IPP #define BOOST_ASIO_DETAIL_IMPL_NULL_EVENT_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_WINDOWS_RUNTIME) # include <thread> #elif defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) # include <boost/asio/detail/socket_types.hpp> #else # include <unistd.h> # if defined(__hpux) # include <sys/time.h> # endif # if !defined(__hpux) \|\| defined(__SELECT) # include <sys/select.h> # endif #endif #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { void null_event::do_wait() { #if defined(BOOST_ASIO_WINDOWS_RUNTIME) std::this_thread::sleep_until((std::chrono::steady_clock::time_point::max)()); #elif defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) ::Sleep(INFINITE); #else ::pause(); #endif } void null_event::do_wait_for_usec(long usec) { #if defined(BOOST_ASIO_WINDOWS_RUNTIME) std::this_thread::sleep_for(std::chrono::microseconds(usec)); #elif defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) ::Sleep(usec / 1000); #elif defined(__hpux) && defined(__SELECT) timespec ts; ts.tv_sec = usec / 1000000; ts.tv_nsec = (usec % 1000000) * 1000; ::pselect(0, 0, 0, 0, &ts, 0); #else timeval tv; tv.tv_sec = usec / 1000000; tv.tv_usec = usec % 1000000; ::select(0, 0, 0, 0, &tv); #endif } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_IMPL_NULL_EVENT_IPP PK��h!\�$��L��L�� reactive_socket_service_base.hppnu��[��// // detail/reactive_socket_service_base.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_REACTIVE_SOCKET_SERVICE_BASE_HPP #define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_BASE_HPP #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_HAS_IOCP) \ && !defined(BOOST_ASIO_WINDOWS_RUNTIME) #include <boost/asio/buffer.hpp> #include <boost/asio/error.hpp> #include <boost/asio/execution_context.hpp> #include <boost/asio/socket_base.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/reactive_null_buffers_op.hpp> #include <boost/asio/detail/reactive_socket_recv_op.hpp> #include <boost/asio/detail/reactive_socket_recvmsg_op.hpp> #include <boost/asio/detail/reactive_socket_send_op.hpp> #include <boost/asio/detail/reactive_wait_op.hpp> #include <boost/asio/detail/reactor.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/socket_holder.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class reactive_socket_service_base { public: // The native type of a socket. typedef socket_type native_handle_type; // The implementation type of the socket. struct base_implementation_type { // The native socket representation. socket_type socket_; // The current state of the socket. socket_ops::state_type state_; // Per-descriptor data used by the reactor. reactor::per_descriptor_data reactor_data_; }; // Constructor. BOOST_ASIO_DECL reactive_socket_service_base(execution_context& context); // Destroy all user-defined handler objects owned by the service. BOOST_ASIO_DECL void base_shutdown(); // Construct a new socket implementation. BOOST_ASIO_DECL void construct(base_implementation_type& impl); // Move-construct a new socket implementation. BOOST_ASIO_DECL void base_move_construct(base_implementation_type& impl, base_implementation_type& other_impl) BOOST_ASIO_NOEXCEPT; // Move-assign from another socket implementation. BOOST_ASIO_DECL void base_move_assign(base_implementation_type& impl, reactive_socket_service_base& other_service, base_implementation_type& other_impl); // Destroy a socket implementation. BOOST_ASIO_DECL void destroy(base_implementation_type& impl); // Determine whether the socket is open. bool is_open(const base_implementation_type& impl) const { return impl.socket_ != invalid_socket; } // Destroy a socket implementation. BOOST_ASIO_DECL boost::system::error_code close( base_implementation_type& impl, boost::system::error_code& ec); // Release ownership of the socket. BOOST_ASIO_DECL socket_type release( base_implementation_type& impl, boost::system::error_code& ec); // Get the native socket representation. native_handle_type native_handle(base_implementation_type& impl) { return impl.socket_; } // Cancel all operations associated with the socket. BOOST_ASIO_DECL boost::system::error_code cancel( base_implementation_type& impl, boost::system::error_code& ec); // Determine whether the socket is at the out-of-band data mark. bool at_mark(const base_implementation_type& impl, boost::system::error_code& ec) const { return socket_ops::sockatmark(impl.socket_, ec); } // Determine the number of bytes available for reading. std::size_t available(const base_implementation_type& impl, boost::system::error_code& ec) const { return socket_ops::available(impl.socket_, ec); } // Place the socket into the state where it will listen for new connections. boost::system::error_code listen(base_implementation_type& impl, int backlog, boost::system::error_code& ec) { socket_ops::listen(impl.socket_, backlog, ec); return ec; } // Perform an IO control command on the socket. template <typename IO_Control_Command> boost::system::error_code io_control(base_implementation_type& impl, IO_Control_Command& command, boost::system::error_code& ec) { socket_ops::ioctl(impl.socket_, impl.state_, command.name(), static_cast<ioctl_arg_type>(command.data()), ec); return ec; } // Gets the non-blocking mode of the socket. bool non_blocking(const base_implementation_type& impl) const { return (impl.state_ & socket_ops::user_set_non_blocking) != 0; } // Sets the non-blocking mode of the socket. boost::system::error_code non_blocking(base_implementation_type& impl, bool mode, boost::system::error_code& ec) { socket_ops::set_user_non_blocking(impl.socket_, impl.state_, mode, ec); return ec; } // Gets the non-blocking mode of the native socket implementation. bool native_non_blocking(const base_implementation_type& impl) const { return (impl.state_ & socket_ops::internal_non_blocking) != 0; } // Sets the non-blocking mode of the native socket implementation. boost::system::error_code native_non_blocking(base_implementation_type& impl, bool mode, boost::system::error_code& ec) { socket_ops::set_internal_non_blocking(impl.socket_, impl.state_, mode, ec); return ec; } // Wait for the socket to become ready to read, ready to write, or to have // pending error conditions. boost::system::error_code wait(base_implementation_type& impl, socket_base::wait_type w, boost::system::error_code& ec) { switch (w) { case socket_base::wait_read: socket_ops::poll_read(impl.socket_, impl.state_, -1, ec); break; case socket_base::wait_write: socket_ops::poll_write(impl.socket_, impl.state_, -1, ec); break; case socket_base::wait_error: socket_ops::poll_error(impl.socket_, impl.state_, -1, ec); break; default: ec = boost::asio::error::invalid_argument; break; } return ec; } // Asynchronously wait for the socket to become ready to read, ready to // write, or to have pending error conditions. template <typename Handler, typename IoExecutor> void async_wait(base_implementation_type& impl, socket_base::wait_type w, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef reactive_wait_op<Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(success_ec_, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((reactor_.context(), p.p, "socket", &impl, impl.socket_, "async_wait")); int op_type; switch (w) { case socket_base::wait_read: op_type = reactor::read_op; break; case socket_base::wait_write: op_type = reactor::write_op; break; case socket_base::wait_error: op_type = reactor::except_op; break; default: p.p->ec_ = boost::asio::error::invalid_argument; reactor_.post_immediate_completion(p.p, is_continuation); p.v = p.p = 0; return; } start_op(impl, op_type, p.p, is_continuation, false, false); p.v = p.p = 0; } // Send the given data to the peer. template <typename ConstBufferSequence> size_t send(base_implementation_type& impl, const ConstBufferSequence& buffers, socket_base::message_flags flags, boost::system::error_code& ec) { typedef buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence> bufs_type; if (bufs_type::is_single_buffer) { return socket_ops::sync_send1(impl.socket_, impl.state_, bufs_type::first(buffers).data(), bufs_type::first(buffers).size(), flags, ec); } else { bufs_type bufs(buffers); return socket_ops::sync_send(impl.socket_, impl.state_, bufs.buffers(), bufs.count(), flags, bufs.all_empty(), ec); } } // Wait until data can be sent without blocking. size_t send(base_implementation_type& impl, const null_buffers&, socket_base::message_flags, boost::system::error_code& ec) { // Wait for socket to become ready. socket_ops::poll_write(impl.socket_, impl.state_, -1, ec); return 0; } // Start an asynchronous send. The data being sent must be valid for the // lifetime of the asynchronous operation. template <typename ConstBufferSequence, typename Handler, typename IoExecutor> void async_send(base_implementation_type& impl, const ConstBufferSequence& buffers, socket_base::message_flags flags, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef reactive_socket_send_op< ConstBufferSequence, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(success_ec_, impl.socket_, impl.state_, buffers, flags, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((reactor_.context(), p.p, "socket", &impl, impl.socket_, "async_send")); start_op(impl, reactor::write_op, p.p, is_continuation, true, ((impl.state_ & socket_ops::stream_oriented) && buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence>::all_empty(buffers))); p.v = p.p = 0; } // Start an asynchronous wait until data can be sent without blocking. template <typename Handler, typename IoExecutor> void async_send(base_implementation_type& impl, const null_buffers&, socket_base::message_flags, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef reactive_null_buffers_op<Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(success_ec_, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((reactor_.context(), p.p, "socket", &impl, impl.socket_, "async_send(null_buffers)")); start_op(impl, reactor::write_op, p.p, is_continuation, false, false); p.v = p.p = 0; } // Receive some data from the peer. Returns the number of bytes received. template <typename MutableBufferSequence> size_t receive(base_implementation_type& impl, const MutableBufferSequence& buffers, socket_base::message_flags flags, boost::system::error_code& ec) { typedef buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence> bufs_type; if (bufs_type::is_single_buffer) { return socket_ops::sync_recv1(impl.socket_, impl.state_, bufs_type::first(buffers).data(), bufs_type::first(buffers).size(), flags, ec); } else { bufs_type bufs(buffers); return socket_ops::sync_recv(impl.socket_, impl.state_, bufs.buffers(), bufs.count(), flags, bufs.all_empty(), ec); } } // Wait until data can be received without blocking. size_t receive(base_implementation_type& impl, const null_buffers&, socket_base::message_flags, boost::system::error_code& ec) { // Wait for socket to become ready. socket_ops::poll_read(impl.socket_, impl.state_, -1, ec); return 0; } // Start an asynchronous receive. The buffer for the data being received // must be valid for the lifetime of the asynchronous operation. template <typename MutableBufferSequence, typename Handler, typename IoExecutor> void async_receive(base_implementation_type& impl, const MutableBufferSequence& buffers, socket_base::message_flags flags, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef reactive_socket_recv_op< MutableBufferSequence, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(success_ec_, impl.socket_, impl.state_, buffers, flags, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((reactor_.context(), p.p, "socket", &impl, impl.socket_, "async_receive")); start_op(impl, (flags & socket_base::message_out_of_band) ? reactor::except_op : reactor::read_op, p.p, is_continuation, (flags & socket_base::message_out_of_band) == 0, ((impl.state_ & socket_ops::stream_oriented) && buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence>::all_empty(buffers))); p.v = p.p = 0; } // Wait until data can be received without blocking. template <typename Handler, typename IoExecutor> void async_receive(base_implementation_type& impl, const null_buffers&, socket_base::message_flags flags, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef reactive_null_buffers_op<Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(success_ec_, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((reactor_.context(), p.p, "socket", &impl, impl.socket_, "async_receive(null_buffers)")); start_op(impl, (flags & socket_base::message_out_of_band) ? reactor::except_op : reactor::read_op, p.p, is_continuation, false, false); p.v = p.p = 0; } // Receive some data with associated flags. Returns the number of bytes // received. template <typename MutableBufferSequence> size_t receive_with_flags(base_implementation_type& impl, const MutableBufferSequence& buffers, socket_base::message_flags in_flags, socket_base::message_flags& out_flags, boost::system::error_code& ec) { buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence> bufs(buffers); return socket_ops::sync_recvmsg(impl.socket_, impl.state_, bufs.buffers(), bufs.count(), in_flags, out_flags, ec); } // Wait until data can be received without blocking. size_t receive_with_flags(base_implementation_type& impl, const null_buffers&, socket_base::message_flags, socket_base::message_flags& out_flags, boost::system::error_code& ec) { // Wait for socket to become ready. socket_ops::poll_read(impl.socket_, impl.state_, -1, ec); // Clear out_flags, since we cannot give it any other sensible value when // performing a null_buffers operation. out_flags = 0; return 0; } // Start an asynchronous receive. The buffer for the data being received // must be valid for the lifetime of the asynchronous operation. template <typename MutableBufferSequence, typename Handler, typename IoExecutor> void async_receive_with_flags(base_implementation_type& impl, const MutableBufferSequence& buffers, socket_base::message_flags in_flags, socket_base::message_flags& out_flags, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef reactive_socket_recvmsg_op< MutableBufferSequence, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(success_ec_, impl.socket_, buffers, in_flags, out_flags, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((reactor_.context(), p.p, "socket", &impl, impl.socket_, "async_receive_with_flags")); start_op(impl, (in_flags & socket_base::message_out_of_band) ? reactor::except_op : reactor::read_op, p.p, is_continuation, (in_flags & socket_base::message_out_of_band) == 0, false); p.v = p.p = 0; } // Wait until data can be received without blocking. template <typename Handler, typename IoExecutor> void async_receive_with_flags(base_implementation_type& impl, const null_buffers&, socket_base::message_flags in_flags, socket_base::message_flags& out_flags, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef reactive_null_buffers_op<Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(success_ec_, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((reactor_.context(), p.p, "socket", &impl, impl.socket_, "async_receive_with_flags(null_buffers)")); // Clear out_flags, since we cannot give it any other sensible value when // performing a null_buffers operation. out_flags = 0; start_op(impl, (in_flags & socket_base::message_out_of_band) ? reactor::except_op : reactor::read_op, p.p, is_continuation, false, false); p.v = p.p = 0; } protected: // Open a new socket implementation. BOOST_ASIO_DECL boost::system::error_code do_open( base_implementation_type& impl, int af, int type, int protocol, boost::system::error_code& ec); // Assign a native socket to a socket implementation. BOOST_ASIO_DECL boost::system::error_code do_assign( base_implementation_type& impl, int type, const native_handle_type& native_socket, boost::system::error_code& ec); // Start the asynchronous read or write operation. BOOST_ASIO_DECL void start_op(base_implementation_type& impl, int op_type, reactor_op* op, bool is_continuation, bool is_non_blocking, bool noop); // Start the asynchronous accept operation. BOOST_ASIO_DECL void start_accept_op(base_implementation_type& impl, reactor_op* op, bool is_continuation, bool peer_is_open); // Start the asynchronous connect operation. BOOST_ASIO_DECL void start_connect_op(base_implementation_type& impl, reactor_op* op, bool is_continuation, const socket_addr_type* addr, size_t addrlen); // The selector that performs event demultiplexing for the service. reactor& reactor_; // Cached success value to avoid accessing category singleton. const boost::system::error_code success_ec_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/reactive_socket_service_base.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // !defined(BOOST_ASIO_HAS_IOCP) // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_BASE_HPP PK��h!\a�Q0��0��handler_work.hppnu��[��// // detail/handler_work.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_HANDLER_WORK_HPP #define BOOST_ASIO_DETAIL_HANDLER_WORK_HPP #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/associated_executor.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/type_traits.hpp> #include <boost/asio/execution/allocator.hpp> #include <boost/asio/execution/blocking.hpp> #include <boost/asio/execution/execute.hpp> #include <boost/asio/execution/executor.hpp> #include <boost/asio/execution/outstanding_work.hpp> #include <boost/asio/executor_work_guard.hpp> #include <boost/asio/prefer.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { class executor; class io_context; namespace execution { #if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) template <typename...> class any_executor; #else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) template <typename, typename, typename, typename, typename, typename, typename, typename, typename> class any_executor; #endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) } // namespace execution namespace detail { template <typename Executor, typename CandidateExecutor = void, typename IoContext = io_context, typename PolymorphicExecutor = executor, typename = void> class handler_work_base { public: explicit handler_work_base(const Executor& ex) BOOST_ASIO_NOEXCEPT : executor_(boost::asio::prefer(ex, execution::outstanding_work.tracked)) { } template <typename OtherExecutor> handler_work_base(const Executor& ex, const OtherExecutor&) BOOST_ASIO_NOEXCEPT : executor_(boost::asio::prefer(ex, execution::outstanding_work.tracked)) { } handler_work_base(const handler_work_base& other) BOOST_ASIO_NOEXCEPT : executor_(other.executor_) { } #if defined(BOOST_ASIO_HAS_MOVE) handler_work_base(handler_work_base&& other) BOOST_ASIO_NOEXCEPT : executor_(BOOST_ASIO_MOVE_CAST(executor_type)(other.executor_)) { } #endif // defined(BOOST_ASIO_HAS_MOVE) bool owns_work() const BOOST_ASIO_NOEXCEPT { return true; } template <typename Function, typename Handler> void dispatch(Function& function, Handler& handler) { execution::execute( boost::asio::prefer(executor_, execution::blocking.possibly, execution::allocator((get_associated_allocator)(handler))), BOOST_ASIO_MOVE_CAST(Function)(function)); } private: typedef typename decay< typename prefer_result<Executor, execution::outstanding_work_t::tracked_t >::type >::type executor_type; executor_type executor_; }; template <typename Executor, typename CandidateExecutor, typename IoContext, typename PolymorphicExecutor> class handler_work_base<Executor, CandidateExecutor, IoContext, PolymorphicExecutor, typename enable_if< !execution::is_executor<Executor>::value && (!is_same<Executor, PolymorphicExecutor>::value \|\| !is_same<CandidateExecutor, void>::value) >::type> { public: explicit handler_work_base(const Executor& ex) BOOST_ASIO_NOEXCEPT : executor_(ex), owns_work_(true) { executor_.on_work_started(); } handler_work_base(const Executor& ex, const Executor& candidate) BOOST_ASIO_NOEXCEPT : executor_(ex), owns_work_(ex != candidate) { if (owns_work_) executor_.on_work_started(); } template <typename OtherExecutor> handler_work_base(const Executor& ex, const OtherExecutor&) BOOST_ASIO_NOEXCEPT : executor_(ex), owns_work_(true) { executor_.on_work_started(); } handler_work_base(const handler_work_base& other) BOOST_ASIO_NOEXCEPT : executor_(other.executor_), owns_work_(other.owns_work_) { if (owns_work_) executor_.on_work_started(); } #if defined(BOOST_ASIO_HAS_MOVE) handler_work_base(handler_work_base&& other) BOOST_ASIO_NOEXCEPT : executor_(BOOST_ASIO_MOVE_CAST(Executor)(other.executor_)), owns_work_(other.owns_work_) { other.owns_work_ = false; } #endif // defined(BOOST_ASIO_HAS_MOVE) ~handler_work_base() { if (owns_work_) executor_.on_work_finished(); } bool owns_work() const BOOST_ASIO_NOEXCEPT { return owns_work_; } template <typename Function, typename Handler> void dispatch(Function& function, Handler& handler) { executor_.dispatch(BOOST_ASIO_MOVE_CAST(Function)(function), boost::asio::get_associated_allocator(handler)); } private: Executor executor_; bool owns_work_; }; template <typename Executor, typename IoContext, typename PolymorphicExecutor> class handler_work_base<Executor, void, IoContext, PolymorphicExecutor, typename enable_if< is_same< Executor, typename IoContext::executor_type >::value >::type> { public: explicit handler_work_base(const Executor&) { } bool owns_work() const BOOST_ASIO_NOEXCEPT { return false; } template <typename Function, typename Handler> void dispatch(Function& function, Handler& handler) { // When using a native implementation, I/O completion handlers are // already dispatched according to the execution context's executor's // rules. We can call the function directly. boost_asio_handler_invoke_helpers::invoke(function, handler); } }; template <typename Executor, typename IoContext> class handler_work_base<Executor, void, IoContext, Executor> { public: explicit handler_work_base(const Executor& ex) BOOST_ASIO_NOEXCEPT #if !defined(BOOST_ASIO_NO_TYPEID) : executor_( ex.target_type() == typeid(typename IoContext::executor_type) ? Executor() : ex) #else // !defined(BOOST_ASIO_NO_TYPEID) : executor_(ex) #endif // !defined(BOOST_ASIO_NO_TYPEID) { if (executor_) executor_.on_work_started(); } handler_work_base(const Executor& ex, const Executor& candidate) BOOST_ASIO_NOEXCEPT : executor_(ex != candidate ? ex : Executor()) { if (executor_) executor_.on_work_started(); } template <typename OtherExecutor> handler_work_base(const Executor& ex, const OtherExecutor&) BOOST_ASIO_NOEXCEPT : executor_(ex) { executor_.on_work_started(); } handler_work_base(const handler_work_base& other) BOOST_ASIO_NOEXCEPT : executor_(other.executor_) { if (executor_) executor_.on_work_started(); } #if defined(BOOST_ASIO_HAS_MOVE) handler_work_base(handler_work_base&& other) BOOST_ASIO_NOEXCEPT : executor_(BOOST_ASIO_MOVE_CAST(Executor)(other.executor_)) { } #endif // defined(BOOST_ASIO_HAS_MOVE) ~handler_work_base() { if (executor_) executor_.on_work_finished(); } bool owns_work() const BOOST_ASIO_NOEXCEPT { return !!executor_; } template <typename Function, typename Handler> void dispatch(Function& function, Handler& handler) { executor_.dispatch(BOOST_ASIO_MOVE_CAST(Function)(function), boost::asio::get_associated_allocator(handler)); } private: Executor executor_; }; template < #if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) typename... SupportableProperties, #else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, #endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) typename IoContext, typename PolymorphicExecutor> class handler_work_base< #if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) execution::any_executor<SupportableProperties...>, #else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) execution::any_executor<T1, T2, T3, T4, T5, T6, T7, T8, T9>, #endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) void, IoContext, PolymorphicExecutor> { public: typedef #if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) execution::any_executor<SupportableProperties...> #else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) execution::any_executor<T1, T2, T3, T4, T5, T6, T7, T8, T9> #endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) executor_type; explicit handler_work_base(const executor_type& ex) BOOST_ASIO_NOEXCEPT #if !defined(BOOST_ASIO_NO_TYPEID) : executor_( ex.target_type() == typeid(typename IoContext::executor_type) ? executor_type() : boost::asio::prefer(ex, execution::outstanding_work.tracked)) #else // !defined(BOOST_ASIO_NO_TYPEID) : executor_(boost::asio::prefer(ex, execution::outstanding_work.tracked)) #endif // !defined(BOOST_ASIO_NO_TYPEID) { } handler_work_base(const executor_type& ex, const executor_type& candidate) BOOST_ASIO_NOEXCEPT : executor_(ex != candidate ? ex : executor_type()) { } template <typename OtherExecutor> handler_work_base(const executor_type& ex, const OtherExecutor&) BOOST_ASIO_NOEXCEPT : executor_(boost::asio::prefer(ex, execution::outstanding_work.tracked)) { } handler_work_base(const handler_work_base& other) BOOST_ASIO_NOEXCEPT : executor_(other.executor_) { } #if defined(BOOST_ASIO_HAS_MOVE) handler_work_base(handler_work_base&& other) BOOST_ASIO_NOEXCEPT : executor_(BOOST_ASIO_MOVE_CAST(executor_type)(other.executor_)) { } #endif // defined(BOOST_ASIO_HAS_MOVE) bool owns_work() const BOOST_ASIO_NOEXCEPT { return !!executor_; } template <typename Function, typename Handler> void dispatch(Function& function, Handler& handler) { execution::execute( boost::asio::prefer(executor_, execution::blocking.possibly, execution::allocator((get_associated_allocator)(handler))), BOOST_ASIO_MOVE_CAST(Function)(function)); } private: executor_type executor_; }; template <typename Handler, typename IoExecutor, typename = void> class handler_work : handler_work_base<IoExecutor>, handler_work_base<typename associated_executor< Handler, IoExecutor>::type, IoExecutor> { public: typedef handler_work_base<IoExecutor> base1_type; typedef handler_work_base<typename associated_executor< Handler, IoExecutor>::type, IoExecutor> base2_type; handler_work(Handler& handler, const IoExecutor& io_ex) BOOST_ASIO_NOEXCEPT : base1_type(io_ex), base2_type(boost::asio::get_associated_executor(handler, io_ex), io_ex) { } template <typename Function> void complete(Function& function, Handler& handler) { if (!base1_type::owns_work() && !base2_type::owns_work()) { // When using a native implementation, I/O completion handlers are // already dispatched according to the execution context's executor's // rules. We can call the function directly. boost_asio_handler_invoke_helpers::invoke(function, handler); } else { base2_type::dispatch(function, handler); } } }; template <typename Handler, typename IoExecutor> class handler_work< Handler, IoExecutor, typename enable_if< is_same< typename associated_executor<Handler, IoExecutor>::asio_associated_executor_is_unspecialised, void >::value >::type> : handler_work_base<IoExecutor> { public: typedef handler_work_base<IoExecutor> base1_type; handler_work(Handler&, const IoExecutor& io_ex) BOOST_ASIO_NOEXCEPT : base1_type(io_ex) { } template <typename Function> void complete(Function& function, Handler& handler) { if (!base1_type::owns_work()) { // When using a native implementation, I/O completion handlers are // already dispatched according to the execution context's executor's // rules. We can call the function directly. boost_asio_handler_invoke_helpers::invoke(function, handler); } else { base1_type::dispatch(function, handler); } } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_HANDLER_WORK_HPP PK��h!\� ��is_buffer_sequence.hppnu��[��// // detail/is_buffer_sequence.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IS_BUFFER_SEQUENCE_HPP #define BOOST_ASIO_DETAIL_IS_BUFFER_SEQUENCE_HPP #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/detail/type_traits.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { class mutable_buffer; class const_buffer; namespace detail { struct buffer_sequence_memfns_base { void begin(); void end(); void size(); void max_size(); void capacity(); void data(); void prepare(); void commit(); void consume(); void grow(); void shrink(); }; template <typename T> struct buffer_sequence_memfns_derived : T, buffer_sequence_memfns_base { }; template <typename T, T> struct buffer_sequence_memfns_check { }; #if defined(BOOST_ASIO_HAS_DECLTYPE) template <typename> char buffer_sequence_begin_helper(...); template <typename T> char (&buffer_sequence_begin_helper(T* t, typename enable_if<!is_same< decltype(boost::asio::buffer_sequence_begin(t)), void>::value>::type))[2]; #else // defined(BOOST_ASIO_HAS_DECLTYPE) template <typename> char (&buffer_sequence_begin_helper(...))[2]; template <typename T> char buffer_sequence_begin_helper(T* t, buffer_sequence_memfns_check< void (buffer_sequence_memfns_base::)(), &buffer_sequence_memfns_derived<T>::begin>); #endif // defined(BOOST_ASIO_HAS_DECLTYPE) #if defined(BOOST_ASIO_HAS_DECLTYPE) template <typename> char buffer_sequence_end_helper(...); template <typename T> char (&buffer_sequence_end_helper(T* t, typename enable_if<!is_same< decltype(boost::asio::buffer_sequence_end(t)), void>::value>::type))[2]; #else // defined(BOOST_ASIO_HAS_DECLTYPE) template <typename> char (&buffer_sequence_end_helper(...))[2]; template <typename T> char buffer_sequence_end_helper(T* t, buffer_sequence_memfns_check< void (buffer_sequence_memfns_base::)(), &buffer_sequence_memfns_derived<T>::end>); #endif // defined(BOOST_ASIO_HAS_DECLTYPE) template <typename> char (&size_memfn_helper(...))[2]; template <typename T> char size_memfn_helper( buffer_sequence_memfns_check< void (buffer_sequence_memfns_base::)(), &buffer_sequence_memfns_derived<T>::size>); template <typename> char (&max_size_memfn_helper(...))[2]; template <typename T> char max_size_memfn_helper( buffer_sequence_memfns_check< void (buffer_sequence_memfns_base::)(), &buffer_sequence_memfns_derived<T>::max_size>); template <typename> char (&capacity_memfn_helper(...))[2]; template <typename T> char capacity_memfn_helper( buffer_sequence_memfns_check< void (buffer_sequence_memfns_base::)(), &buffer_sequence_memfns_derived<T>::capacity>); template <typename> char (&data_memfn_helper(...))[2]; template <typename T> char data_memfn_helper( buffer_sequence_memfns_check< void (buffer_sequence_memfns_base::)(), &buffer_sequence_memfns_derived<T>::data>); template <typename> char (&prepare_memfn_helper(...))[2]; template <typename T> char prepare_memfn_helper( buffer_sequence_memfns_check< void (buffer_sequence_memfns_base::)(), &buffer_sequence_memfns_derived<T>::prepare>); template <typename> char (&commit_memfn_helper(...))[2]; template <typename T> char commit_memfn_helper( buffer_sequence_memfns_check< void (buffer_sequence_memfns_base::)(), &buffer_sequence_memfns_derived<T>::commit>); template <typename> char (&consume_memfn_helper(...))[2]; template <typename T> char consume_memfn_helper( buffer_sequence_memfns_check< void (buffer_sequence_memfns_base::)(), &buffer_sequence_memfns_derived<T>::consume>); template <typename> char (&grow_memfn_helper(...))[2]; template <typename T> char grow_memfn_helper( buffer_sequence_memfns_check< void (buffer_sequence_memfns_base::)(), &buffer_sequence_memfns_derived<T>::grow>); template <typename> char (&shrink_memfn_helper(...))[2]; template <typename T> char shrink_memfn_helper( buffer_sequence_memfns_check< void (buffer_sequence_memfns_base::)(), &buffer_sequence_memfns_derived<T>::shrink>); template <typename, typename> char (&buffer_sequence_element_type_helper(...))[2]; #if defined(BOOST_ASIO_HAS_DECLTYPE) template <typename T, typename Buffer> char buffer_sequence_element_type_helper(T* t, typename enable_if<is_convertible< decltype(boost::asio::buffer_sequence_begin(t)), Buffer>::value>::type); #else // defined(BOOST_ASIO_HAS_DECLTYPE) template <typename T, typename Buffer> char buffer_sequence_element_type_helper( typename T::const_iterator, typename enable_if<is_convertible< typename T::value_type, Buffer>::value>::type); #endif // defined(BOOST_ASIO_HAS_DECLTYPE) template <typename> char (&const_buffers_type_typedef_helper(...))[2]; template <typename T> char const_buffers_type_typedef_helper( typename T::const_buffers_type); template <typename> char (&mutable_buffers_type_typedef_helper(...))[2]; template <typename T> char mutable_buffers_type_typedef_helper( typename T::mutable_buffers_type); template <typename T, typename Buffer> struct is_buffer_sequence_class : integral_constant<bool, sizeof(buffer_sequence_begin_helper<T>(0, 0)) != 1 && sizeof(buffer_sequence_end_helper<T>(0, 0)) != 1 && sizeof(buffer_sequence_element_type_helper<T, Buffer>(0, 0)) == 1> { }; template <typename T, typename Buffer> struct is_buffer_sequence : conditional<is_class<T>::value, is_buffer_sequence_class<T, Buffer>, false_type>::type { }; template <> struct is_buffer_sequence<mutable_buffer, mutable_buffer> : true_type { }; template <> struct is_buffer_sequence<mutable_buffer, const_buffer> : true_type { }; template <> struct is_buffer_sequence<const_buffer, const_buffer> : true_type { }; template <> struct is_buffer_sequence<const_buffer, mutable_buffer> : false_type { }; template <typename T> struct is_dynamic_buffer_class_v1 : integral_constant<bool, sizeof(size_memfn_helper<T>(0)) != 1 && sizeof(max_size_memfn_helper<T>(0)) != 1 && sizeof(capacity_memfn_helper<T>(0)) != 1 && sizeof(data_memfn_helper<T>(0)) != 1 && sizeof(consume_memfn_helper<T>(0)) != 1 && sizeof(prepare_memfn_helper<T>(0)) != 1 && sizeof(commit_memfn_helper<T>(0)) != 1 && sizeof(const_buffers_type_typedef_helper<T>(0)) == 1 && sizeof(mutable_buffers_type_typedef_helper<T>(0)) == 1> { }; template <typename T> struct is_dynamic_buffer_v1 : conditional<is_class<T>::value, is_dynamic_buffer_class_v1<T>, false_type>::type { }; template <typename T> struct is_dynamic_buffer_class_v2 : integral_constant<bool, sizeof(size_memfn_helper<T>(0)) != 1 && sizeof(max_size_memfn_helper<T>(0)) != 1 && sizeof(capacity_memfn_helper<T>(0)) != 1 && sizeof(data_memfn_helper<T>(0)) != 1 && sizeof(consume_memfn_helper<T>(0)) != 1 && sizeof(grow_memfn_helper<T>(0)) != 1 && sizeof(shrink_memfn_helper<T>(0)) != 1 && sizeof(const_buffers_type_typedef_helper<T>(0)) == 1 && sizeof(mutable_buffers_type_typedef_helper<T>(0)) == 1> { }; template <typename T> struct is_dynamic_buffer_v2 : conditional<is_class<T>::value, is_dynamic_buffer_class_v2<T>, false_type>::type { }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_IS_BUFFER_SEQUENCE_HPP PK��h!\ݜ�{��{��dependent_type.hppnu��[��// // detail/dependent_type.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_DEPENDENT_TYPE_HPP #define BOOST_ASIO_DETAIL_DEPENDENT_TYPE_HPP #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/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename DependsOn, typename T> struct dependent_type { typedef T type; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_DEPENDENT_TYPE_HPP PK��h!\b �Q��Q��reactive_wait_op.hppnu��[��// // detail/reactive_wait_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_REACTIVE_WAIT_OP_HPP #define BOOST_ASIO_DETAIL_REACTIVE_WAIT_OP_HPP #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/detail/bind_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Handler, typename IoExecutor> class reactive_wait_op : public reactor_op { public: BOOST_ASIO_DEFINE_HANDLER_PTR(reactive_wait_op); reactive_wait_op(const boost::system::error_code& success_ec, Handler& handler, const IoExecutor& io_ex) : reactor_op(success_ec, &reactive_wait_op::do_perform, &reactive_wait_op::do_complete), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static status do_perform(reactor_op) { return done; } static void do_complete(void* owner, operation* base, const boost::system::error_code& /ec/, std::size_t /bytes_transferred/) { // Take ownership of the handler object. reactive_wait_op* o(static_cast<reactive_wait_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder1<Handler, boost::system::error_code> handler(o->handler_, o->ec_); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_REACTIVE_WAIT_OP_HPP PK��h!\ ��is��s��signal_handler.hppnu��[��// // detail/signal_handler.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_SIGNAL_HANDLER_HPP #define BOOST_ASIO_DETAIL_SIGNAL_HANDLER_HPP #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/detail/bind_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/signal_op.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Handler, typename IoExecutor> class signal_handler : public signal_op { public: BOOST_ASIO_DEFINE_HANDLER_PTR(signal_handler); signal_handler(Handler& h, const IoExecutor& io_ex) : signal_op(&signal_handler::do_complete), handler_(BOOST_ASIO_MOVE_CAST(Handler)(h)), work_(handler_, io_ex) { } static void do_complete(void* owner, operation* base, const boost::system::error_code& /ec/, std::size_t /bytes_transferred/) { // Take ownership of the handler object. signal_handler* h(static_cast<signal_handler>(base)); ptr p = { boost::asio::detail::addressof(h->handler_), h, h }; BOOST_ASIO_HANDLER_COMPLETION((h)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( h->work_)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, int> handler(h->handler_, h->ec_, h->signal_number_); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_SIGNAL_HANDLER_HPP PK��h!\x2��#��#��handler_tracking.hppnu��[��// // detail/handler_tracking.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_HANDLER_TRACKING_HPP #define BOOST_ASIO_DETAIL_HANDLER_TRACKING_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> namespace boost { namespace asio { class execution_context; } // namespace asio } // namespace boost #if defined(BOOST_ASIO_CUSTOM_HANDLER_TRACKING) # include BOOST_ASIO_CUSTOM_HANDLER_TRACKING #elif defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) # include <boost/system/error_code.hpp> # include <boost/asio/detail/cstdint.hpp> # include <boost/asio/detail/static_mutex.hpp> # include <boost/asio/detail/tss_ptr.hpp> #endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { #if defined(BOOST_ASIO_CUSTOM_HANDLER_TRACKING) // The user-specified header must define the following macros: // - BOOST_ASIO_INHERIT_TRACKED_HANDLER // - BOOST_ASIO_ALSO_INHERIT_TRACKED_HANDLER // - BOOST_ASIO_HANDLER_TRACKING_INIT // - BOOST_ASIO_HANDLER_CREATION(args) // - BOOST_ASIO_HANDLER_COMPLETION(args) // - BOOST_ASIO_HANDLER_INVOCATION_BEGIN(args) // - BOOST_ASIO_HANDLER_INVOCATION_END // - BOOST_ASIO_HANDLER_OPERATION(args) // - BOOST_ASIO_HANDLER_REACTOR_REGISTRATION(args) // - BOOST_ASIO_HANDLER_REACTOR_DEREGISTRATION(args) // - BOOST_ASIO_HANDLER_REACTOR_READ_EVENT // - BOOST_ASIO_HANDLER_REACTOR_WRITE_EVENT // - BOOST_ASIO_HANDLER_REACTOR_ERROR_EVENT // - BOOST_ASIO_HANDLER_REACTOR_EVENTS(args) // - BOOST_ASIO_HANDLER_REACTOR_OPERATION(args) # if !defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) # define BOOST_ASIO_ENABLE_HANDLER_TRACKING 1 # endif /// !defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) #elif defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) class handler_tracking { public: class completion; // Base class for objects containing tracked handlers. class tracked_handler { private: // Only the handler_tracking class will have access to the id. friend class handler_tracking; friend class completion; uint64_t id_; protected: // Constructor initialises with no id. tracked_handler() : id_(0) {} // Prevent deletion through this type. ~tracked_handler() {} }; // Initialise the tracking system. BOOST_ASIO_DECL static void init(); class location { public: // Constructor adds a location to the stack. BOOST_ASIO_DECL explicit location(const char* file, int line, const char* func); // Destructor removes a location from the stack. BOOST_ASIO_DECL ~location(); private: // Disallow copying and assignment. location(const location&) BOOST_ASIO_DELETED; location& operator=(const location&) BOOST_ASIO_DELETED; friend class handler_tracking; const char* file_; int line_; const char* func_; location* next_; }; // Record the creation of a tracked handler. BOOST_ASIO_DECL static void creation( execution_context& context, tracked_handler& h, const char* object_type, void* object, uintmax_t native_handle, const char* op_name); class completion { public: // Constructor records that handler is to be invoked with no arguments. BOOST_ASIO_DECL explicit completion(const tracked_handler& h); // Destructor records only when an exception is thrown from the handler, or // if the memory is being freed without the handler having been invoked. BOOST_ASIO_DECL ~completion(); // Records that handler is to be invoked with no arguments. BOOST_ASIO_DECL void invocation_begin(); // Records that handler is to be invoked with one arguments. BOOST_ASIO_DECL void invocation_begin(const boost::system::error_code& ec); // Constructor records that handler is to be invoked with two arguments. BOOST_ASIO_DECL void invocation_begin( const boost::system::error_code& ec, std::size_t bytes_transferred); // Constructor records that handler is to be invoked with two arguments. BOOST_ASIO_DECL void invocation_begin( const boost::system::error_code& ec, int signal_number); // Constructor records that handler is to be invoked with two arguments. BOOST_ASIO_DECL void invocation_begin( const boost::system::error_code& ec, const char* arg); // Record that handler invocation has ended. BOOST_ASIO_DECL void invocation_end(); private: friend class handler_tracking; uint64_t id_; bool invoked_; completion* next_; }; // Record an operation that is not directly associated with a handler. BOOST_ASIO_DECL static void operation(execution_context& context, const char* object_type, void* object, uintmax_t native_handle, const char* op_name); // Record that a descriptor has been registered with the reactor. BOOST_ASIO_DECL static void reactor_registration(execution_context& context, uintmax_t native_handle, uintmax_t registration); // Record that a descriptor has been deregistered from the reactor. BOOST_ASIO_DECL static void reactor_deregistration(execution_context& context, uintmax_t native_handle, uintmax_t registration); // Record a reactor-based operation that is associated with a handler. BOOST_ASIO_DECL static void reactor_events(execution_context& context, uintmax_t registration, unsigned events); // Record a reactor-based operation that is associated with a handler. BOOST_ASIO_DECL static void reactor_operation( const tracked_handler& h, const char* op_name, const boost::system::error_code& ec); // Record a reactor-based operation that is associated with a handler. BOOST_ASIO_DECL static void reactor_operation( const tracked_handler& h, const char* op_name, const boost::system::error_code& ec, std::size_t bytes_transferred); // Write a line of output. BOOST_ASIO_DECL static void write_line(const char* format, ...); private: struct tracking_state; BOOST_ASIO_DECL static tracking_state* get_state(); }; # define BOOST_ASIO_INHERIT_TRACKED_HANDLER \ : public boost::asio::detail::handler_tracking::tracked_handler # define BOOST_ASIO_ALSO_INHERIT_TRACKED_HANDLER \ , public boost::asio::detail::handler_tracking::tracked_handler # define BOOST_ASIO_HANDLER_TRACKING_INIT \ boost::asio::detail::handler_tracking::init() # define BOOST_ASIO_HANDLER_LOCATION(args) \ boost::asio::detail::handler_tracking::location tracked_location args # define BOOST_ASIO_HANDLER_CREATION(args) \ boost::asio::detail::handler_tracking::creation args # define BOOST_ASIO_HANDLER_COMPLETION(args) \ boost::asio::detail::handler_tracking::completion tracked_completion args # define BOOST_ASIO_HANDLER_INVOCATION_BEGIN(args) \ tracked_completion.invocation_begin args # define BOOST_ASIO_HANDLER_INVOCATION_END \ tracked_completion.invocation_end() # define BOOST_ASIO_HANDLER_OPERATION(args) \ boost::asio::detail::handler_tracking::operation args # define BOOST_ASIO_HANDLER_REACTOR_REGISTRATION(args) \ boost::asio::detail::handler_tracking::reactor_registration args # define BOOST_ASIO_HANDLER_REACTOR_DEREGISTRATION(args) \ boost::asio::detail::handler_tracking::reactor_deregistration args # define BOOST_ASIO_HANDLER_REACTOR_READ_EVENT 1 # define BOOST_ASIO_HANDLER_REACTOR_WRITE_EVENT 2 # define BOOST_ASIO_HANDLER_REACTOR_ERROR_EVENT 4 # define BOOST_ASIO_HANDLER_REACTOR_EVENTS(args) \ boost::asio::detail::handler_tracking::reactor_events args # define BOOST_ASIO_HANDLER_REACTOR_OPERATION(args) \ boost::asio::detail::handler_tracking::reactor_operation args #else // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) # define BOOST_ASIO_INHERIT_TRACKED_HANDLER # define BOOST_ASIO_ALSO_INHERIT_TRACKED_HANDLER # define BOOST_ASIO_HANDLER_TRACKING_INIT (void)0 # define BOOST_ASIO_HANDLER_LOCATION(loc) (void)0 # define BOOST_ASIO_HANDLER_CREATION(args) (void)0 # define BOOST_ASIO_HANDLER_COMPLETION(args) (void)0 # define BOOST_ASIO_HANDLER_INVOCATION_BEGIN(args) (void)0 # define BOOST_ASIO_HANDLER_INVOCATION_END (void)0 # define BOOST_ASIO_HANDLER_OPERATION(args) (void)0 # define BOOST_ASIO_HANDLER_REACTOR_REGISTRATION(args) (void)0 # define BOOST_ASIO_HANDLER_REACTOR_DEREGISTRATION(args) (void)0 # define BOOST_ASIO_HANDLER_REACTOR_READ_EVENT 0 # define BOOST_ASIO_HANDLER_REACTOR_WRITE_EVENT 0 # define BOOST_ASIO_HANDLER_REACTOR_ERROR_EVENT 0 # define BOOST_ASIO_HANDLER_REACTOR_EVENTS(args) (void)0 # define BOOST_ASIO_HANDLER_REACTOR_OPERATION(args) (void)0 #endif // defined(BOOST_ASIO_ENABLE_HANDLER_TRACKING) } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/handler_tracking.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // BOOST_ASIO_DETAIL_HANDLER_TRACKING_HPP PK��h!\�F�,��blocking_executor_op.hppnu��[��// // detail/blocking_executor_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_BLOCKING_EXECUTOR_OP_HPP #define BOOST_ASIO_DETAIL_BLOCKING_EXECUTOR_OP_HPP #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/detail/event.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/mutex.hpp> #include <boost/asio/detail/scheduler_operation.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Operation = scheduler_operation> class blocking_executor_op_base : public Operation { public: blocking_executor_op_base(typename Operation::func_type complete_func) : Operation(complete_func), is_complete_(false) { } void wait() { boost::asio::detail::mutex::scoped_lock lock(mutex_); while (!is_complete_) event_.wait(lock); } protected: struct do_complete_cleanup { ~do_complete_cleanup() { boost::asio::detail::mutex::scoped_lock lock(op_->mutex_); op_->is_complete_ = true; op_->event_.unlock_and_signal_one_for_destruction(lock); } blocking_executor_op_base* op_; }; private: boost::asio::detail::mutex mutex_; boost::asio::detail::event event_; bool is_complete_; }; template <typename Handler, typename Operation = scheduler_operation> class blocking_executor_op : public blocking_executor_op_base<Operation> { public: blocking_executor_op(Handler& h) : blocking_executor_op_base<Operation>(&blocking_executor_op::do_complete), handler_(h) { } static void do_complete(void* owner, Operation* base, const boost::system::error_code& /ec/, std::size_t /bytes_transferred/) { blocking_executor_op* o(static_cast<blocking_executor_op>(base)); typename blocking_executor_op_base<Operation>::do_complete_cleanup on_exit = { o }; (void)on_exit; BOOST_ASIO_HANDLER_COMPLETION((o)); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN(()); boost_asio_handler_invoke_helpers::invoke(o->handler_, o->handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: Handler& handler_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_BLOCKING_EXECUTOR_OP_HPP PK��h!\��=0��0��wait_handler.hppnu��[��// // detail/wait_handler.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WAIT_HANDLER_HPP #define BOOST_ASIO_DETAIL_WAIT_HANDLER_HPP #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/detail/bind_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/wait_op.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Handler, typename IoExecutor> class wait_handler : public wait_op { public: BOOST_ASIO_DEFINE_HANDLER_PTR(wait_handler); wait_handler(Handler& h, const IoExecutor& io_ex) : wait_op(&wait_handler::do_complete), handler_(BOOST_ASIO_MOVE_CAST(Handler)(h)), work_(handler_, io_ex) { } static void do_complete(void* owner, operation* base, const boost::system::error_code& /ec/, std::size_t /bytes_transferred/) { // Take ownership of the handler object. wait_handler* h(static_cast<wait_handler>(base)); ptr p = { boost::asio::detail::addressof(h->handler_), h, h }; BOOST_ASIO_HANDLER_COMPLETION((h)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( h->work_)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder1<Handler, boost::system::error_code> handler(h->handler_, h->ec_); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_WAIT_HANDLER_HPP PK��h!\��qL��posix_global.hppnu��[��// // detail/posix_global.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_POSIX_GLOBAL_HPP #define BOOST_ASIO_DETAIL_POSIX_GLOBAL_HPP #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_HAS_PTHREADS) #include <exception> #include <pthread.h> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename T> struct posix_global_impl { // Helper function to perform initialisation. static void do_init() { instance_.static_ptr_ = instance_.ptr_ = new T; } // Destructor automatically cleans up the global. ~posix_global_impl() { delete static_ptr_; } static ::pthread_once_t init_once_; static T* static_ptr_; static posix_global_impl instance_; T* ptr_; }; template <typename T> ::pthread_once_t posix_global_impl<T>::init_once_ = PTHREAD_ONCE_INIT; template <typename T> T* posix_global_impl<T>::static_ptr_ = 0; template <typename T> posix_global_impl<T> posix_global_impl<T>::instance_; template <typename T> T& posix_global() { int result = ::pthread_once( &posix_global_impl<T>::init_once_, &posix_global_impl<T>::do_init); if (result != 0) std::terminate(); return posix_global_impl<T>::instance_.ptr_; } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_PTHREADS) #endif // BOOST_ASIO_DETAIL_POSIX_GLOBAL_HPP PK��h!\;�/��win_iocp_socket_send_op.hppnu��[��// // detail/win_iocp_socket_send_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_IOCP_SOCKET_SEND_OP_HPP #define BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_SEND_OP_HPP #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_HAS_IOCP) #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/operation.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename ConstBufferSequence, typename Handler, typename IoExecutor> class win_iocp_socket_send_op : public operation { public: BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_send_op); win_iocp_socket_send_op(socket_ops::weak_cancel_token_type cancel_token, const ConstBufferSequence& buffers, Handler& handler, const IoExecutor& io_ex) : operation(&win_iocp_socket_send_op::do_complete), cancel_token_(cancel_token), buffers_(buffers), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static void do_complete(void owner, operation* base, const boost::system::error_code& result_ec, std::size_t bytes_transferred) { boost::system::error_code ec(result_ec); // Take ownership of the operation object. win_iocp_socket_send_op* o(static_cast<win_iocp_socket_send_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) // Check whether buffers are still valid. if (owner) { buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence>::validate(o->buffers_); } #endif // defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) socket_ops::complete_iocp_send(o->cancel_token_, ec); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, ec, bytes_transferred); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: socket_ops::weak_cancel_token_type cancel_token_; ConstBufferSequence buffers_; Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #endif // BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_SEND_OP_HPP PK��h!\D.u��posix_thread.hppnu��[��// // detail/posix_thread.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_POSIX_THREAD_HPP #define BOOST_ASIO_DETAIL_POSIX_THREAD_HPP #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_HAS_PTHREADS) #include <cstddef> #include <pthread.h> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { extern "C" { BOOST_ASIO_DECL void* boost_asio_detail_posix_thread_function(void* arg); } class posix_thread : private noncopyable { public: // Constructor. template <typename Function> posix_thread(Function f, unsigned int = 0) : joined_(false) { start_thread(new func<Function>(f)); } // Destructor. BOOST_ASIO_DECL ~posix_thread(); // Wait for the thread to exit. BOOST_ASIO_DECL void join(); // Get number of CPUs. BOOST_ASIO_DECL static std::size_t hardware_concurrency(); private: friend void* boost_asio_detail_posix_thread_function(void* arg); class func_base { public: virtual ~func_base() {} virtual void run() = 0; }; struct auto_func_base_ptr { func_base* ptr; ~auto_func_base_ptr() { delete ptr; } }; template <typename Function> class func : public func_base { public: func(Function f) : f_(f) { } virtual void run() { f_(); } private: Function f_; }; BOOST_ASIO_DECL void start_thread(func_base* arg); ::pthread_t thread_; bool joined_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/posix_thread.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_HAS_PTHREADS) #endif // BOOST_ASIO_DETAIL_POSIX_THREAD_HPP PK��h!\�M!Ӡ��winsock_init.hppnu��[��// // detail/winsock_init.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WINSOCK_INIT_HPP #define BOOST_ASIO_DETAIL_WINSOCK_INIT_HPP #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_WINDOWS) \|\| defined(__CYGWIN__) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class winsock_init_base { protected: // Structure to track result of initialisation and number of uses. POD is used // to ensure that the values are zero-initialised prior to any code being run. struct data { long init_count_; long result_; }; BOOST_ASIO_DECL static void startup(data& d, unsigned char major, unsigned char minor); BOOST_ASIO_DECL static void manual_startup(data& d); BOOST_ASIO_DECL static void cleanup(data& d); BOOST_ASIO_DECL static void manual_cleanup(data& d); BOOST_ASIO_DECL static void throw_on_error(data& d); }; template <int Major = 2, int Minor = 0> class winsock_init : private winsock_init_base { public: winsock_init(bool allow_throw = true) { startup(data_, Major, Minor); if (allow_throw) throw_on_error(data_); } winsock_init(const winsock_init&) { startup(data_, Major, Minor); throw_on_error(data_); } ~winsock_init() { cleanup(data_); } // This class may be used to indicate that user code will manage Winsock // initialisation and cleanup. This may be required in the case of a DLL, for // example, where it is not safe to initialise Winsock from global object // constructors. // // To prevent asio from initialising Winsock, the object must be constructed // before any Asio's own global objects. With MSVC, this may be accomplished // by adding the following code to the DLL: // // #pragma warning(push) // #pragma warning(disable:4073) // #pragma init_seg(lib) // boost::asio::detail::winsock_init<>::manual manual_winsock_init; // #pragma warning(pop) class manual { public: manual() { manual_startup(data_); } manual(const manual&) { manual_startup(data_); } ~manual() { manual_cleanup(data_); } }; private: friend class manual; static data data_; }; template <int Major, int Minor> winsock_init_base::data winsock_init<Major, Minor>::data_; // Static variable to ensure that winsock is initialised before main, and // therefore before any other threads can get started. static const winsock_init<>& winsock_init_instance = winsock_init<>(false); } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/winsock_init.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_WINSOCK_INIT_HPP PK��h!\ٵ� �� service_registry.hppnu��[��// // detail/service_registry.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_SERVICE_REGISTRY_HPP #define BOOST_ASIO_DETAIL_SERVICE_REGISTRY_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <typeinfo> #include <boost/asio/detail/mutex.hpp> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/type_traits.hpp> #include <boost/asio/execution_context.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { class io_context; namespace detail { template <typename T> class typeid_wrapper {}; class service_registry : private noncopyable { public: // Constructor. BOOST_ASIO_DECL service_registry(execution_context& owner); // Destructor. BOOST_ASIO_DECL ~service_registry(); // Shutdown all services. BOOST_ASIO_DECL void shutdown_services(); // Destroy all services. BOOST_ASIO_DECL void destroy_services(); // Notify all services of a fork event. BOOST_ASIO_DECL void notify_fork(execution_context::fork_event fork_ev); // Get the service object corresponding to the specified service type. Will // create a new service object automatically if no such object already // exists. Ownership of the service object is not transferred to the caller. template <typename Service> Service& use_service(); // Get the service object corresponding to the specified service type. Will // create a new service object automatically if no such object already // exists. Ownership of the service object is not transferred to the caller. // This overload is used for backwards compatibility with services that // inherit from io_context::service. template <typename Service> Service& use_service(io_context& owner); // Add a service object. Throws on error, in which case ownership of the // object is retained by the caller. template <typename Service> void add_service(Service* new_service); // Check whether a service object of the specified type already exists. template <typename Service> bool has_service() const; private: // Initalise a service's key when the key_type typedef is not available. template <typename Service> static void init_key(execution_context::service::key& key, ...); #if !defined(BOOST_ASIO_NO_TYPEID) // Initalise a service's key when the key_type typedef is available. template <typename Service> static void init_key(execution_context::service::key& key, typename enable_if< is_base_of<typename Service::key_type, Service>::value>::type); #endif // !defined(BOOST_ASIO_NO_TYPEID) // Initialise a service's key based on its id. BOOST_ASIO_DECL static void init_key_from_id( execution_context::service::key& key, const execution_context::id& id); #if !defined(BOOST_ASIO_NO_TYPEID) // Initialise a service's key based on its id. template <typename Service> static void init_key_from_id(execution_context::service::key& key, const service_id<Service>& /id/); #endif // !defined(BOOST_ASIO_NO_TYPEID) // Check if a service matches the given id. BOOST_ASIO_DECL static bool keys_match( const execution_context::service::key& key1, const execution_context::service::key& key2); // The type of a factory function used for creating a service instance. typedef execution_context::service(factory_type)(void); // Factory function for creating a service instance. template <typename Service, typename Owner> static execution_context::service* create(void* owner); // Destroy a service instance. BOOST_ASIO_DECL static void destroy(execution_context::service* service); // Helper class to manage service pointers. struct auto_service_ptr; friend struct auto_service_ptr; struct auto_service_ptr { execution_context::service* ptr_; ~auto_service_ptr() { destroy(ptr_); } }; // Get the service object corresponding to the specified service key. Will // create a new service object automatically if no such object already // exists. Ownership of the service object is not transferred to the caller. BOOST_ASIO_DECL execution_context::service* do_use_service( const execution_context::service::key& key, factory_type factory, void* owner); // Add a service object. Throws on error, in which case ownership of the // object is retained by the caller. BOOST_ASIO_DECL void do_add_service( const execution_context::service::key& key, execution_context::service* new_service); // Check whether a service object with the specified key already exists. BOOST_ASIO_DECL bool do_has_service( const execution_context::service::key& key) const; // Mutex to protect access to internal data. mutable boost::asio::detail::mutex mutex_; // The owner of this service registry and the services it contains. execution_context& owner_; // The first service in the list of contained services. execution_context::service* first_service_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #include <boost/asio/detail/impl/service_registry.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/service_registry.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // BOOST_ASIO_DETAIL_SERVICE_REGISTRY_HPP PK��h!\I�e9��9��reactive_socket_recv_op.hppnu��[��// // detail/reactive_socket_recv_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_REACTIVE_SOCKET_RECV_OP_HPP #define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECV_OP_HPP #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/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename MutableBufferSequence> class reactive_socket_recv_op_base : public reactor_op { public: reactive_socket_recv_op_base(const boost::system::error_code& success_ec, socket_type socket, socket_ops::state_type state, const MutableBufferSequence& buffers, socket_base::message_flags flags, func_type complete_func) : reactor_op(success_ec, &reactive_socket_recv_op_base::do_perform, complete_func), socket_(socket), state_(state), buffers_(buffers), flags_(flags) { } static status do_perform(reactor_op* base) { reactive_socket_recv_op_base* o( static_cast<reactive_socket_recv_op_base>(base)); typedef buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence> bufs_type; status result; if (bufs_type::is_single_buffer) { result = socket_ops::non_blocking_recv1(o->socket_, bufs_type::first(o->buffers_).data(), bufs_type::first(o->buffers_).size(), o->flags_, (o->state_ & socket_ops::stream_oriented) != 0, o->ec_, o->bytes_transferred_) ? done : not_done; } else { bufs_type bufs(o->buffers_); result = socket_ops::non_blocking_recv(o->socket_, bufs.buffers(), bufs.count(), o->flags_, (o->state_ & socket_ops::stream_oriented) != 0, o->ec_, o->bytes_transferred_) ? done : not_done; } if (result == done) if ((o->state_ & socket_ops::stream_oriented) != 0) if (o->bytes_transferred_ == 0) result = done_and_exhausted; BOOST_ASIO_HANDLER_REACTOR_OPERATION((o, "non_blocking_recv", o->ec_, o->bytes_transferred_)); return result; } private: socket_type socket_; socket_ops::state_type state_; MutableBufferSequence buffers_; socket_base::message_flags flags_; }; template <typename MutableBufferSequence, typename Handler, typename IoExecutor> class reactive_socket_recv_op : public reactive_socket_recv_op_base<MutableBufferSequence> { public: BOOST_ASIO_DEFINE_HANDLER_PTR(reactive_socket_recv_op); reactive_socket_recv_op(const boost::system::error_code& success_ec, socket_type socket, socket_ops::state_type state, const MutableBufferSequence& buffers, socket_base::message_flags flags, Handler& handler, const IoExecutor& io_ex) : reactive_socket_recv_op_base<MutableBufferSequence>(success_ec, socket, state, buffers, flags, &reactive_socket_recv_op::do_complete), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static void do_complete(void* owner, operation* base, const boost::system::error_code& /ec/, std::size_t /bytes_transferred/) { // Take ownership of the handler object. reactive_socket_recv_op* o(static_cast<reactive_socket_recv_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, o->ec_, o->bytes_transferred_); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECV_OP_HPP PK��h!\ǉ,e��local_free_on_block_exit.hppnu��[��// // detail/local_free_on_block_exit.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_LOCAL_FREE_ON_BLOCK_EXIT_HPP #define BOOST_ASIO_DETAIL_LOCAL_FREE_ON_BLOCK_EXIT_HPP #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_WINDOWS) \|\| defined(__CYGWIN__) #if !defined(BOOST_ASIO_WINDOWS_APP) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class local_free_on_block_exit : private noncopyable { public: // Constructor blocks all signals for the calling thread. explicit local_free_on_block_exit(void* p) : p_(p) { } // Destructor restores the previous signal mask. ~local_free_on_block_exit() { ::LocalFree(p_); } private: void* p_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // !defined(BOOST_ASIO_WINDOWS_APP) #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_LOCAL_FREE_ON_BLOCK_EXIT_HPP PK��h!\��YV�N��N��win_iocp_socket_service.hppnu��[��// // detail/win_iocp_socket_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_IOCP_SOCKET_SERVICE_HPP #define BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_SERVICE_HPP #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_HAS_IOCP) #include <cstring> #include <boost/asio/error.hpp> #include <boost/asio/execution_context.hpp> #include <boost/asio/socket_base.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/mutex.hpp> #include <boost/asio/detail/operation.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/select_reactor.hpp> #include <boost/asio/detail/socket_holder.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/win_iocp_io_context.hpp> #include <boost/asio/detail/win_iocp_null_buffers_op.hpp> #include <boost/asio/detail/win_iocp_socket_accept_op.hpp> #include <boost/asio/detail/win_iocp_socket_connect_op.hpp> #include <boost/asio/detail/win_iocp_socket_recvfrom_op.hpp> #include <boost/asio/detail/win_iocp_socket_send_op.hpp> #include <boost/asio/detail/win_iocp_socket_service_base.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Protocol> class win_iocp_socket_service : public execution_context_service_base<win_iocp_socket_service<Protocol> >, public win_iocp_socket_service_base { public: // The protocol type. typedef Protocol protocol_type; // The endpoint type. typedef typename Protocol::endpoint endpoint_type; // The native type of a socket. class native_handle_type { public: native_handle_type(socket_type s) : socket_(s), have_remote_endpoint_(false) { } native_handle_type(socket_type s, const endpoint_type& ep) : socket_(s), have_remote_endpoint_(true), remote_endpoint_(ep) { } void operator=(socket_type s) { socket_ = s; have_remote_endpoint_ = false; remote_endpoint_ = endpoint_type(); } operator socket_type() const { return socket_; } bool have_remote_endpoint() const { return have_remote_endpoint_; } endpoint_type remote_endpoint() const { return remote_endpoint_; } private: socket_type socket_; bool have_remote_endpoint_; endpoint_type remote_endpoint_; }; // The implementation type of the socket. struct implementation_type : win_iocp_socket_service_base::base_implementation_type { // Default constructor. implementation_type() : protocol_(endpoint_type().protocol()), have_remote_endpoint_(false), remote_endpoint_() { } // The protocol associated with the socket. protocol_type protocol_; // Whether we have a cached remote endpoint. bool have_remote_endpoint_; // A cached remote endpoint. endpoint_type remote_endpoint_; }; // Constructor. win_iocp_socket_service(execution_context& context) : execution_context_service_base< win_iocp_socket_service<Protocol> >(context), win_iocp_socket_service_base(context) { } // Destroy all user-defined handler objects owned by the service. void shutdown() { this->base_shutdown(); } // Move-construct a new socket implementation. void move_construct(implementation_type& impl, implementation_type& other_impl) BOOST_ASIO_NOEXCEPT { this->base_move_construct(impl, other_impl); impl.protocol_ = other_impl.protocol_; other_impl.protocol_ = endpoint_type().protocol(); impl.have_remote_endpoint_ = other_impl.have_remote_endpoint_; other_impl.have_remote_endpoint_ = false; impl.remote_endpoint_ = other_impl.remote_endpoint_; other_impl.remote_endpoint_ = endpoint_type(); } // Move-assign from another socket implementation. void move_assign(implementation_type& impl, win_iocp_socket_service_base& other_service, implementation_type& other_impl) { this->base_move_assign(impl, other_service, other_impl); impl.protocol_ = other_impl.protocol_; other_impl.protocol_ = endpoint_type().protocol(); impl.have_remote_endpoint_ = other_impl.have_remote_endpoint_; other_impl.have_remote_endpoint_ = false; impl.remote_endpoint_ = other_impl.remote_endpoint_; other_impl.remote_endpoint_ = endpoint_type(); } // Move-construct a new socket implementation from another protocol type. template <typename Protocol1> void converting_move_construct(implementation_type& impl, win_iocp_socket_service<Protocol1>&, typename win_iocp_socket_service< Protocol1>::implementation_type& other_impl) { this->base_move_construct(impl, other_impl); impl.protocol_ = protocol_type(other_impl.protocol_); other_impl.protocol_ = typename Protocol1::endpoint().protocol(); impl.have_remote_endpoint_ = other_impl.have_remote_endpoint_; other_impl.have_remote_endpoint_ = false; impl.remote_endpoint_ = other_impl.remote_endpoint_; other_impl.remote_endpoint_ = typename Protocol1::endpoint(); } // Open a new socket implementation. boost::system::error_code open(implementation_type& impl, const protocol_type& protocol, boost::system::error_code& ec) { if (!do_open(impl, protocol.family(), protocol.type(), protocol.protocol(), ec)) { impl.protocol_ = protocol; impl.have_remote_endpoint_ = false; impl.remote_endpoint_ = endpoint_type(); } return ec; } // Assign a native socket to a socket implementation. boost::system::error_code assign(implementation_type& impl, const protocol_type& protocol, const native_handle_type& native_socket, boost::system::error_code& ec) { if (!do_assign(impl, protocol.type(), native_socket, ec)) { impl.protocol_ = protocol; impl.have_remote_endpoint_ = native_socket.have_remote_endpoint(); impl.remote_endpoint_ = native_socket.remote_endpoint(); } return ec; } // Get the native socket representation. native_handle_type native_handle(implementation_type& impl) { if (impl.have_remote_endpoint_) return native_handle_type(impl.socket_, impl.remote_endpoint_); return native_handle_type(impl.socket_); } // Bind the socket to the specified local endpoint. boost::system::error_code bind(implementation_type& impl, const endpoint_type& endpoint, boost::system::error_code& ec) { socket_ops::bind(impl.socket_, endpoint.data(), endpoint.size(), ec); return ec; } // Set a socket option. template <typename Option> boost::system::error_code set_option(implementation_type& impl, const Option& option, boost::system::error_code& ec) { socket_ops::setsockopt(impl.socket_, impl.state_, option.level(impl.protocol_), option.name(impl.protocol_), option.data(impl.protocol_), option.size(impl.protocol_), ec); return ec; } // Set a socket option. template <typename Option> boost::system::error_code get_option(const implementation_type& impl, Option& option, boost::system::error_code& ec) const { std::size_t size = option.size(impl.protocol_); socket_ops::getsockopt(impl.socket_, impl.state_, option.level(impl.protocol_), option.name(impl.protocol_), option.data(impl.protocol_), &size, ec); if (!ec) option.resize(impl.protocol_, size); return ec; } // Get the local endpoint. endpoint_type local_endpoint(const implementation_type& impl, boost::system::error_code& ec) const { endpoint_type endpoint; std::size_t addr_len = endpoint.capacity(); if (socket_ops::getsockname(impl.socket_, endpoint.data(), &addr_len, ec)) return endpoint_type(); endpoint.resize(addr_len); return endpoint; } // Get the remote endpoint. endpoint_type remote_endpoint(const implementation_type& impl, boost::system::error_code& ec) const { endpoint_type endpoint = impl.remote_endpoint_; std::size_t addr_len = endpoint.capacity(); if (socket_ops::getpeername(impl.socket_, endpoint.data(), &addr_len, impl.have_remote_endpoint_, ec)) return endpoint_type(); endpoint.resize(addr_len); return endpoint; } // Disable sends or receives on the socket. boost::system::error_code shutdown(base_implementation_type& impl, socket_base::shutdown_type what, boost::system::error_code& ec) { socket_ops::shutdown(impl.socket_, what, ec); return ec; } // Send a datagram to the specified endpoint. Returns the number of bytes // sent. template <typename ConstBufferSequence> size_t send_to(implementation_type& impl, const ConstBufferSequence& buffers, const endpoint_type& destination, socket_base::message_flags flags, boost::system::error_code& ec) { buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence> bufs(buffers); return socket_ops::sync_sendto(impl.socket_, impl.state_, bufs.buffers(), bufs.count(), flags, destination.data(), destination.size(), ec); } // Wait until data can be sent without blocking. size_t send_to(implementation_type& impl, const null_buffers&, const endpoint_type&, socket_base::message_flags, boost::system::error_code& ec) { // Wait for socket to become ready. socket_ops::poll_write(impl.socket_, impl.state_, -1, ec); return 0; } // Start an asynchronous send. The data being sent must be valid for the // lifetime of the asynchronous operation. template <typename ConstBufferSequence, typename Handler, typename IoExecutor> void async_send_to(implementation_type& impl, const ConstBufferSequence& buffers, const endpoint_type& destination, socket_base::message_flags flags, Handler& handler, const IoExecutor& io_ex) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_socket_send_op< ConstBufferSequence, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(impl.cancel_token_, buffers, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((context_, p.p, "socket", &impl, impl.socket_, "async_send_to")); buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence> bufs(buffers); start_send_to_op(impl, bufs.buffers(), bufs.count(), destination.data(), static_cast<int>(destination.size()), flags, p.p); p.v = p.p = 0; } // Start an asynchronous wait until data can be sent without blocking. template <typename Handler, typename IoExecutor> void async_send_to(implementation_type& impl, const null_buffers&, const endpoint_type&, socket_base::message_flags, Handler& handler, const IoExecutor& io_ex) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_null_buffers_op<Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(impl.cancel_token_, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((context_, p.p, "socket", &impl, impl.socket_, "async_send_to(null_buffers)")); start_reactor_op(impl, select_reactor::write_op, p.p); p.v = p.p = 0; } // Receive a datagram with the endpoint of the sender. Returns the number of // bytes received. template <typename MutableBufferSequence> size_t receive_from(implementation_type& impl, const MutableBufferSequence& buffers, endpoint_type& sender_endpoint, socket_base::message_flags flags, boost::system::error_code& ec) { buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence> bufs(buffers); std::size_t addr_len = sender_endpoint.capacity(); std::size_t bytes_recvd = socket_ops::sync_recvfrom( impl.socket_, impl.state_, bufs.buffers(), bufs.count(), flags, sender_endpoint.data(), &addr_len, ec); if (!ec) sender_endpoint.resize(addr_len); return bytes_recvd; } // Wait until data can be received without blocking. size_t receive_from(implementation_type& impl, const null_buffers&, endpoint_type& sender_endpoint, socket_base::message_flags, boost::system::error_code& ec) { // Wait for socket to become ready. socket_ops::poll_read(impl.socket_, impl.state_, -1, ec); // Reset endpoint since it can be given no sensible value at this time. sender_endpoint = endpoint_type(); return 0; } // Start an asynchronous receive. The buffer for the data being received and // the sender_endpoint object must both be valid for the lifetime of the // asynchronous operation. template <typename MutableBufferSequence, typename Handler, typename IoExecutor> void async_receive_from(implementation_type& impl, const MutableBufferSequence& buffers, endpoint_type& sender_endp, socket_base::message_flags flags, Handler& handler, const IoExecutor& io_ex) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_socket_recvfrom_op<MutableBufferSequence, endpoint_type, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(sender_endp, impl.cancel_token_, buffers, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((context_, p.p, "socket", &impl, impl.socket_, "async_receive_from")); buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence> bufs(buffers); start_receive_from_op(impl, bufs.buffers(), bufs.count(), sender_endp.data(), flags, &p.p->endpoint_size(), p.p); p.v = p.p = 0; } // Wait until data can be received without blocking. template <typename Handler, typename IoExecutor> void async_receive_from(implementation_type& impl, const null_buffers&, endpoint_type& sender_endpoint, socket_base::message_flags flags, Handler& handler, const IoExecutor& io_ex) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_null_buffers_op<Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(impl.cancel_token_, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((context_, p.p, "socket", &impl, impl.socket_, "async_receive_from(null_buffers)")); // Reset endpoint since it can be given no sensible value at this time. sender_endpoint = endpoint_type(); start_null_buffers_receive_op(impl, flags, p.p); p.v = p.p = 0; } // Accept a new connection. template <typename Socket> boost::system::error_code accept(implementation_type& impl, Socket& peer, endpoint_type* peer_endpoint, boost::system::error_code& ec) { // We cannot accept a socket that is already open. if (peer.is_open()) { ec = boost::asio::error::already_open; return ec; } std::size_t addr_len = peer_endpoint ? peer_endpoint->capacity() : 0; socket_holder new_socket(socket_ops::sync_accept(impl.socket_, impl.state_, peer_endpoint ? peer_endpoint->data() : 0, peer_endpoint ? &addr_len : 0, ec)); // On success, assign new connection to peer socket object. if (new_socket.get() != invalid_socket) { if (peer_endpoint) peer_endpoint->resize(addr_len); peer.assign(impl.protocol_, new_socket.get(), ec); if (!ec) new_socket.release(); } return ec; } // Start an asynchronous accept. The peer and peer_endpoint objects // must be valid until the accept's handler is invoked. template <typename Socket, typename Handler, typename IoExecutor> void async_accept(implementation_type& impl, Socket& peer, endpoint_type* peer_endpoint, Handler& handler, const IoExecutor& io_ex) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_socket_accept_op<Socket, protocol_type, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; bool enable_connection_aborted = (impl.state_ & socket_ops::enable_connection_aborted) != 0; p.p = new (p.v) op(this, impl.socket_, peer, impl.protocol_, peer_endpoint, enable_connection_aborted, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((context_, p.p, "socket", &impl, impl.socket_, "async_accept")); start_accept_op(impl, peer.is_open(), p.p->new_socket(), impl.protocol_.family(), impl.protocol_.type(), impl.protocol_.protocol(), p.p->output_buffer(), p.p->address_length(), p.p); p.v = p.p = 0; } #if defined(BOOST_ASIO_HAS_MOVE) // Start an asynchronous accept. The peer and peer_endpoint objects // must be valid until the accept's handler is invoked. template <typename PeerIoExecutor, typename Handler, typename IoExecutor> void async_move_accept(implementation_type& impl, const PeerIoExecutor& peer_io_ex, endpoint_type* peer_endpoint, Handler& handler, const IoExecutor& io_ex) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_socket_move_accept_op< protocol_type, PeerIoExecutor, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; bool enable_connection_aborted = (impl.state_ & socket_ops::enable_connection_aborted) != 0; p.p = new (p.v) op(this, impl.socket_, impl.protocol_, peer_io_ex, peer_endpoint, enable_connection_aborted, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((context_, p.p, "socket", &impl, impl.socket_, "async_accept")); start_accept_op(impl, false, p.p->new_socket(), impl.protocol_.family(), impl.protocol_.type(), impl.protocol_.protocol(), p.p->output_buffer(), p.p->address_length(), p.p); p.v = p.p = 0; } #endif // defined(BOOST_ASIO_HAS_MOVE) // Connect the socket to the specified endpoint. boost::system::error_code connect(implementation_type& impl, const endpoint_type& peer_endpoint, boost::system::error_code& ec) { socket_ops::sync_connect(impl.socket_, peer_endpoint.data(), peer_endpoint.size(), ec); return ec; } // Start an asynchronous connect. template <typename Handler, typename IoExecutor> void async_connect(implementation_type& impl, const endpoint_type& peer_endpoint, Handler& handler, const IoExecutor& io_ex) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_socket_connect_op<Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(impl.socket_, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((context_, p.p, "socket", &impl, impl.socket_, "async_connect")); start_connect_op(impl, impl.protocol_.family(), impl.protocol_.type(), peer_endpoint.data(), static_cast<int>(peer_endpoint.size()), p.p); p.v = p.p = 0; } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #endif // BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_SERVICE_HPP PK��h!\��`��`�� win_event.hppnu��[��// // detail/win_event.hpp // ~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_EVENT_HPP #define BOOST_ASIO_DETAIL_WIN_EVENT_HPP #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_WINDOWS) #include <cstddef> #include <boost/asio/detail/assert.hpp> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class win_event : private noncopyable { public: // Constructor. BOOST_ASIO_DECL win_event(); // Destructor. BOOST_ASIO_DECL ~win_event(); // Signal the event. (Retained for backward compatibility.) template <typename Lock> void signal(Lock& lock) { this->signal_all(lock); } // Signal all waiters. template <typename Lock> void signal_all(Lock& lock) { BOOST_ASIO_ASSERT(lock.locked()); (void)lock; state_ \|= 1; ::SetEvent(events_[0]); } // Unlock the mutex and signal one waiter. template <typename Lock> void unlock_and_signal_one(Lock& lock) { BOOST_ASIO_ASSERT(lock.locked()); state_ \|= 1; bool have_waiters = (state_ > 1); lock.unlock(); if (have_waiters) ::SetEvent(events_[1]); } // Unlock the mutex and signal one waiter who may destroy us. template <typename Lock> void unlock_and_signal_one_for_destruction(Lock& lock) { BOOST_ASIO_ASSERT(lock.locked()); state_ \|= 1; bool have_waiters = (state_ > 1); if (have_waiters) ::SetEvent(events_[1]); lock.unlock(); } // If there's a waiter, unlock the mutex and signal it. template <typename Lock> bool maybe_unlock_and_signal_one(Lock& lock) { BOOST_ASIO_ASSERT(lock.locked()); state_ \|= 1; if (state_ > 1) { lock.unlock(); ::SetEvent(events_[1]); return true; } return false; } // Reset the event. template <typename Lock> void clear(Lock& lock) { BOOST_ASIO_ASSERT(lock.locked()); (void)lock; ::ResetEvent(events_[0]); state_ &= ~std::size_t(1); } // Wait for the event to become signalled. template <typename Lock> void wait(Lock& lock) { BOOST_ASIO_ASSERT(lock.locked()); while ((state_ & 1) == 0) { state_ += 2; lock.unlock(); #if defined(BOOST_ASIO_WINDOWS_APP) ::WaitForMultipleObjectsEx(2, events_, false, INFINITE, false); #else // defined(BOOST_ASIO_WINDOWS_APP) ::WaitForMultipleObjects(2, events_, false, INFINITE); #endif // defined(BOOST_ASIO_WINDOWS_APP) lock.lock(); state_ -= 2; } } // Timed wait for the event to become signalled. template <typename Lock> bool wait_for_usec(Lock& lock, long usec) { BOOST_ASIO_ASSERT(lock.locked()); if ((state_ & 1) == 0) { state_ += 2; lock.unlock(); DWORD msec = usec > 0 ? (usec < 1000 ? 1 : usec / 1000) : 0; #if defined(BOOST_ASIO_WINDOWS_APP) ::WaitForMultipleObjectsEx(2, events_, false, msec, false); #else // defined(BOOST_ASIO_WINDOWS_APP) ::WaitForMultipleObjects(2, events_, false, msec); #endif // defined(BOOST_ASIO_WINDOWS_APP) lock.lock(); state_ -= 2; } return (state_ & 1) != 0; } private: HANDLE events_[2]; std::size_t state_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/win_event.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_WINDOWS) #endif // BOOST_ASIO_DETAIL_WIN_EVENT_HPP PK��h!\@��posix_event.hppnu��[��// // detail/posix_event.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_POSIX_EVENT_HPP #define BOOST_ASIO_DETAIL_POSIX_EVENT_HPP #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_HAS_PTHREADS) #include <cstddef> #include <pthread.h> #include <boost/asio/detail/assert.hpp> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class posix_event : private noncopyable { public: // Constructor. BOOST_ASIO_DECL posix_event(); // Destructor. ~posix_event() { ::pthread_cond_destroy(&cond_); } // Signal the event. (Retained for backward compatibility.) template <typename Lock> void signal(Lock& lock) { this->signal_all(lock); } // Signal all waiters. template <typename Lock> void signal_all(Lock& lock) { BOOST_ASIO_ASSERT(lock.locked()); (void)lock; state_ \|= 1; ::pthread_cond_broadcast(&cond_); // Ignore EINVAL. } // Unlock the mutex and signal one waiter. template <typename Lock> void unlock_and_signal_one(Lock& lock) { BOOST_ASIO_ASSERT(lock.locked()); state_ \|= 1; bool have_waiters = (state_ > 1); lock.unlock(); if (have_waiters) ::pthread_cond_signal(&cond_); // Ignore EINVAL. } // Unlock the mutex and signal one waiter who may destroy us. template <typename Lock> void unlock_and_signal_one_for_destruction(Lock& lock) { BOOST_ASIO_ASSERT(lock.locked()); state_ \|= 1; bool have_waiters = (state_ > 1); if (have_waiters) ::pthread_cond_signal(&cond_); // Ignore EINVAL. lock.unlock(); } // If there's a waiter, unlock the mutex and signal it. template <typename Lock> bool maybe_unlock_and_signal_one(Lock& lock) { BOOST_ASIO_ASSERT(lock.locked()); state_ \|= 1; if (state_ > 1) { lock.unlock(); ::pthread_cond_signal(&cond_); // Ignore EINVAL. return true; } return false; } // Reset the event. template <typename Lock> void clear(Lock& lock) { BOOST_ASIO_ASSERT(lock.locked()); (void)lock; state_ &= ~std::size_t(1); } // Wait for the event to become signalled. template <typename Lock> void wait(Lock& lock) { BOOST_ASIO_ASSERT(lock.locked()); while ((state_ & 1) == 0) { state_ += 2; ::pthread_cond_wait(&cond_, &lock.mutex().mutex_); // Ignore EINVAL. state_ -= 2; } } // Timed wait for the event to become signalled. template <typename Lock> bool wait_for_usec(Lock& lock, long usec) { BOOST_ASIO_ASSERT(lock.locked()); if ((state_ & 1) == 0) { state_ += 2; timespec ts; #if (defined(__MACH__) && defined(__APPLE__)) \ \|\| (defined(__ANDROID__) && (__ANDROID_API__ < 21) \ && defined(HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE)) ts.tv_sec = usec / 1000000; ts.tv_nsec = (usec % 1000000) 1000; ::pthread_cond_timedwait_relative_np( &cond_, &lock.mutex().mutex_, &ts); // Ignore EINVAL. #else // (defined(__MACH__) && defined(__APPLE__)) // \|\| (defined(__ANDROID__) && (__ANDROID_API__ < 21) // && defined(HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE)) if (::clock_gettime(CLOCK_MONOTONIC, &ts) == 0) { ts.tv_sec += usec / 1000000; ts.tv_nsec += (usec % 1000000) * 1000; ts.tv_sec += ts.tv_nsec / 1000000000; ts.tv_nsec = ts.tv_nsec % 1000000000; ::pthread_cond_timedwait(&cond_, &lock.mutex().mutex_, &ts); // Ignore EINVAL. } #endif // (defined(__MACH__) && defined(__APPLE__)) // \|\| (defined(__ANDROID__) && (__ANDROID_API__ < 21) // && defined(HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE)) state_ -= 2; } return (state_ & 1) != 0; } private: ::pthread_cond_t cond_; std::size_t state_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/posix_event.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_HAS_PTHREADS) #endif // BOOST_ASIO_DETAIL_POSIX_EVENT_HPP PK��h!\eR�� array_fwd.hppnu��[��// // detail/array_fwd.hpp // ~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_ARRAY_FWD_HPP #define BOOST_ASIO_DETAIL_ARRAY_FWD_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> namespace boost { template<class T, std::size_t N> class array; } // namespace boost // Standard library components can't be forward declared, so we'll have to // include the array header. Fortunately, it's fairly lightweight and doesn't // add significantly to the compile time. #if defined(BOOST_ASIO_HAS_STD_ARRAY) # include <array> #endif // defined(BOOST_ASIO_HAS_STD_ARRAY) #endif // BOOST_ASIO_DETAIL_ARRAY_FWD_HPP PK��h!\��ň��win_iocp_socket_recv_op.hppnu��[��// // detail/win_iocp_socket_recv_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_IOCP_SOCKET_RECV_OP_HPP #define BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_RECV_OP_HPP #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_HAS_IOCP) #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/operation.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename MutableBufferSequence, typename Handler, typename IoExecutor> class win_iocp_socket_recv_op : public operation { public: BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_recv_op); win_iocp_socket_recv_op(socket_ops::state_type state, socket_ops::weak_cancel_token_type cancel_token, const MutableBufferSequence& buffers, Handler& handler, const IoExecutor& io_ex) : operation(&win_iocp_socket_recv_op::do_complete), state_(state), cancel_token_(cancel_token), buffers_(buffers), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static void do_complete(void owner, operation* base, const boost::system::error_code& result_ec, std::size_t bytes_transferred) { boost::system::error_code ec(result_ec); // Take ownership of the operation object. win_iocp_socket_recv_op* o(static_cast<win_iocp_socket_recv_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) // Check whether buffers are still valid. if (owner) { buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence>::validate(o->buffers_); } #endif // defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) socket_ops::complete_iocp_recv(o->state_, o->cancel_token_, buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence>::all_empty(o->buffers_), ec, bytes_transferred); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, ec, bytes_transferred); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: socket_ops::state_type state_; socket_ops::weak_cancel_token_type cancel_token_; MutableBufferSequence buffers_; Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #endif // BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_RECV_OP_HPP PK��h!\��u��u��chrono_time_traits.hppnu��[��// // detail/chrono_time_traits.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_CHRONO_TIME_TRAITS_HPP #define BOOST_ASIO_DETAIL_CHRONO_TIME_TRAITS_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/cstdint.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { // Helper template to compute the greatest common divisor. template <int64_t v1, int64_t v2> struct gcd { enum { value = gcd<v2, v1 % v2>::value }; }; template <int64_t v1> struct gcd<v1, 0> { enum { value = v1 }; }; // Adapts std::chrono clocks for use with a deadline timer. template <typename Clock, typename WaitTraits> struct chrono_time_traits { // The clock type. typedef Clock clock_type; // The duration type of the clock. typedef typename clock_type::duration duration_type; // The time point type of the clock. typedef typename clock_type::time_point time_type; // The period of the clock. typedef typename duration_type::period period_type; // Get the current time. static time_type now() { return clock_type::now(); } // Add a duration to a time. static time_type add(const time_type& t, const duration_type& d) { const time_type epoch; if (t >= epoch) { if ((time_type::max)() - t < d) return (time_type::max)(); } else // t < epoch { if (-(t - (time_type::min)()) > d) return (time_type::min)(); } return t + d; } // Subtract one time from another. static duration_type subtract(const time_type& t1, const time_type& t2) { const time_type epoch; if (t1 >= epoch) { if (t2 >= epoch) { return t1 - t2; } else if (t2 == (time_type::min)()) { return (duration_type::max)(); } else if ((time_type::max)() - t1 < epoch - t2) { return (duration_type::max)(); } else { return t1 - t2; } } else // t1 < epoch { if (t2 < epoch) { return t1 - t2; } else if (t1 == (time_type::min)()) { return (duration_type::min)(); } else if ((time_type::max)() - t2 < epoch - t1) { return (duration_type::min)(); } else { return -(t2 - t1); } } } // Test whether one time is less than another. static bool less_than(const time_type& t1, const time_type& t2) { return t1 < t2; } // Implement just enough of the posix_time::time_duration interface to supply // what the timer_queue requires. class posix_time_duration { public: explicit posix_time_duration(const duration_type& d) : d_(d) { } int64_t ticks() const { return d_.count(); } int64_t total_seconds() const { return duration_cast<1, 1>(); } int64_t total_milliseconds() const { return duration_cast<1, 1000>(); } int64_t total_microseconds() const { return duration_cast<1, 1000000>(); } private: template <int64_t Num, int64_t Den> int64_t duration_cast() const { const int64_t num1 = period_type::num / gcd<period_type::num, Num>::value; const int64_t num2 = Num / gcd<period_type::num, Num>::value; const int64_t den1 = period_type::den / gcd<period_type::den, Den>::value; const int64_t den2 = Den / gcd<period_type::den, Den>::value; const int64_t num = num1 den2; const int64_t den = num2 * den1; if (num == 1 && den == 1) return ticks(); else if (num != 1 && den == 1) return ticks() * num; else if (num == 1 && period_type::den != 1) return ticks() / den; else return ticks() * num / den; } duration_type d_; }; // Convert to POSIX duration type. static posix_time_duration to_posix_duration(const duration_type& d) { return posix_time_duration(WaitTraits::to_wait_duration(d)); } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_CHRONO_TIME_TRAITS_HPP PK��h!\1q��F2��F2��winrt_ssocket_service_base.hppnu��[��// // detail/winrt_ssocket_service_base.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WINRT_SSOCKET_SERVICE_BASE_HPP #define BOOST_ASIO_DETAIL_WINRT_SSOCKET_SERVICE_BASE_HPP #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_WINDOWS_RUNTIME) #include <boost/asio/buffer.hpp> #include <boost/asio/error.hpp> #include <boost/asio/execution_context.hpp> #include <boost/asio/socket_base.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/winrt_async_manager.hpp> #include <boost/asio/detail/winrt_socket_recv_op.hpp> #include <boost/asio/detail/winrt_socket_send_op.hpp> #if defined(BOOST_ASIO_HAS_IOCP) # include <boost/asio/detail/win_iocp_io_context.hpp> #else // defined(BOOST_ASIO_HAS_IOCP) # include <boost/asio/detail/scheduler.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class winrt_ssocket_service_base { public: // The native type of a socket. typedef Windows::Networking::Sockets::StreamSocket^ native_handle_type; // The implementation type of the socket. struct base_implementation_type { // Default constructor. base_implementation_type() : socket_(nullptr), next_(0), prev_(0) { } // The underlying native socket. native_handle_type socket_; // Pointers to adjacent socket implementations in linked list. base_implementation_type* next_; base_implementation_type* prev_; }; // Constructor. BOOST_ASIO_DECL winrt_ssocket_service_base(execution_context& context); // Destroy all user-defined handler objects owned by the service. BOOST_ASIO_DECL void base_shutdown(); // Construct a new socket implementation. BOOST_ASIO_DECL void construct(base_implementation_type&); // Move-construct a new socket implementation. BOOST_ASIO_DECL void base_move_construct(base_implementation_type& impl, base_implementation_type& other_impl) BOOST_ASIO_NOEXCEPT; // Move-assign from another socket implementation. BOOST_ASIO_DECL void base_move_assign(base_implementation_type& impl, winrt_ssocket_service_base& other_service, base_implementation_type& other_impl); // Destroy a socket implementation. BOOST_ASIO_DECL void destroy(base_implementation_type& impl); // Determine whether the socket is open. bool is_open(const base_implementation_type& impl) const { return impl.socket_ != nullptr; } // Destroy a socket implementation. BOOST_ASIO_DECL boost::system::error_code close( base_implementation_type& impl, boost::system::error_code& ec); // Release ownership of the socket. BOOST_ASIO_DECL native_handle_type release( base_implementation_type& impl, boost::system::error_code& ec); // Get the native socket representation. native_handle_type native_handle(base_implementation_type& impl) { return impl.socket_; } // Cancel all operations associated with the socket. boost::system::error_code cancel(base_implementation_type&, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return ec; } // Determine whether the socket is at the out-of-band data mark. bool at_mark(const base_implementation_type&, boost::system::error_code& ec) const { ec = boost::asio::error::operation_not_supported; return false; } // Determine the number of bytes available for reading. std::size_t available(const base_implementation_type&, boost::system::error_code& ec) const { ec = boost::asio::error::operation_not_supported; return 0; } // Perform an IO control command on the socket. template <typename IO_Control_Command> boost::system::error_code io_control(base_implementation_type&, IO_Control_Command&, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return ec; } // Gets the non-blocking mode of the socket. bool non_blocking(const base_implementation_type&) const { return false; } // Sets the non-blocking mode of the socket. boost::system::error_code non_blocking(base_implementation_type&, bool, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return ec; } // Gets the non-blocking mode of the native socket implementation. bool native_non_blocking(const base_implementation_type&) const { return false; } // Sets the non-blocking mode of the native socket implementation. boost::system::error_code native_non_blocking(base_implementation_type&, bool, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return ec; } // Send the given data to the peer. template <typename ConstBufferSequence> std::size_t send(base_implementation_type& impl, const ConstBufferSequence& buffers, socket_base::message_flags flags, boost::system::error_code& ec) { return do_send(impl, buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence>::first(buffers), flags, ec); } // Wait until data can be sent without blocking. std::size_t send(base_implementation_type&, const null_buffers&, socket_base::message_flags, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return 0; } // Start an asynchronous send. The data being sent must be valid for the // lifetime of the asynchronous operation. template <typename ConstBufferSequence, typename Handler, typename IoExecutor> void async_send(base_implementation_type& impl, const ConstBufferSequence& buffers, socket_base::message_flags flags, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef winrt_socket_send_op<ConstBufferSequence, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(buffers, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((scheduler_.context(), p.p, "socket", &impl, 0, "async_send")); start_send_op(impl, buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence>::first(buffers), flags, p.p, is_continuation); p.v = p.p = 0; } // Start an asynchronous wait until data can be sent without blocking. template <typename Handler, typename IoExecutor> void async_send(base_implementation_type&, const null_buffers&, socket_base::message_flags, Handler& handler, const IoExecutor& io_ex) { boost::system::error_code ec = boost::asio::error::operation_not_supported; const std::size_t bytes_transferred = 0; boost::asio::post(io_ex, detail::bind_handler(handler, ec, bytes_transferred)); } // Receive some data from the peer. Returns the number of bytes received. template <typename MutableBufferSequence> std::size_t receive(base_implementation_type& impl, const MutableBufferSequence& buffers, socket_base::message_flags flags, boost::system::error_code& ec) { return do_receive(impl, buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence>::first(buffers), flags, ec); } // Wait until data can be received without blocking. std::size_t receive(base_implementation_type&, const null_buffers&, socket_base::message_flags, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return 0; } // Start an asynchronous receive. The buffer for the data being received // must be valid for the lifetime of the asynchronous operation. template <typename MutableBufferSequence, typename Handler, typename IoExecutor> void async_receive(base_implementation_type& impl, const MutableBufferSequence& buffers, socket_base::message_flags flags, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef winrt_socket_recv_op<MutableBufferSequence, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(buffers, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((scheduler_.context(), p.p, "socket", &impl, 0, "async_receive")); start_receive_op(impl, buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence>::first(buffers), flags, p.p, is_continuation); p.v = p.p = 0; } // Wait until data can be received without blocking. template <typename Handler, typename IoExecutor> void async_receive(base_implementation_type&, const null_buffers&, socket_base::message_flags, Handler& handler, const IoExecutor& io_ex) { boost::system::error_code ec = boost::asio::error::operation_not_supported; const std::size_t bytes_transferred = 0; boost::asio::post(io_ex, detail::bind_handler(handler, ec, bytes_transferred)); } protected: // Helper function to obtain endpoints associated with the connection. BOOST_ASIO_DECL std::size_t do_get_endpoint( const base_implementation_type& impl, bool local, void* addr, std::size_t addr_len, boost::system::error_code& ec) const; // Helper function to set a socket option. BOOST_ASIO_DECL boost::system::error_code do_set_option( base_implementation_type& impl, int level, int optname, const void* optval, std::size_t optlen, boost::system::error_code& ec); // Helper function to get a socket option. BOOST_ASIO_DECL void do_get_option( const base_implementation_type& impl, int level, int optname, void* optval, std::size_t* optlen, boost::system::error_code& ec) const; // Helper function to perform a synchronous connect. BOOST_ASIO_DECL boost::system::error_code do_connect( base_implementation_type& impl, const void* addr, boost::system::error_code& ec); // Helper function to start an asynchronous connect. BOOST_ASIO_DECL void start_connect_op( base_implementation_type& impl, const void* addr, winrt_async_op<void>* op, bool is_continuation); // Helper function to perform a synchronous send. BOOST_ASIO_DECL std::size_t do_send( base_implementation_type& impl, const boost::asio::const_buffer& data, socket_base::message_flags flags, boost::system::error_code& ec); // Helper function to start an asynchronous send. BOOST_ASIO_DECL void start_send_op(base_implementation_type& impl, const boost::asio::const_buffer& data, socket_base::message_flags flags, winrt_async_op<unsigned int>* op, bool is_continuation); // Helper function to perform a synchronous receive. BOOST_ASIO_DECL std::size_t do_receive( base_implementation_type& impl, const boost::asio::mutable_buffer& data, socket_base::message_flags flags, boost::system::error_code& ec); // Helper function to start an asynchronous receive. BOOST_ASIO_DECL void start_receive_op(base_implementation_type& impl, const boost::asio::mutable_buffer& data, socket_base::message_flags flags, winrt_async_op<Windows::Storage::Streams::IBuffer^>* op, bool is_continuation); // The scheduler implementation used for delivering completions. #if defined(BOOST_ASIO_HAS_IOCP) typedef class win_iocp_io_context scheduler_impl; #else typedef class scheduler scheduler_impl; #endif scheduler_impl& scheduler_; // The manager that keeps track of outstanding operations. winrt_async_manager& async_manager_; // Mutex to protect access to the linked list of implementations. boost::asio::detail::mutex mutex_; // The head of a linked list of all implementations. base_implementation_type* impl_list_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/winrt_ssocket_service_base.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_WINRT_SSOCKET_SERVICE_BASE_HPP PK��h!\;�_�N��N�� regex_fwd.hppnu��[��// // detail/regex_fwd.hpp // ~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_REGEX_FWD_HPP #define BOOST_ASIO_DETAIL_REGEX_FWD_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #if defined(BOOST_ASIO_HAS_BOOST_REGEX) #include <boost/regex_fwd.hpp> #include <boost/regex/v4/match_flags.hpp> namespace boost { template <class BidiIterator> struct sub_match; template <class BidiIterator, class Allocator> class match_results; } // namespace boost #endif // defined(BOOST_ASIO_HAS_BOOST_REGEX) #endif // BOOST_ASIO_DETAIL_REGEX_FWD_HPP PK��h!\��:��:��solaris_fenced_block.hppnu��[��// // detail/solaris_fenced_block.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_SOLARIS_FENCED_BLOCK_HPP #define BOOST_ASIO_DETAIL_SOLARIS_FENCED_BLOCK_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(__sun) #include <atomic.h> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class solaris_fenced_block : private noncopyable { public: enum half_t { half }; enum full_t { full }; // Constructor for a half fenced block. explicit solaris_fenced_block(half_t) { } // Constructor for a full fenced block. explicit solaris_fenced_block(full_t) { membar_consumer(); } // Destructor. ~solaris_fenced_block() { membar_producer(); } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(__sun) #endif // BOOST_ASIO_DETAIL_SOLARIS_FENCED_BLOCK_HPP PK��h!\��fϷ��posix_signal_blocker.hppnu��[��// // detail/posix_signal_blocker.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_POSIX_SIGNAL_BLOCKER_HPP #define BOOST_ASIO_DETAIL_POSIX_SIGNAL_BLOCKER_HPP #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_HAS_PTHREADS) #include <csignal> #include <pthread.h> #include <signal.h> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class posix_signal_blocker : private noncopyable { public: // Constructor blocks all signals for the calling thread. posix_signal_blocker() : blocked_(false) { sigset_t new_mask; sigfillset(&new_mask); blocked_ = (pthread_sigmask(SIG_BLOCK, &new_mask, &old_mask_) == 0); } // Destructor restores the previous signal mask. ~posix_signal_blocker() { if (blocked_) pthread_sigmask(SIG_SETMASK, &old_mask_, 0); } // Block all signals for the calling thread. void block() { if (!blocked_) { sigset_t new_mask; sigfillset(&new_mask); blocked_ = (pthread_sigmask(SIG_BLOCK, &new_mask, &old_mask_) == 0); } } // Restore the previous signal mask. void unblock() { if (blocked_) blocked_ = (pthread_sigmask(SIG_SETMASK, &old_mask_, 0) != 0); } private: // Have signals been blocked. bool blocked_; // The previous signal mask. sigset_t old_mask_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_PTHREADS) #endif // BOOST_ASIO_DETAIL_POSIX_SIGNAL_BLOCKER_HPP PK��h!\�p�]6��]6��socket_ops.hppnu��[��// // detail/socket_ops.hpp // ~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_SOCKET_OPS_HPP #define BOOST_ASIO_DETAIL_SOCKET_OPS_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <boost/system/error_code.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { namespace socket_ops { // Socket state bits. enum { // The user wants a non-blocking socket. user_set_non_blocking = 1, // The socket has been set non-blocking. internal_non_blocking = 2, // Helper "state" used to determine whether the socket is non-blocking. non_blocking = user_set_non_blocking \| internal_non_blocking, // User wants connection_aborted errors, which are disabled by default. enable_connection_aborted = 4, // The user set the linger option. Needs to be checked when closing. user_set_linger = 8, // The socket is stream-oriented. stream_oriented = 16, // The socket is datagram-oriented. datagram_oriented = 32, // The socket may have been dup()-ed. possible_dup = 64 }; typedef unsigned char state_type; struct noop_deleter { void operator()(void) {} }; typedef shared_ptr<void> shared_cancel_token_type; typedef weak_ptr<void> weak_cancel_token_type; #if !defined(BOOST_ASIO_WINDOWS_RUNTIME) BOOST_ASIO_DECL socket_type accept(socket_type s, socket_addr_type addr, std::size_t* addrlen, boost::system::error_code& ec); BOOST_ASIO_DECL socket_type sync_accept(socket_type s, state_type state, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec); #if defined(BOOST_ASIO_HAS_IOCP) BOOST_ASIO_DECL void complete_iocp_accept(socket_type s, void* output_buffer, DWORD address_length, socket_addr_type* addr, std::size_t* addrlen, socket_type new_socket, boost::system::error_code& ec); #else // defined(BOOST_ASIO_HAS_IOCP) BOOST_ASIO_DECL bool non_blocking_accept(socket_type s, state_type state, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec, socket_type& new_socket); #endif // defined(BOOST_ASIO_HAS_IOCP) BOOST_ASIO_DECL int bind(socket_type s, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec); BOOST_ASIO_DECL int close(socket_type s, state_type& state, bool destruction, boost::system::error_code& ec); BOOST_ASIO_DECL bool set_user_non_blocking(socket_type s, state_type& state, bool value, boost::system::error_code& ec); BOOST_ASIO_DECL bool set_internal_non_blocking(socket_type s, state_type& state, bool value, boost::system::error_code& ec); BOOST_ASIO_DECL int shutdown(socket_type s, int what, boost::system::error_code& ec); BOOST_ASIO_DECL int connect(socket_type s, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec); BOOST_ASIO_DECL void sync_connect(socket_type s, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec); #if defined(BOOST_ASIO_HAS_IOCP) BOOST_ASIO_DECL void complete_iocp_connect(socket_type s, boost::system::error_code& ec); #endif // defined(BOOST_ASIO_HAS_IOCP) BOOST_ASIO_DECL bool non_blocking_connect(socket_type s, boost::system::error_code& ec); BOOST_ASIO_DECL int socketpair(int af, int type, int protocol, socket_type sv[2], boost::system::error_code& ec); BOOST_ASIO_DECL bool sockatmark(socket_type s, boost::system::error_code& ec); BOOST_ASIO_DECL size_t available(socket_type s, boost::system::error_code& ec); BOOST_ASIO_DECL int listen(socket_type s, int backlog, boost::system::error_code& ec); #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) typedef WSABUF buf; #else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) typedef iovec buf; #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) BOOST_ASIO_DECL void init_buf(buf& b, void* data, size_t size); BOOST_ASIO_DECL void init_buf(buf& b, const void* data, size_t size); BOOST_ASIO_DECL signed_size_type recv(socket_type s, buf* bufs, size_t count, int flags, boost::system::error_code& ec); BOOST_ASIO_DECL signed_size_type recv1(socket_type s, void* data, size_t size, int flags, boost::system::error_code& ec); BOOST_ASIO_DECL size_t sync_recv(socket_type s, state_type state, buf* bufs, size_t count, int flags, bool all_empty, boost::system::error_code& ec); BOOST_ASIO_DECL size_t sync_recv1(socket_type s, state_type state, void* data, size_t size, int flags, boost::system::error_code& ec); #if defined(BOOST_ASIO_HAS_IOCP) BOOST_ASIO_DECL void complete_iocp_recv(state_type state, const weak_cancel_token_type& cancel_token, bool all_empty, boost::system::error_code& ec, size_t bytes_transferred); #else // defined(BOOST_ASIO_HAS_IOCP) BOOST_ASIO_DECL bool non_blocking_recv(socket_type s, buf* bufs, size_t count, int flags, bool is_stream, boost::system::error_code& ec, size_t& bytes_transferred); BOOST_ASIO_DECL bool non_blocking_recv1(socket_type s, void* data, size_t size, int flags, bool is_stream, boost::system::error_code& ec, size_t& bytes_transferred); #endif // defined(BOOST_ASIO_HAS_IOCP) BOOST_ASIO_DECL signed_size_type recvfrom(socket_type s, buf* bufs, size_t count, int flags, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec); BOOST_ASIO_DECL signed_size_type recvfrom1(socket_type s, void* data, size_t size, int flags, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec); BOOST_ASIO_DECL size_t sync_recvfrom(socket_type s, state_type state, buf* bufs, size_t count, int flags, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec); BOOST_ASIO_DECL size_t sync_recvfrom1(socket_type s, state_type state, void* data, size_t size, int flags, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec); #if defined(BOOST_ASIO_HAS_IOCP) BOOST_ASIO_DECL void complete_iocp_recvfrom( const weak_cancel_token_type& cancel_token, boost::system::error_code& ec); #else // defined(BOOST_ASIO_HAS_IOCP) BOOST_ASIO_DECL bool non_blocking_recvfrom(socket_type s, buf* bufs, size_t count, int flags, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec, size_t& bytes_transferred); BOOST_ASIO_DECL bool non_blocking_recvfrom1(socket_type s, void* data, size_t size, int flags, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec, size_t& bytes_transferred); #endif // defined(BOOST_ASIO_HAS_IOCP) BOOST_ASIO_DECL signed_size_type recvmsg(socket_type s, buf* bufs, size_t count, int in_flags, int& out_flags, boost::system::error_code& ec); BOOST_ASIO_DECL size_t sync_recvmsg(socket_type s, state_type state, buf* bufs, size_t count, int in_flags, int& out_flags, boost::system::error_code& ec); #if defined(BOOST_ASIO_HAS_IOCP) BOOST_ASIO_DECL void complete_iocp_recvmsg( const weak_cancel_token_type& cancel_token, boost::system::error_code& ec); #else // defined(BOOST_ASIO_HAS_IOCP) BOOST_ASIO_DECL bool non_blocking_recvmsg(socket_type s, buf* bufs, size_t count, int in_flags, int& out_flags, boost::system::error_code& ec, size_t& bytes_transferred); #endif // defined(BOOST_ASIO_HAS_IOCP) BOOST_ASIO_DECL signed_size_type send(socket_type s, const buf* bufs, size_t count, int flags, boost::system::error_code& ec); BOOST_ASIO_DECL signed_size_type send1(socket_type s, const void* data, size_t size, int flags, boost::system::error_code& ec); BOOST_ASIO_DECL size_t sync_send(socket_type s, state_type state, const buf* bufs, size_t count, int flags, bool all_empty, boost::system::error_code& ec); BOOST_ASIO_DECL size_t sync_send1(socket_type s, state_type state, const void* data, size_t size, int flags, boost::system::error_code& ec); #if defined(BOOST_ASIO_HAS_IOCP) BOOST_ASIO_DECL void complete_iocp_send( const weak_cancel_token_type& cancel_token, boost::system::error_code& ec); #else // defined(BOOST_ASIO_HAS_IOCP) BOOST_ASIO_DECL bool non_blocking_send(socket_type s, const buf* bufs, size_t count, int flags, boost::system::error_code& ec, size_t& bytes_transferred); BOOST_ASIO_DECL bool non_blocking_send1(socket_type s, const void* data, size_t size, int flags, boost::system::error_code& ec, size_t& bytes_transferred); #endif // defined(BOOST_ASIO_HAS_IOCP) BOOST_ASIO_DECL signed_size_type sendto(socket_type s, const buf* bufs, size_t count, int flags, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec); BOOST_ASIO_DECL signed_size_type sendto1(socket_type s, const void* data, size_t size, int flags, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec); BOOST_ASIO_DECL size_t sync_sendto(socket_type s, state_type state, const buf* bufs, size_t count, int flags, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec); BOOST_ASIO_DECL size_t sync_sendto1(socket_type s, state_type state, const void* data, size_t size, int flags, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec); #if !defined(BOOST_ASIO_HAS_IOCP) BOOST_ASIO_DECL bool non_blocking_sendto(socket_type s, const buf* bufs, size_t count, int flags, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec, size_t& bytes_transferred); BOOST_ASIO_DECL bool non_blocking_sendto1(socket_type s, const void* data, size_t size, int flags, const socket_addr_type* addr, std::size_t addrlen, boost::system::error_code& ec, size_t& bytes_transferred); #endif // !defined(BOOST_ASIO_HAS_IOCP) BOOST_ASIO_DECL socket_type socket(int af, int type, int protocol, boost::system::error_code& ec); BOOST_ASIO_DECL int setsockopt(socket_type s, state_type& state, int level, int optname, const void* optval, std::size_t optlen, boost::system::error_code& ec); BOOST_ASIO_DECL int getsockopt(socket_type s, state_type state, int level, int optname, void* optval, size_t* optlen, boost::system::error_code& ec); BOOST_ASIO_DECL int getpeername(socket_type s, socket_addr_type* addr, std::size_t* addrlen, bool cached, boost::system::error_code& ec); BOOST_ASIO_DECL int getsockname(socket_type s, socket_addr_type* addr, std::size_t* addrlen, boost::system::error_code& ec); BOOST_ASIO_DECL int ioctl(socket_type s, state_type& state, int cmd, ioctl_arg_type* arg, boost::system::error_code& ec); BOOST_ASIO_DECL int select(int nfds, fd_set* readfds, fd_set* writefds, fd_set* exceptfds, timeval* timeout, boost::system::error_code& ec); BOOST_ASIO_DECL int poll_read(socket_type s, state_type state, int msec, boost::system::error_code& ec); BOOST_ASIO_DECL int poll_write(socket_type s, state_type state, int msec, boost::system::error_code& ec); BOOST_ASIO_DECL int poll_error(socket_type s, state_type state, int msec, boost::system::error_code& ec); BOOST_ASIO_DECL int poll_connect(socket_type s, int msec, boost::system::error_code& ec); #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) BOOST_ASIO_DECL const char* inet_ntop(int af, const void* src, char* dest, size_t length, unsigned long scope_id, boost::system::error_code& ec); BOOST_ASIO_DECL int inet_pton(int af, const char* src, void* dest, unsigned long* scope_id, boost::system::error_code& ec); BOOST_ASIO_DECL int gethostname(char* name, int namelen, boost::system::error_code& ec); #if !defined(BOOST_ASIO_WINDOWS_RUNTIME) BOOST_ASIO_DECL boost::system::error_code getaddrinfo(const char* host, const char* service, const addrinfo_type& hints, addrinfo_type** result, boost::system::error_code& ec); BOOST_ASIO_DECL boost::system::error_code background_getaddrinfo( const weak_cancel_token_type& cancel_token, const char* host, const char* service, const addrinfo_type& hints, addrinfo_type** result, boost::system::error_code& ec); BOOST_ASIO_DECL void freeaddrinfo(addrinfo_type* ai); BOOST_ASIO_DECL boost::system::error_code getnameinfo( const socket_addr_type* addr, std::size_t addrlen, char* host, std::size_t hostlen, char* serv, std::size_t servlen, int flags, boost::system::error_code& ec); BOOST_ASIO_DECL boost::system::error_code sync_getnameinfo( const socket_addr_type* addr, std::size_t addrlen, char* host, std::size_t hostlen, char* serv, std::size_t servlen, int sock_type, boost::system::error_code& ec); BOOST_ASIO_DECL boost::system::error_code background_getnameinfo( const weak_cancel_token_type& cancel_token, const socket_addr_type* addr, std::size_t addrlen, char* host, std::size_t hostlen, char* serv, std::size_t servlen, int sock_type, boost::system::error_code& ec); #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) BOOST_ASIO_DECL u_long_type network_to_host_long(u_long_type value); BOOST_ASIO_DECL u_long_type host_to_network_long(u_long_type value); BOOST_ASIO_DECL u_short_type network_to_host_short(u_short_type value); BOOST_ASIO_DECL u_short_type host_to_network_short(u_short_type value); } // namespace socket_ops } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/socket_ops.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // BOOST_ASIO_DETAIL_SOCKET_OPS_HPP PK��h!\X;@�2��2��win_iocp_socket_connect_op.hppnu��[��// // detail/win_iocp_socket_connect_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_IOCP_SOCKET_CONNECT_OP_HPP #define BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_CONNECT_OP_HPP #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_HAS_IOCP) #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class win_iocp_socket_connect_op_base : public reactor_op { public: win_iocp_socket_connect_op_base(socket_type socket, func_type complete_func) : reactor_op(boost::system::error_code(), &win_iocp_socket_connect_op_base::do_perform, complete_func), socket_(socket), connect_ex_(false) { } static status do_perform(reactor_op* base) { win_iocp_socket_connect_op_base* o( static_cast<win_iocp_socket_connect_op_base>(base)); return socket_ops::non_blocking_connect( o->socket_, o->ec_) ? done : not_done; } socket_type socket_; bool connect_ex_; }; template <typename Handler, typename IoExecutor> class win_iocp_socket_connect_op : public win_iocp_socket_connect_op_base { public: BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_connect_op); win_iocp_socket_connect_op(socket_type socket, Handler& handler, const IoExecutor& io_ex) : win_iocp_socket_connect_op_base(socket, &win_iocp_socket_connect_op::do_complete), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static void do_complete(void owner, operation* base, const boost::system::error_code& result_ec, std::size_t /bytes_transferred/) { boost::system::error_code ec(result_ec); // Take ownership of the operation object. win_iocp_socket_connect_op* o( static_cast<win_iocp_socket_connect_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; if (owner) { if (o->connect_ex_) socket_ops::complete_iocp_connect(o->socket_, ec); else ec = o->ec_; } BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder1<Handler, boost::system::error_code> handler(o->handler_, ec); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #endif // BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_CONNECT_OP_HPP PK��h!\�Z�?�-��-��win_iocp_io_context.hppnu��[��// // detail/win_iocp_io_context.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_IOCP_IO_CONTEXT_HPP #define BOOST_ASIO_DETAIL_WIN_IOCP_IO_CONTEXT_HPP #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_HAS_IOCP) #include <boost/asio/detail/limits.hpp> #include <boost/asio/detail/mutex.hpp> #include <boost/asio/detail/op_queue.hpp> #include <boost/asio/detail/scoped_ptr.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/thread.hpp> #include <boost/asio/detail/thread_context.hpp> #include <boost/asio/detail/timer_queue_base.hpp> #include <boost/asio/detail/timer_queue_set.hpp> #include <boost/asio/detail/wait_op.hpp> #include <boost/asio/detail/win_iocp_operation.hpp> #include <boost/asio/detail/win_iocp_thread_info.hpp> #include <boost/asio/execution_context.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class wait_op; class win_iocp_io_context : public execution_context_service_base<win_iocp_io_context>, public thread_context { public: // Constructor. Specifies a concurrency hint that is passed through to the // underlying I/O completion port. BOOST_ASIO_DECL win_iocp_io_context(boost::asio::execution_context& ctx, int concurrency_hint = -1, bool own_thread = true); // Destructor. BOOST_ASIO_DECL ~win_iocp_io_context(); // Destroy all user-defined handler objects owned by the service. BOOST_ASIO_DECL void shutdown(); // Initialise the task. Nothing to do here. void init_task() { } // Register a handle with the IO completion port. BOOST_ASIO_DECL boost::system::error_code register_handle( HANDLE handle, boost::system::error_code& ec); // Run the event loop until stopped or no more work. BOOST_ASIO_DECL size_t run(boost::system::error_code& ec); // Run until stopped or one operation is performed. BOOST_ASIO_DECL size_t run_one(boost::system::error_code& ec); // Run until timeout, interrupted, or one operation is performed. BOOST_ASIO_DECL size_t wait_one(long usec, boost::system::error_code& ec); // Poll for operations without blocking. BOOST_ASIO_DECL size_t poll(boost::system::error_code& ec); // Poll for one operation without blocking. BOOST_ASIO_DECL size_t poll_one(boost::system::error_code& ec); // Stop the event processing loop. BOOST_ASIO_DECL void stop(); // Determine whether the io_context is stopped. bool stopped() const { return ::InterlockedExchangeAdd(&stopped_, 0) != 0; } // Restart in preparation for a subsequent run invocation. void restart() { ::InterlockedExchange(&stopped_, 0); } // Notify that some work has started. void work_started() { ::InterlockedIncrement(&outstanding_work_); } // Notify that some work has finished. void work_finished() { if (::InterlockedDecrement(&outstanding_work_) == 0) stop(); } // Return whether a handler can be dispatched immediately. bool can_dispatch() { return thread_call_stack::contains(this) != 0; } /// Capture the current exception so it can be rethrown from a run function. BOOST_ASIO_DECL void capture_current_exception(); // Request invocation of the given operation and return immediately. Assumes // that work_started() has not yet been called for the operation. void post_immediate_completion(win_iocp_operation* op, bool) { work_started(); post_deferred_completion(op); } // Request invocation of the given operation and return immediately. Assumes // that work_started() was previously called for the operation. BOOST_ASIO_DECL void post_deferred_completion(win_iocp_operation* op); // Request invocation of the given operation and return immediately. Assumes // that work_started() was previously called for the operations. BOOST_ASIO_DECL void post_deferred_completions( op_queue<win_iocp_operation>& ops); // Request invocation of the given operation using the thread-private queue // and return immediately. Assumes that work_started() has not yet been // called for the operation. void post_private_immediate_completion(win_iocp_operation* op) { post_immediate_completion(op, false); } // Request invocation of the given operation using the thread-private queue // and return immediately. Assumes that work_started() was previously called // for the operation. void post_private_deferred_completion(win_iocp_operation* op) { post_deferred_completion(op); } // Enqueue the given operation following a failed attempt to dispatch the // operation for immediate invocation. void do_dispatch(operation* op) { post_immediate_completion(op, false); } // Process unfinished operations as part of a shutdown operation. Assumes // that work_started() was previously called for the operations. BOOST_ASIO_DECL void abandon_operations(op_queue<operation>& ops); // Called after starting an overlapped I/O operation that did not complete // immediately. The caller must have already called work_started() prior to // starting the operation. BOOST_ASIO_DECL void on_pending(win_iocp_operation* op); // Called after starting an overlapped I/O operation that completed // immediately. The caller must have already called work_started() prior to // starting the operation. BOOST_ASIO_DECL void on_completion(win_iocp_operation* op, DWORD last_error = 0, DWORD bytes_transferred = 0); // Called after starting an overlapped I/O operation that completed // immediately. The caller must have already called work_started() prior to // starting the operation. BOOST_ASIO_DECL void on_completion(win_iocp_operation* op, const boost::system::error_code& ec, DWORD bytes_transferred = 0); // Add a new timer queue to the service. template <typename Time_Traits> void add_timer_queue(timer_queue<Time_Traits>& timer_queue); // Remove a timer queue from the service. template <typename Time_Traits> void remove_timer_queue(timer_queue<Time_Traits>& timer_queue); // Schedule a new operation in the given timer queue to expire at the // specified absolute time. template <typename Time_Traits> void schedule_timer(timer_queue<Time_Traits>& queue, const typename Time_Traits::time_type& time, typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op); // Cancel the timer associated with the given token. Returns the number of // handlers that have been posted or dispatched. template <typename Time_Traits> std::size_t cancel_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& timer, std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)()); // Move the timer operations associated with the given timer. template <typename Time_Traits> void move_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& to, typename timer_queue<Time_Traits>::per_timer_data& from); // Get the concurrency hint that was used to initialise the io_context. int concurrency_hint() const { return concurrency_hint_; } private: #if defined(WINVER) && (WINVER < 0x0500) typedef DWORD dword_ptr_t; typedef ULONG ulong_ptr_t; #else // defined(WINVER) && (WINVER < 0x0500) typedef DWORD_PTR dword_ptr_t; typedef ULONG_PTR ulong_ptr_t; #endif // defined(WINVER) && (WINVER < 0x0500) // Dequeues at most one operation from the I/O completion port, and then // executes it. Returns the number of operations that were dequeued (i.e. // either 0 or 1). BOOST_ASIO_DECL size_t do_one(DWORD msec, win_iocp_thread_info& this_thread, boost::system::error_code& ec); // Helper to calculate the GetQueuedCompletionStatus timeout. BOOST_ASIO_DECL static DWORD get_gqcs_timeout(); // Helper function to add a new timer queue. BOOST_ASIO_DECL void do_add_timer_queue(timer_queue_base& queue); // Helper function to remove a timer queue. BOOST_ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue); // Called to recalculate and update the timeout. BOOST_ASIO_DECL void update_timeout(); // Helper class to call work_finished() on block exit. struct work_finished_on_block_exit; // Helper class for managing a HANDLE. struct auto_handle { HANDLE handle; auto_handle() : handle(0) {} ~auto_handle() { if (handle) ::CloseHandle(handle); } }; // The IO completion port used for queueing operations. auto_handle iocp_; // The count of unfinished work. long outstanding_work_; // Flag to indicate whether the event loop has been stopped. mutable long stopped_; // Flag to indicate whether there is an in-flight stop event. Every event // posted using PostQueuedCompletionStatus consumes non-paged pool, so to // avoid exhausting this resouce we limit the number of outstanding events. long stop_event_posted_; // Flag to indicate whether the service has been shut down. long shutdown_; enum { // Timeout to use with GetQueuedCompletionStatus on older versions of // Windows. Some versions of windows have a "bug" where a call to // GetQueuedCompletionStatus can appear stuck even though there are events // waiting on the queue. Using a timeout helps to work around the issue. default_gqcs_timeout = 500, // Maximum waitable timer timeout, in milliseconds. max_timeout_msec = 5 * 60 * 1000, // Maximum waitable timer timeout, in microseconds. max_timeout_usec = max_timeout_msec * 1000, // Completion key value used to wake up a thread to dispatch timers or // completed operations. wake_for_dispatch = 1, // Completion key value to indicate that an operation has posted with the // original last_error and bytes_transferred values stored in the fields of // the OVERLAPPED structure. overlapped_contains_result = 2 }; // Timeout to use with GetQueuedCompletionStatus. const DWORD gqcs_timeout_; // Helper class to run the scheduler in its own thread. struct thread_function; friend struct thread_function; // Function object for processing timeouts in a background thread. struct timer_thread_function; friend struct timer_thread_function; // Background thread used for processing timeouts. scoped_ptr<thread> timer_thread_; // A waitable timer object used for waiting for timeouts. auto_handle waitable_timer_; // Non-zero if timers or completed operations need to be dispatched. long dispatch_required_; // Mutex for protecting access to the timer queues and completed operations. mutex dispatch_mutex_; // The timer queues. timer_queue_set timer_queues_; // The operations that are ready to dispatch. op_queue<win_iocp_operation> completed_ops_; // The concurrency hint used to initialise the io_context. const int concurrency_hint_; // The thread that is running the io_context. scoped_ptr<thread> thread_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #include <boost/asio/detail/impl/win_iocp_io_context.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/win_iocp_io_context.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_HAS_IOCP) #endif // BOOST_ASIO_DETAIL_WIN_IOCP_IO_CONTEXT_HPP PK��h!\�M�k��cstdint.hppnu��[��// // detail/cstdint.hpp // ~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_CSTDINT_HPP #define BOOST_ASIO_DETAIL_CSTDINT_HPP #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_HAS_CSTDINT) # include <cstdint> #else // defined(BOOST_ASIO_HAS_CSTDINT) # include <boost/cstdint.hpp> #endif // defined(BOOST_ASIO_HAS_CSTDINT) namespace boost { namespace asio { #if defined(BOOST_ASIO_HAS_CSTDINT) using std::int16_t; using std::int_least16_t; using std::uint16_t; using std::uint_least16_t; using std::int32_t; using std::int_least32_t; using std::uint32_t; using std::uint_least32_t; using std::int64_t; using std::int_least64_t; using std::uint64_t; using std::uint_least64_t; using std::uintmax_t; #else // defined(BOOST_ASIO_HAS_CSTDINT) using boost::int16_t; using boost::int_least16_t; using boost::uint16_t; using boost::uint_least16_t; using boost::int32_t; using boost::int_least32_t; using boost::uint32_t; using boost::uint_least32_t; using boost::int64_t; using boost::int_least64_t; using boost::uint64_t; using boost::uint_least64_t; using boost::uintmax_t; #endif // defined(BOOST_ASIO_HAS_CSTDINT) } // namespace asio } // namespace boost #endif // BOOST_ASIO_DETAIL_CSTDINT_HPP PK��h!\b��yZ��Z��win_fenced_block.hppnu��[��// // detail/win_fenced_block.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_FENCED_BLOCK_HPP #define BOOST_ASIO_DETAIL_WIN_FENCED_BLOCK_HPP #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_WINDOWS) && !defined(UNDER_CE) #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class win_fenced_block : private noncopyable { public: enum half_t { half }; enum full_t { full }; // Constructor for a half fenced block. explicit win_fenced_block(half_t) { } // Constructor for a full fenced block. explicit win_fenced_block(full_t) { #if defined(__BORLANDC__) LONG barrier = 0; ::InterlockedExchange(&barrier, 1); #elif defined(BOOST_ASIO_MSVC) \ && ((BOOST_ASIO_MSVC < 1400) \|\| !defined(MemoryBarrier)) # if defined(_M_IX86) # pragma warning(push) # pragma warning(disable:4793) LONG barrier; __asm { xchg barrier, eax } # pragma warning(pop) # endif // defined(_M_IX86) #else MemoryBarrier(); #endif } // Destructor. ~win_fenced_block() { #if defined(__BORLANDC__) LONG barrier = 0; ::InterlockedExchange(&barrier, 1); #elif defined(BOOST_ASIO_MSVC) \ && ((BOOST_ASIO_MSVC < 1400) \|\| !defined(MemoryBarrier)) # if defined(_M_IX86) # pragma warning(push) # pragma warning(disable:4793) LONG barrier; __asm { xchg barrier, eax } # pragma warning(pop) # endif // defined(_M_IX86) #else MemoryBarrier(); #endif } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS) && !defined(UNDER_CE) #endif // BOOST_ASIO_DETAIL_WIN_FENCED_BLOCK_HPP PK��h!\\|��f�&��&��timer_queue.hppnu��[��// // detail/timer_queue.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_TIMER_QUEUE_HPP #define BOOST_ASIO_DETAIL_TIMER_QUEUE_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <cstddef> #include <vector> #include <boost/asio/detail/cstdint.hpp> #include <boost/asio/detail/date_time_fwd.hpp> #include <boost/asio/detail/limits.hpp> #include <boost/asio/detail/op_queue.hpp> #include <boost/asio/detail/timer_queue_base.hpp> #include <boost/asio/detail/wait_op.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Time_Traits> class timer_queue : public timer_queue_base { public: // The time type. typedef typename Time_Traits::time_type time_type; // The duration type. typedef typename Time_Traits::duration_type duration_type; // Per-timer data. class per_timer_data { public: per_timer_data() : heap_index_((std::numeric_limits<std::size_t>::max)()), next_(0), prev_(0) { } private: friend class timer_queue; // The operations waiting on the timer. op_queue<wait_op> op_queue_; // The index of the timer in the heap. std::size_t heap_index_; // Pointers to adjacent timers in a linked list. per_timer_data* next_; per_timer_data* prev_; }; // Constructor. timer_queue() : timers_(), heap_() { } // Add a new timer to the queue. Returns true if this is the timer that is // earliest in the queue, in which case the reactor's event demultiplexing // function call may need to be interrupted and restarted. bool enqueue_timer(const time_type& time, per_timer_data& timer, wait_op* op) { // Enqueue the timer object. if (timer.prev_ == 0 && &timer != timers_) { if (this->is_positive_infinity(time)) { // No heap entry is required for timers that never expire. timer.heap_index_ = (std::numeric_limits<std::size_t>::max)(); } else { // Put the new timer at the correct position in the heap. This is done // first since push_back() can throw due to allocation failure. timer.heap_index_ = heap_.size(); heap_entry entry = { time, &timer }; heap_.push_back(entry); up_heap(heap_.size() - 1); } // Insert the new timer into the linked list of active timers. timer.next_ = timers_; timer.prev_ = 0; if (timers_) timers_->prev_ = &timer; timers_ = &timer; } // Enqueue the individual timer operation. timer.op_queue_.push(op); // Interrupt reactor only if newly added timer is first to expire. return timer.heap_index_ == 0 && timer.op_queue_.front() == op; } // Whether there are no timers in the queue. virtual bool empty() const { return timers_ == 0; } // Get the time for the timer that is earliest in the queue. virtual long wait_duration_msec(long max_duration) const { if (heap_.empty()) return max_duration; return this->to_msec( Time_Traits::to_posix_duration( Time_Traits::subtract(heap_[0].time_, Time_Traits::now())), max_duration); } // Get the time for the timer that is earliest in the queue. virtual long wait_duration_usec(long max_duration) const { if (heap_.empty()) return max_duration; return this->to_usec( Time_Traits::to_posix_duration( Time_Traits::subtract(heap_[0].time_, Time_Traits::now())), max_duration); } // Dequeue all timers not later than the current time. virtual void get_ready_timers(op_queue<operation>& ops) { if (!heap_.empty()) { const time_type now = Time_Traits::now(); while (!heap_.empty() && !Time_Traits::less_than(now, heap_[0].time_)) { per_timer_data* timer = heap_[0].timer_; ops.push(timer->op_queue_); remove_timer(timer); } } } // Dequeue all timers. virtual void get_all_timers(op_queue<operation>& ops) { while (timers_) { per_timer_data timer = timers_; timers_ = timers_->next_; ops.push(timer->op_queue_); timer->next_ = 0; timer->prev_ = 0; } heap_.clear(); } // Cancel and dequeue operations for the given timer. std::size_t cancel_timer(per_timer_data& timer, op_queue<operation>& ops, std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)()) { std::size_t num_cancelled = 0; if (timer.prev_ != 0 \|\| &timer == timers_) { while (wait_op* op = (num_cancelled != max_cancelled) ? timer.op_queue_.front() : 0) { op->ec_ = boost::asio::error::operation_aborted; timer.op_queue_.pop(); ops.push(op); ++num_cancelled; } if (timer.op_queue_.empty()) remove_timer(timer); } return num_cancelled; } // Move operations from one timer to another, empty timer. void move_timer(per_timer_data& target, per_timer_data& source) { target.op_queue_.push(source.op_queue_); target.heap_index_ = source.heap_index_; source.heap_index_ = (std::numeric_limits<std::size_t>::max)(); if (target.heap_index_ < heap_.size()) heap_[target.heap_index_].timer_ = &target; if (timers_ == &source) timers_ = &target; if (source.prev_) source.prev_->next_ = &target; if (source.next_) source.next_->prev_= &target; target.next_ = source.next_; target.prev_ = source.prev_; source.next_ = 0; source.prev_ = 0; } private: // Move the item at the given index up the heap to its correct position. void up_heap(std::size_t index) { while (index > 0) { std::size_t parent = (index - 1) / 2; if (!Time_Traits::less_than(heap_[index].time_, heap_[parent].time_)) break; swap_heap(index, parent); index = parent; } } // Move the item at the given index down the heap to its correct position. void down_heap(std::size_t index) { std::size_t child = index * 2 + 1; while (child < heap_.size()) { std::size_t min_child = (child + 1 == heap_.size() \|\| Time_Traits::less_than( heap_[child].time_, heap_[child + 1].time_)) ? child : child + 1; if (Time_Traits::less_than(heap_[index].time_, heap_[min_child].time_)) break; swap_heap(index, min_child); index = min_child; child = index * 2 + 1; } } // Swap two entries in the heap. void swap_heap(std::size_t index1, std::size_t index2) { heap_entry tmp = heap_[index1]; heap_[index1] = heap_[index2]; heap_[index2] = tmp; heap_[index1].timer_->heap_index_ = index1; heap_[index2].timer_->heap_index_ = index2; } // Remove a timer from the heap and list of timers. void remove_timer(per_timer_data& timer) { // Remove the timer from the heap. std::size_t index = timer.heap_index_; if (!heap_.empty() && index < heap_.size()) { if (index == heap_.size() - 1) { timer.heap_index_ = (std::numeric_limits<std::size_t>::max)(); heap_.pop_back(); } else { swap_heap(index, heap_.size() - 1); timer.heap_index_ = (std::numeric_limits<std::size_t>::max)(); heap_.pop_back(); if (index > 0 && Time_Traits::less_than( heap_[index].time_, heap_[(index - 1) / 2].time_)) up_heap(index); else down_heap(index); } } // Remove the timer from the linked list of active timers. if (timers_ == &timer) timers_ = timer.next_; if (timer.prev_) timer.prev_->next_ = timer.next_; if (timer.next_) timer.next_->prev_= timer.prev_; timer.next_ = 0; timer.prev_ = 0; } // Determine if the specified absolute time is positive infinity. template <typename Time_Type> static bool is_positive_infinity(const Time_Type&) { return false; } // Determine if the specified absolute time is positive infinity. template <typename T, typename TimeSystem> static bool is_positive_infinity( const boost::date_time::base_time<T, TimeSystem>& time) { return time.is_pos_infinity(); } // Helper function to convert a duration into milliseconds. template <typename Duration> long to_msec(const Duration& d, long max_duration) const { if (d.ticks() <= 0) return 0; int64_t msec = d.total_milliseconds(); if (msec == 0) return 1; if (msec > max_duration) return max_duration; return static_cast<long>(msec); } // Helper function to convert a duration into microseconds. template <typename Duration> long to_usec(const Duration& d, long max_duration) const { if (d.ticks() <= 0) return 0; int64_t usec = d.total_microseconds(); if (usec == 0) return 1; if (usec > max_duration) return max_duration; return static_cast<long>(usec); } // The head of a linked list of all active timers. per_timer_data* timers_; struct heap_entry { // The time when the timer should fire. time_type time_; // The associated timer with enqueued operations. per_timer_data* timer_; }; // The heap of timers, with the earliest timer at the front. std::vector<heap_entry> heap_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_TIMER_QUEUE_HPP PK��h!\� ��concurrency_hint.hppnu��[��// // detail/concurrency_hint.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_CONCURRENCY_HINT_HPP #define BOOST_ASIO_DETAIL_CONCURRENCY_HINT_HPP #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/detail/noncopyable.hpp> // The concurrency hint ID and mask are used to identify when a "well-known" // concurrency hint value has been passed to the io_context. #define BOOST_ASIO_CONCURRENCY_HINT_ID 0xA5100000u #define BOOST_ASIO_CONCURRENCY_HINT_ID_MASK 0xFFFF0000u // If set, this bit indicates that the scheduler should perform locking. #define BOOST_ASIO_CONCURRENCY_HINT_LOCKING_SCHEDULER 0x1u // If set, this bit indicates that the reactor should perform locking when // managing descriptor registrations. #define BOOST_ASIO_CONCURRENCY_HINT_LOCKING_REACTOR_REGISTRATION 0x2u // If set, this bit indicates that the reactor should perform locking for I/O. #define BOOST_ASIO_CONCURRENCY_HINT_LOCKING_REACTOR_IO 0x4u // Helper macro to determine if we have a special concurrency hint. #define BOOST_ASIO_CONCURRENCY_HINT_IS_SPECIAL(hint) \ ((static_cast<unsigned>(hint) \ & BOOST_ASIO_CONCURRENCY_HINT_ID_MASK) \ == BOOST_ASIO_CONCURRENCY_HINT_ID) // Helper macro to determine if locking is enabled for a given facility. #define BOOST_ASIO_CONCURRENCY_HINT_IS_LOCKING(facility, hint) \ (((static_cast<unsigned>(hint) \ & (BOOST_ASIO_CONCURRENCY_HINT_ID_MASK \ \| BOOST_ASIO_CONCURRENCY_HINT_LOCKING_ ## facility)) \ ^ BOOST_ASIO_CONCURRENCY_HINT_ID) != 0) // This special concurrency hint disables locking in both the scheduler and // reactor I/O. This hint has the following restrictions: // // - Care must be taken to ensure that all operations on the io_context and any // of its associated I/O objects (such as sockets and timers) occur in only // one thread at a time. // // - Asynchronous resolve operations fail with operation_not_supported. // // - If a signal_set is used with the io_context, signal_set objects cannot be // used with any other io_context in the program. #define BOOST_ASIO_CONCURRENCY_HINT_UNSAFE \ static_cast<int>(BOOST_ASIO_CONCURRENCY_HINT_ID) // This special concurrency hint disables locking in the reactor I/O. This hint // has the following restrictions: // // - Care must be taken to ensure that run functions on the io_context, and all // operations on the io_context's associated I/O objects (such as sockets and // timers), occur in only one thread at a time. #define BOOST_ASIO_CONCURRENCY_HINT_UNSAFE_IO \ static_cast<int>(BOOST_ASIO_CONCURRENCY_HINT_ID \ \| BOOST_ASIO_CONCURRENCY_HINT_LOCKING_SCHEDULER \ \| BOOST_ASIO_CONCURRENCY_HINT_LOCKING_REACTOR_REGISTRATION) // The special concurrency hint provides full thread safety. #define BOOST_ASIO_CONCURRENCY_HINT_SAFE \ static_cast<int>(BOOST_ASIO_CONCURRENCY_HINT_ID \ \| BOOST_ASIO_CONCURRENCY_HINT_LOCKING_SCHEDULER \ \| BOOST_ASIO_CONCURRENCY_HINT_LOCKING_REACTOR_REGISTRATION \ \| BOOST_ASIO_CONCURRENCY_HINT_LOCKING_REACTOR_IO) // This #define may be overridden at compile time to specify a program-wide // default concurrency hint, used by the zero-argument io_context constructor. #if !defined(BOOST_ASIO_CONCURRENCY_HINT_DEFAULT) # define BOOST_ASIO_CONCURRENCY_HINT_DEFAULT -1 #endif // !defined(BOOST_ASIO_CONCURRENCY_HINT_DEFAULT) // This #define may be overridden at compile time to specify a program-wide // concurrency hint, used by the one-argument io_context constructor when // passed a value of 1. #if !defined(BOOST_ASIO_CONCURRENCY_HINT_1) # define BOOST_ASIO_CONCURRENCY_HINT_1 1 #endif // !defined(BOOST_ASIO_CONCURRENCY_HINT_DEFAULT) #endif // BOOST_ASIO_DETAIL_CONCURRENCY_HINT_HPP PK��h!\7�8�, ��, ��handler_alloc_helpers.hppnu��[��// // detail/handler_alloc_helpers.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_HANDLER_ALLOC_HELPERS_HPP #define BOOST_ASIO_DETAIL_HANDLER_ALLOC_HELPERS_HPP #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/detail/memory.hpp> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/recycling_allocator.hpp> #include <boost/asio/detail/thread_info_base.hpp> #include <boost/asio/associated_allocator.hpp> #include <boost/asio/handler_alloc_hook.hpp> #include <boost/asio/detail/push_options.hpp> // Calls to asio_handler_allocate and asio_handler_deallocate must be made from // a namespace that does not contain any overloads of these functions. The // boost_asio_handler_alloc_helpers namespace is defined here for that purpose. namespace boost_asio_handler_alloc_helpers { #if defined(BOOST_ASIO_NO_DEPRECATED) template <typename Handler> inline void error_if_hooks_are_defined(Handler& h) { using boost::asio::asio_handler_allocate; // If you get an error here it is because some of your handlers still // overload asio_handler_allocate, but this hook is no longer used. (void)static_cast<boost::asio::asio_handler_allocate_is_no_longer_used>( asio_handler_allocate(static_cast<std::size_t>(0), boost::asio::detail::addressof(h))); using boost::asio::asio_handler_deallocate; // If you get an error here it is because some of your handlers still // overload asio_handler_deallocate, but this hook is no longer used. (void)static_cast<boost::asio::asio_handler_deallocate_is_no_longer_used>( asio_handler_deallocate(static_cast<void>(0), static_cast<std::size_t>(0), boost::asio::detail::addressof(h))); } #endif // defined(BOOST_ASIO_NO_DEPRECATED) template <typename Handler> inline void allocate(std::size_t s, Handler& h) { #if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS) return ::operator new(s); #elif defined(BOOST_ASIO_NO_DEPRECATED) // The asio_handler_allocate hook is no longer used to obtain memory. (void)&error_if_hooks_are_defined<Handler>; (void)h; #if !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING) return boost::asio::detail::thread_info_base::allocate( boost::asio::detail::thread_context::thread_call_stack::top(), s); #else // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING) return ::operator new(size); #endif // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING) #else using boost::asio::asio_handler_allocate; return asio_handler_allocate(s, boost::asio::detail::addressof(h)); #endif } template <typename Handler> inline void deallocate(void* p, std::size_t s, Handler& h) { #if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS) ::operator delete(p); #elif defined(BOOST_ASIO_NO_DEPRECATED) // The asio_handler_allocate hook is no longer used to obtain memory. (void)&error_if_hooks_are_defined<Handler>; (void)h; #if !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING) boost::asio::detail::thread_info_base::deallocate( boost::asio::detail::thread_context::thread_call_stack::top(), p, s); #else // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING) (void)s; ::operator delete(p); #endif // !defined(BOOST_ASIO_DISABLE_SMALL_BLOCK_RECYCLING) #else using boost::asio::asio_handler_deallocate; asio_handler_deallocate(p, s, boost::asio::detail::addressof(h)); #endif } } // namespace boost_asio_handler_alloc_helpers namespace boost { namespace asio { namespace detail { template <typename Handler, typename T> class hook_allocator { public: typedef T value_type; template <typename U> struct rebind { typedef hook_allocator<Handler, U> other; }; explicit hook_allocator(Handler& h) : handler_(h) { } template <typename U> hook_allocator(const hook_allocator<Handler, U>& a) : handler_(a.handler_) { } T* allocate(std::size_t n) { return static_cast<T>( boost_asio_handler_alloc_helpers::allocate(sizeof(T) n, handler_)); } void deallocate(T* p, std::size_t n) { boost_asio_handler_alloc_helpers::deallocate(p, sizeof(T) * n, handler_); } //private: Handler& handler_; }; template <typename Handler> class hook_allocator<Handler, void> { public: typedef void value_type; template <typename U> struct rebind { typedef hook_allocator<Handler, U> other; }; explicit hook_allocator(Handler& h) : handler_(h) { } template <typename U> hook_allocator(const hook_allocator<Handler, U>& a) : handler_(a.handler_) { } //private: Handler& handler_; }; template <typename Handler, typename Allocator> struct get_hook_allocator { typedef Allocator type; static type get(Handler&, const Allocator& a) { return a; } }; template <typename Handler, typename T> struct get_hook_allocator<Handler, std::allocator<T> > { typedef hook_allocator<Handler, T> type; static type get(Handler& handler, const std::allocator<T>&) { return type(handler); } }; } // namespace detail } // namespace asio } // namespace boost #define BOOST_ASIO_DEFINE_HANDLER_PTR(op) \ struct ptr \ { \ Handler* h; \ op* v; \ op* p; \ ~ptr() \ { \ reset(); \ } \ static op* allocate(Handler& handler) \ { \ typedef typename ::boost::asio::associated_allocator< \ Handler>::type associated_allocator_type; \ typedef typename ::boost::asio::detail::get_hook_allocator< \ Handler, associated_allocator_type>::type hook_allocator_type; \ BOOST_ASIO_REBIND_ALLOC(hook_allocator_type, op) a( \ ::boost::asio::detail::get_hook_allocator< \ Handler, associated_allocator_type>::get( \ handler, ::boost::asio::get_associated_allocator(handler))); \ return a.allocate(1); \ } \ void reset() \ { \ if (p) \ { \ p->~op(); \ p = 0; \ } \ if (v) \ { \ typedef typename ::boost::asio::associated_allocator< \ Handler>::type associated_allocator_type; \ typedef typename ::boost::asio::detail::get_hook_allocator< \ Handler, associated_allocator_type>::type hook_allocator_type; \ BOOST_ASIO_REBIND_ALLOC(hook_allocator_type, op) a( \ ::boost::asio::detail::get_hook_allocator< \ Handler, associated_allocator_type>::get( \ h, ::boost::asio::get_associated_allocator(h))); \ a.deallocate(static_cast<op>(v), 1); \ v = 0; \ } \ } \ } \ // #define BOOST_ASIO_DEFINE_TAGGED_HANDLER_ALLOCATOR_PTR(purpose, op) \ struct ptr \ { \ const Alloc a; \ void* v; \ op* p; \ ~ptr() \ { \ reset(); \ } \ static op* allocate(const Alloc& a) \ { \ typedef typename ::boost::asio::detail::get_recycling_allocator< \ Alloc, purpose>::type recycling_allocator_type; \ BOOST_ASIO_REBIND_ALLOC(recycling_allocator_type, op) a1( \ ::boost::asio::detail::get_recycling_allocator< \ Alloc, purpose>::get(a)); \ return a1.allocate(1); \ } \ void reset() \ { \ if (p) \ { \ p->~op(); \ p = 0; \ } \ if (v) \ { \ typedef typename ::boost::asio::detail::get_recycling_allocator< \ Alloc, purpose>::type recycling_allocator_type; \ BOOST_ASIO_REBIND_ALLOC(recycling_allocator_type, op) a1( \ ::boost::asio::detail::get_recycling_allocator< \ Alloc, purpose>::get(a)); \ a1.deallocate(static_cast<op>(v), 1); \ v = 0; \ } \ } \ } \ // #define BOOST_ASIO_DEFINE_HANDLER_ALLOCATOR_PTR(op) \ BOOST_ASIO_DEFINE_TAGGED_HANDLER_ALLOCATOR_PTR( \ ::boost::asio::detail::thread_info_base::default_tag, op ) \ // #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_HANDLER_ALLOC_HELPERS_HPP PK��h!\8� �� handler_invoke_helpers.hppnu��[��// // detail/handler_invoke_helpers.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_HANDLER_INVOKE_HELPERS_HPP #define BOOST_ASIO_DETAIL_HANDLER_INVOKE_HELPERS_HPP #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/detail/memory.hpp> #include <boost/asio/handler_invoke_hook.hpp> #include <boost/asio/detail/push_options.hpp> // Calls to asio_handler_invoke must be made from a namespace that does not // contain overloads of this function. The boost_asio_handler_invoke_helpers // namespace is defined here for that purpose. namespace boost_asio_handler_invoke_helpers { #if defined(BOOST_ASIO_NO_DEPRECATED) template <typename Function, typename Context> inline void error_if_hook_is_defined(Function& function, Context& context) { using boost::asio::asio_handler_invoke; // If you get an error here it is because some of your handlers still // overload asio_handler_invoke, but this hook is no longer used. (void)static_cast<boost::asio::asio_handler_invoke_is_no_longer_used>( asio_handler_invoke(function, boost::asio::detail::addressof(context))); } #endif // defined(BOOST_ASIO_NO_DEPRECATED) template <typename Function, typename Context> inline void invoke(Function& function, Context& context) { #if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS) Function tmp(function); tmp(); #elif defined(BOOST_ASIO_NO_DEPRECATED) // The asio_handler_invoke hook is no longer used to invoke the function. (void)&error_if_hook_is_defined<Function, Context>; (void)context; function(); #else using boost::asio::asio_handler_invoke; asio_handler_invoke(function, boost::asio::detail::addressof(context)); #endif } template <typename Function, typename Context> inline void invoke(const Function& function, Context& context) { #if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS) Function tmp(function); tmp(); #elif defined(BOOST_ASIO_NO_DEPRECATED) // The asio_handler_invoke hook is no longer used to invoke the function. (void)&error_if_hook_is_defined<const Function, Context>; (void)context; Function tmp(function); tmp(); #else using boost::asio::asio_handler_invoke; asio_handler_invoke(function, boost::asio::detail::addressof(context)); #endif } } // namespace boost_asio_handler_invoke_helpers #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_HANDLER_INVOKE_HELPERS_HPP PK��h!\R��H��H��reactive_socket_service.hppnu��[��// // detail/reactive_socket_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_REACTIVE_SOCKET_SERVICE_HPP #define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_HPP #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_HAS_IOCP) #include <boost/asio/buffer.hpp> #include <boost/asio/error.hpp> #include <boost/asio/execution_context.hpp> #include <boost/asio/socket_base.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/reactive_null_buffers_op.hpp> #include <boost/asio/detail/reactive_socket_accept_op.hpp> #include <boost/asio/detail/reactive_socket_connect_op.hpp> #include <boost/asio/detail/reactive_socket_recvfrom_op.hpp> #include <boost/asio/detail/reactive_socket_sendto_op.hpp> #include <boost/asio/detail/reactive_socket_service_base.hpp> #include <boost/asio/detail/reactor.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/socket_holder.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Protocol> class reactive_socket_service : public execution_context_service_base<reactive_socket_service<Protocol> >, public reactive_socket_service_base { public: // The protocol type. typedef Protocol protocol_type; // The endpoint type. typedef typename Protocol::endpoint endpoint_type; // The native type of a socket. typedef socket_type native_handle_type; // The implementation type of the socket. struct implementation_type : reactive_socket_service_base::base_implementation_type { // Default constructor. implementation_type() : protocol_(endpoint_type().protocol()) { } // The protocol associated with the socket. protocol_type protocol_; }; // Constructor. reactive_socket_service(execution_context& context) : execution_context_service_base< reactive_socket_service<Protocol> >(context), reactive_socket_service_base(context) { } // Destroy all user-defined handler objects owned by the service. void shutdown() { this->base_shutdown(); } // Move-construct a new socket implementation. void move_construct(implementation_type& impl, implementation_type& other_impl) BOOST_ASIO_NOEXCEPT { this->base_move_construct(impl, other_impl); impl.protocol_ = other_impl.protocol_; other_impl.protocol_ = endpoint_type().protocol(); } // Move-assign from another socket implementation. void move_assign(implementation_type& impl, reactive_socket_service_base& other_service, implementation_type& other_impl) { this->base_move_assign(impl, other_service, other_impl); impl.protocol_ = other_impl.protocol_; other_impl.protocol_ = endpoint_type().protocol(); } // Move-construct a new socket implementation from another protocol type. template <typename Protocol1> void converting_move_construct(implementation_type& impl, reactive_socket_service<Protocol1>&, typename reactive_socket_service< Protocol1>::implementation_type& other_impl) { this->base_move_construct(impl, other_impl); impl.protocol_ = protocol_type(other_impl.protocol_); other_impl.protocol_ = typename Protocol1::endpoint().protocol(); } // Open a new socket implementation. boost::system::error_code open(implementation_type& impl, const protocol_type& protocol, boost::system::error_code& ec) { if (!do_open(impl, protocol.family(), protocol.type(), protocol.protocol(), ec)) impl.protocol_ = protocol; return ec; } // Assign a native socket to a socket implementation. boost::system::error_code assign(implementation_type& impl, const protocol_type& protocol, const native_handle_type& native_socket, boost::system::error_code& ec) { if (!do_assign(impl, protocol.type(), native_socket, ec)) impl.protocol_ = protocol; return ec; } // Get the native socket representation. native_handle_type native_handle(implementation_type& impl) { return impl.socket_; } // Bind the socket to the specified local endpoint. boost::system::error_code bind(implementation_type& impl, const endpoint_type& endpoint, boost::system::error_code& ec) { socket_ops::bind(impl.socket_, endpoint.data(), endpoint.size(), ec); return ec; } // Set a socket option. template <typename Option> boost::system::error_code set_option(implementation_type& impl, const Option& option, boost::system::error_code& ec) { socket_ops::setsockopt(impl.socket_, impl.state_, option.level(impl.protocol_), option.name(impl.protocol_), option.data(impl.protocol_), option.size(impl.protocol_), ec); return ec; } // Set a socket option. template <typename Option> boost::system::error_code get_option(const implementation_type& impl, Option& option, boost::system::error_code& ec) const { std::size_t size = option.size(impl.protocol_); socket_ops::getsockopt(impl.socket_, impl.state_, option.level(impl.protocol_), option.name(impl.protocol_), option.data(impl.protocol_), &size, ec); if (!ec) option.resize(impl.protocol_, size); return ec; } // Get the local endpoint. endpoint_type local_endpoint(const implementation_type& impl, boost::system::error_code& ec) const { endpoint_type endpoint; std::size_t addr_len = endpoint.capacity(); if (socket_ops::getsockname(impl.socket_, endpoint.data(), &addr_len, ec)) return endpoint_type(); endpoint.resize(addr_len); return endpoint; } // Get the remote endpoint. endpoint_type remote_endpoint(const implementation_type& impl, boost::system::error_code& ec) const { endpoint_type endpoint; std::size_t addr_len = endpoint.capacity(); if (socket_ops::getpeername(impl.socket_, endpoint.data(), &addr_len, false, ec)) return endpoint_type(); endpoint.resize(addr_len); return endpoint; } // Disable sends or receives on the socket. boost::system::error_code shutdown(base_implementation_type& impl, socket_base::shutdown_type what, boost::system::error_code& ec) { socket_ops::shutdown(impl.socket_, what, ec); return ec; } // Send a datagram to the specified endpoint. Returns the number of bytes // sent. template <typename ConstBufferSequence> size_t send_to(implementation_type& impl, const ConstBufferSequence& buffers, const endpoint_type& destination, socket_base::message_flags flags, boost::system::error_code& ec) { typedef buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence> bufs_type; if (bufs_type::is_single_buffer) { return socket_ops::sync_sendto1(impl.socket_, impl.state_, bufs_type::first(buffers).data(), bufs_type::first(buffers).size(), flags, destination.data(), destination.size(), ec); } else { bufs_type bufs(buffers); return socket_ops::sync_sendto(impl.socket_, impl.state_, bufs.buffers(), bufs.count(), flags, destination.data(), destination.size(), ec); } } // Wait until data can be sent without blocking. size_t send_to(implementation_type& impl, const null_buffers&, const endpoint_type&, socket_base::message_flags, boost::system::error_code& ec) { // Wait for socket to become ready. socket_ops::poll_write(impl.socket_, impl.state_, -1, ec); return 0; } // Start an asynchronous send. The data being sent must be valid for the // lifetime of the asynchronous operation. template <typename ConstBufferSequence, typename Handler, typename IoExecutor> void async_send_to(implementation_type& impl, const ConstBufferSequence& buffers, const endpoint_type& destination, socket_base::message_flags flags, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef reactive_socket_sendto_op<ConstBufferSequence, endpoint_type, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(success_ec_, impl.socket_, buffers, destination, flags, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((reactor_.context(), p.p, "socket", &impl, impl.socket_, "async_send_to")); start_op(impl, reactor::write_op, p.p, is_continuation, true, false); p.v = p.p = 0; } // Start an asynchronous wait until data can be sent without blocking. template <typename Handler, typename IoExecutor> void async_send_to(implementation_type& impl, const null_buffers&, const endpoint_type&, socket_base::message_flags, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef reactive_null_buffers_op<Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(success_ec_, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((reactor_.context(), p.p, "socket", &impl, impl.socket_, "async_send_to(null_buffers)")); start_op(impl, reactor::write_op, p.p, is_continuation, false, false); p.v = p.p = 0; } // Receive a datagram with the endpoint of the sender. Returns the number of // bytes received. template <typename MutableBufferSequence> size_t receive_from(implementation_type& impl, const MutableBufferSequence& buffers, endpoint_type& sender_endpoint, socket_base::message_flags flags, boost::system::error_code& ec) { typedef buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence> bufs_type; std::size_t addr_len = sender_endpoint.capacity(); std::size_t bytes_recvd; if (bufs_type::is_single_buffer) { bytes_recvd = socket_ops::sync_recvfrom1(impl.socket_, impl.state_, bufs_type::first(buffers).data(), bufs_type::first(buffers).size(), flags, sender_endpoint.data(), &addr_len, ec); } else { bufs_type bufs(buffers); bytes_recvd = socket_ops::sync_recvfrom( impl.socket_, impl.state_, bufs.buffers(), bufs.count(), flags, sender_endpoint.data(), &addr_len, ec); } if (!ec) sender_endpoint.resize(addr_len); return bytes_recvd; } // Wait until data can be received without blocking. size_t receive_from(implementation_type& impl, const null_buffers&, endpoint_type& sender_endpoint, socket_base::message_flags, boost::system::error_code& ec) { // Wait for socket to become ready. socket_ops::poll_read(impl.socket_, impl.state_, -1, ec); // Reset endpoint since it can be given no sensible value at this time. sender_endpoint = endpoint_type(); return 0; } // Start an asynchronous receive. The buffer for the data being received and // the sender_endpoint object must both be valid for the lifetime of the // asynchronous operation. template <typename MutableBufferSequence, typename Handler, typename IoExecutor> void async_receive_from(implementation_type& impl, const MutableBufferSequence& buffers, endpoint_type& sender_endpoint, socket_base::message_flags flags, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef reactive_socket_recvfrom_op<MutableBufferSequence, endpoint_type, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; int protocol = impl.protocol_.type(); p.p = new (p.v) op(success_ec_, impl.socket_, protocol, buffers, sender_endpoint, flags, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((reactor_.context(), p.p, "socket", &impl, impl.socket_, "async_receive_from")); start_op(impl, (flags & socket_base::message_out_of_band) ? reactor::except_op : reactor::read_op, p.p, is_continuation, true, false); p.v = p.p = 0; } // Wait until data can be received without blocking. template <typename Handler, typename IoExecutor> void async_receive_from(implementation_type& impl, const null_buffers&, endpoint_type& sender_endpoint, socket_base::message_flags flags, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef reactive_null_buffers_op<Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(success_ec_, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((reactor_.context(), p.p, "socket", &impl, impl.socket_, "async_receive_from(null_buffers)")); // Reset endpoint since it can be given no sensible value at this time. sender_endpoint = endpoint_type(); start_op(impl, (flags & socket_base::message_out_of_band) ? reactor::except_op : reactor::read_op, p.p, is_continuation, false, false); p.v = p.p = 0; } // Accept a new connection. template <typename Socket> boost::system::error_code accept(implementation_type& impl, Socket& peer, endpoint_type* peer_endpoint, boost::system::error_code& ec) { // We cannot accept a socket that is already open. if (peer.is_open()) { ec = boost::asio::error::already_open; return ec; } std::size_t addr_len = peer_endpoint ? peer_endpoint->capacity() : 0; socket_holder new_socket(socket_ops::sync_accept(impl.socket_, impl.state_, peer_endpoint ? peer_endpoint->data() : 0, peer_endpoint ? &addr_len : 0, ec)); // On success, assign new connection to peer socket object. if (new_socket.get() != invalid_socket) { if (peer_endpoint) peer_endpoint->resize(addr_len); peer.assign(impl.protocol_, new_socket.get(), ec); if (!ec) new_socket.release(); } return ec; } // Start an asynchronous accept. The peer and peer_endpoint objects must be // valid until the accept's handler is invoked. template <typename Socket, typename Handler, typename IoExecutor> void async_accept(implementation_type& impl, Socket& peer, endpoint_type* peer_endpoint, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef reactive_socket_accept_op<Socket, Protocol, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(success_ec_, impl.socket_, impl.state_, peer, impl.protocol_, peer_endpoint, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((reactor_.context(), p.p, "socket", &impl, impl.socket_, "async_accept")); start_accept_op(impl, p.p, is_continuation, peer.is_open()); p.v = p.p = 0; } #if defined(BOOST_ASIO_HAS_MOVE) // Start an asynchronous accept. The peer_endpoint object must be valid until // the accept's handler is invoked. template <typename PeerIoExecutor, typename Handler, typename IoExecutor> void async_move_accept(implementation_type& impl, const PeerIoExecutor& peer_io_ex, endpoint_type peer_endpoint, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef reactive_socket_move_accept_op<Protocol, PeerIoExecutor, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(success_ec_, peer_io_ex, impl.socket_, impl.state_, impl.protocol_, peer_endpoint, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((reactor_.context(), p.p, "socket", &impl, impl.socket_, "async_accept")); start_accept_op(impl, p.p, is_continuation, false); p.v = p.p = 0; } #endif // defined(BOOST_ASIO_HAS_MOVE) // Connect the socket to the specified endpoint. boost::system::error_code connect(implementation_type& impl, const endpoint_type& peer_endpoint, boost::system::error_code& ec) { socket_ops::sync_connect(impl.socket_, peer_endpoint.data(), peer_endpoint.size(), ec); return ec; } // Start an asynchronous connect. template <typename Handler, typename IoExecutor> void async_connect(implementation_type& impl, const endpoint_type& peer_endpoint, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef reactive_socket_connect_op<Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(success_ec_, impl.socket_, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((reactor_.context(), p.p, "socket", &impl, impl.socket_, "async_connect")); start_connect_op(impl, p.p, is_continuation, peer_endpoint.data(), peer_endpoint.size()); p.v = p.p = 0; } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // !defined(BOOST_ASIO_HAS_IOCP) #endif // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SERVICE_HPP PK��h!\�S��reactor_fwd.hppnu��[��// // detail/reactor_fwd.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_REACTOR_FWD_HPP #define BOOST_ASIO_DETAIL_REACTOR_FWD_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> namespace boost { namespace asio { namespace detail { #if defined(BOOST_ASIO_HAS_IOCP) \|\| defined(BOOST_ASIO_WINDOWS_RUNTIME) typedef class null_reactor reactor; #elif defined(BOOST_ASIO_HAS_IOCP) typedef class select_reactor reactor; #elif defined(BOOST_ASIO_HAS_EPOLL) typedef class epoll_reactor reactor; #elif defined(BOOST_ASIO_HAS_KQUEUE) typedef class kqueue_reactor reactor; #elif defined(BOOST_ASIO_HAS_DEV_POLL) typedef class dev_poll_reactor reactor; #else typedef class select_reactor reactor; #endif } // namespace detail } // namespace asio } // namespace boost #endif // BOOST_ASIO_DETAIL_REACTOR_FWD_HPP PK��h!\�\|�&��&��thread_group.hppnu��[��// // detail/thread_group.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_THREAD_GROUP_HPP #define BOOST_ASIO_DETAIL_THREAD_GROUP_HPP #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/detail/scoped_ptr.hpp> #include <boost/asio/detail/thread.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class thread_group { public: // Constructor initialises an empty thread group. thread_group() : first_(0) { } // Destructor joins any remaining threads in the group. ~thread_group() { join(); } // Create a new thread in the group. template <typename Function> void create_thread(Function f) { first_ = new item(f, first_); } // Create new threads in the group. template <typename Function> void create_threads(Function f, std::size_t num_threads) { for (std::size_t i = 0; i < num_threads; ++i) create_thread(f); } // Wait for all threads in the group to exit. void join() { while (first_) { first_->thread_.join(); item* tmp = first_; first_ = first_->next_; delete tmp; } } // Test whether the group is empty. bool empty() const { return first_ == 0; } private: // Structure used to track a single thread in the group. struct item { template <typename Function> explicit item(Function f, item* next) : thread_(f), next_(next) { } boost::asio::detail::thread thread_; item* next_; }; // The first thread in the group. item* first_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_THREAD_GROUP_HPP PK��h!\�2�� array.hppnu��[��// // detail/array.hpp // ~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_ARRAY_HPP #define BOOST_ASIO_DETAIL_ARRAY_HPP #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_HAS_STD_ARRAY) # include <array> #else // defined(BOOST_ASIO_HAS_STD_ARRAY) # include <boost/array.hpp> #endif // defined(BOOST_ASIO_HAS_STD_ARRAY) namespace boost { namespace asio { namespace detail { #if defined(BOOST_ASIO_HAS_STD_ARRAY) using std::array; #else // defined(BOOST_ASIO_HAS_STD_ARRAY) using boost::array; #endif // defined(BOOST_ASIO_HAS_STD_ARRAY) } // namespace detail } // namespace asio } // namespace boost #endif // BOOST_ASIO_DETAIL_ARRAY_HPP PK��h!\�L���win_iocp_wait_op.hppnu��[��// // detail/win_iocp_wait_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_IOCP_WAIT_OP_HPP #define BOOST_ASIO_DETAIL_WIN_IOCP_WAIT_OP_HPP #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_HAS_IOCP) #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Handler, typename IoExecutor> class win_iocp_wait_op : public reactor_op { public: BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_wait_op); win_iocp_wait_op(socket_ops::weak_cancel_token_type cancel_token, Handler& handler, const IoExecutor& io_ex) : reactor_op(boost::system::error_code(), &win_iocp_wait_op::do_perform, &win_iocp_wait_op::do_complete), cancel_token_(cancel_token), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static status do_perform(reactor_op) { return done; } static void do_complete(void* owner, operation* base, const boost::system::error_code& result_ec, std::size_t /bytes_transferred/) { boost::system::error_code ec(result_ec); // Take ownership of the operation object. win_iocp_wait_op* o(static_cast<win_iocp_wait_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); // The reactor may have stored a result in the operation object. if (o->ec_) ec = o->ec_; // Map non-portable errors to their portable counterparts. if (ec.value() == ERROR_NETNAME_DELETED) { if (o->cancel_token_.expired()) ec = boost::asio::error::operation_aborted; else ec = boost::asio::error::connection_reset; } else if (ec.value() == ERROR_PORT_UNREACHABLE) { ec = boost::asio::error::connection_refused; } // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder1<Handler, boost::system::error_code> handler(o->handler_, ec); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: socket_ops::weak_cancel_token_type cancel_token_; Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #endif // BOOST_ASIO_DETAIL_WIN_IOCP_WAIT_OP_HPP PK��h!\�γ�d2��d2��win_iocp_handle_service.hppnu��[��// // detail/win_iocp_handle_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.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_DETAIL_WIN_IOCP_HANDLE_SERVICE_HPP #define BOOST_ASIO_DETAIL_WIN_IOCP_HANDLE_SERVICE_HPP #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_HAS_IOCP) #include <boost/asio/error.hpp> #include <boost/asio/execution_context.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/cstdint.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/mutex.hpp> #include <boost/asio/detail/operation.hpp> #include <boost/asio/detail/win_iocp_handle_read_op.hpp> #include <boost/asio/detail/win_iocp_handle_write_op.hpp> #include <boost/asio/detail/win_iocp_io_context.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class win_iocp_handle_service : public execution_context_service_base<win_iocp_handle_service> { public: // The native type of a stream handle. typedef HANDLE native_handle_type; // The implementation type of the stream handle. class implementation_type { public: // Default constructor. implementation_type() : handle_(INVALID_HANDLE_VALUE), safe_cancellation_thread_id_(0), next_(0), prev_(0) { } private: // Only this service will have access to the internal values. friend class win_iocp_handle_service; // The native stream handle representation. native_handle_type handle_; // The ID of the thread from which it is safe to cancel asynchronous // operations. 0 means no asynchronous operations have been started yet. // ~0 means asynchronous operations have been started from more than one // thread, and cancellation is not supported for the handle. DWORD safe_cancellation_thread_id_; // Pointers to adjacent handle implementations in linked list. implementation_type* next_; implementation_type* prev_; }; BOOST_ASIO_DECL win_iocp_handle_service(execution_context& context); // Destroy all user-defined handler objects owned by the service. BOOST_ASIO_DECL void shutdown(); // Construct a new handle implementation. BOOST_ASIO_DECL void construct(implementation_type& impl); // Move-construct a new handle implementation. BOOST_ASIO_DECL void move_construct(implementation_type& impl, implementation_type& other_impl); // Move-assign from another handle implementation. BOOST_ASIO_DECL void move_assign(implementation_type& impl, win_iocp_handle_service& other_service, implementation_type& other_impl); // Destroy a handle implementation. BOOST_ASIO_DECL void destroy(implementation_type& impl); // Assign a native handle to a handle implementation. BOOST_ASIO_DECL boost::system::error_code assign(implementation_type& impl, const native_handle_type& handle, boost::system::error_code& ec); // Determine whether the handle is open. bool is_open(const implementation_type& impl) const { return impl.handle_ != INVALID_HANDLE_VALUE; } // Destroy a handle implementation. BOOST_ASIO_DECL boost::system::error_code close(implementation_type& impl, boost::system::error_code& ec); // Get the native handle representation. native_handle_type native_handle(const implementation_type& impl) const { return impl.handle_; } // Cancel all operations associated with the handle. BOOST_ASIO_DECL boost::system::error_code cancel(implementation_type& impl, boost::system::error_code& ec); // Write the given data. Returns the number of bytes written. template <typename ConstBufferSequence> size_t write_some(implementation_type& impl, const ConstBufferSequence& buffers, boost::system::error_code& ec) { return write_some_at(impl, 0, buffers, ec); } // Write the given data at the specified offset. Returns the number of bytes // written. template <typename ConstBufferSequence> size_t write_some_at(implementation_type& impl, uint64_t offset, const ConstBufferSequence& buffers, boost::system::error_code& ec) { boost::asio::const_buffer buffer = buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence>::first(buffers); return do_write(impl, offset, buffer, ec); } // Start an asynchronous write. The data being written must be valid for the // lifetime of the asynchronous operation. template <typename ConstBufferSequence, typename Handler, typename IoExecutor> void async_write_some(implementation_type& impl, const ConstBufferSequence& buffers, Handler& handler, const IoExecutor& io_ex) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_handle_write_op< ConstBufferSequence, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(buffers, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((iocp_service_.context(), p.p, "handle", &impl, reinterpret_cast<uintmax_t>(impl.handle_), "async_write_some")); start_write_op(impl, 0, buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence>::first(buffers), p.p); p.v = p.p = 0; } // Start an asynchronous write at a specified offset. The data being written // must be valid for the lifetime of the asynchronous operation. template <typename ConstBufferSequence, typename Handler, typename IoExecutor> void async_write_some_at(implementation_type& impl, uint64_t offset, const ConstBufferSequence& buffers, Handler& handler, const IoExecutor& io_ex) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_handle_write_op< ConstBufferSequence, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(buffers, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((iocp_service_.context(), p.p, "handle", &impl, reinterpret_cast<uintmax_t>(impl.handle_), "async_write_some_at")); start_write_op(impl, offset, buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence>::first(buffers), p.p); p.v = p.p = 0; } // Read some data. Returns the number of bytes received. template <typename MutableBufferSequence> size_t read_some(implementation_type& impl, const MutableBufferSequence& buffers, boost::system::error_code& ec) { return read_some_at(impl, 0, buffers, ec); } // Read some data at a specified offset. Returns the number of bytes received. template <typename MutableBufferSequence> size_t read_some_at(implementation_type& impl, uint64_t offset, const MutableBufferSequence& buffers, boost::system::error_code& ec) { boost::asio::mutable_buffer buffer = buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence>::first(buffers); return do_read(impl, offset, buffer, ec); } // Start an asynchronous read. The buffer for the data being received must be // valid for the lifetime of the asynchronous operation. template <typename MutableBufferSequence, typename Handler, typename IoExecutor> void async_read_some(implementation_type& impl, const MutableBufferSequence& buffers, Handler& handler, const IoExecutor& io_ex) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_handle_read_op< MutableBufferSequence, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(buffers, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((iocp_service_.context(), p.p, "handle", &impl, reinterpret_cast<uintmax_t>(impl.handle_), "async_read_some")); start_read_op(impl, 0, buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence>::first(buffers), p.p); p.v = p.p = 0; } // Start an asynchronous read at a specified offset. The buffer for the data // being received must be valid for the lifetime of the asynchronous // operation. template <typename MutableBufferSequence, typename Handler, typename IoExecutor> void async_read_some_at(implementation_type& impl, uint64_t offset, const MutableBufferSequence& buffers, Handler& handler, const IoExecutor& io_ex) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_handle_read_op< MutableBufferSequence, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(buffers, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((iocp_service_.context(), p.p, "handle", &impl, reinterpret_cast<uintmax_t>(impl.handle_), "async_read_some_at")); start_read_op(impl, offset, buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence>::first(buffers), p.p); p.v = p.p = 0; } private: // Prevent the use of the null_buffers type with this service. size_t write_some(implementation_type& impl, const null_buffers& buffers, boost::system::error_code& ec); size_t write_some_at(implementation_type& impl, uint64_t offset, const null_buffers& buffers, boost::system::error_code& ec); template <typename Handler, typename IoExecutor> void async_write_some(implementation_type& impl, const null_buffers& buffers, Handler& handler, const IoExecutor& io_ex); template <typename Handler, typename IoExecutor> void async_write_some_at(implementation_type& impl, uint64_t offset, const null_buffers& buffers, Handler& handler, const IoExecutor& io_ex); size_t read_some(implementation_type& impl, const null_buffers& buffers, boost::system::error_code& ec); size_t read_some_at(implementation_type& impl, uint64_t offset, const null_buffers& buffers, boost::system::error_code& ec); template <typename Handler, typename IoExecutor> void async_read_some(implementation_type& impl, const null_buffers& buffers, Handler& handler, const IoExecutor& io_ex); template <typename Handler, typename IoExecutor> void async_read_some_at(implementation_type& impl, uint64_t offset, const null_buffers& buffers, Handler& handler, const IoExecutor& io_ex); // Helper class for waiting for synchronous operations to complete. class overlapped_wrapper; // Helper function to perform a synchronous write operation. BOOST_ASIO_DECL size_t do_write(implementation_type& impl, uint64_t offset, const boost::asio::const_buffer& buffer, boost::system::error_code& ec); // Helper function to start a write operation. BOOST_ASIO_DECL void start_write_op(implementation_type& impl, uint64_t offset, const boost::asio::const_buffer& buffer, operation* op); // Helper function to perform a synchronous write operation. BOOST_ASIO_DECL size_t do_read(implementation_type& impl, uint64_t offset, const boost::asio::mutable_buffer& buffer, boost::system::error_code& ec); // Helper function to start a read operation. BOOST_ASIO_DECL void start_read_op(implementation_type& impl, uint64_t offset, const boost::asio::mutable_buffer& buffer, operation* op); // Update the ID of the thread from which cancellation is safe. BOOST_ASIO_DECL void update_cancellation_thread_id(implementation_type& impl); // Helper function to close a handle when the associated object is being // destroyed. BOOST_ASIO_DECL void close_for_destruction(implementation_type& impl); // The IOCP service used for running asynchronous operations and dispatching // handlers. win_iocp_io_context& iocp_service_; // Mutex to protect access to the linked list of implementations. mutex mutex_; // The head of a linked list of all implementations. implementation_type* impl_list_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/win_iocp_handle_service.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_HAS_IOCP) #endif // BOOST_ASIO_DETAIL_WIN_IOCP_HANDLE_SERVICE_HPP PK��h!\V�N��select_interrupter.hppnu��[��// // detail/select_interrupter.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_SELECT_INTERRUPTER_HPP #define BOOST_ASIO_DETAIL_SELECT_INTERRUPTER_HPP #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_WINDOWS_RUNTIME) #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) \|\| defined(__SYMBIAN32__) # include <boost/asio/detail/socket_select_interrupter.hpp> #elif defined(BOOST_ASIO_HAS_EVENTFD) # include <boost/asio/detail/eventfd_select_interrupter.hpp> #else # include <boost/asio/detail/pipe_select_interrupter.hpp> #endif namespace boost { namespace asio { namespace detail { #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) \|\| defined(__SYMBIAN32__) typedef socket_select_interrupter select_interrupter; #elif defined(BOOST_ASIO_HAS_EVENTFD) typedef eventfd_select_interrupter select_interrupter; #else typedef pipe_select_interrupter select_interrupter; #endif } // namespace detail } // namespace asio } // namespace boost #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_SELECT_INTERRUPTER_HPP PK��h!\j B.T��T�� event.hppnu��[��// // detail/event.hpp // ~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_EVENT_HPP #define BOOST_ASIO_DETAIL_EVENT_HPP #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_HAS_THREADS) # include <boost/asio/detail/null_event.hpp> #elif defined(BOOST_ASIO_WINDOWS) # include <boost/asio/detail/win_event.hpp> #elif defined(BOOST_ASIO_HAS_PTHREADS) # include <boost/asio/detail/posix_event.hpp> #elif defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) # include <boost/asio/detail/std_event.hpp> #else # error Only Windows, POSIX and std::condition_variable are supported! #endif namespace boost { namespace asio { namespace detail { #if !defined(BOOST_ASIO_HAS_THREADS) typedef null_event event; #elif defined(BOOST_ASIO_WINDOWS) typedef win_event event; #elif defined(BOOST_ASIO_HAS_PTHREADS) typedef posix_event event; #elif defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) typedef std_event event; #endif } // namespace detail } // namespace asio } // namespace boost #endif // BOOST_ASIO_DETAIL_EVENT_HPP PK��h!\Sw��std_fenced_block.hppnu��[��// // detail/std_fenced_block.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_STD_FENCED_BLOCK_HPP #define BOOST_ASIO_DETAIL_STD_FENCED_BLOCK_HPP #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_HAS_STD_ATOMIC) #include <atomic> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class std_fenced_block : private noncopyable { public: enum half_t { half }; enum full_t { full }; // Constructor for a half fenced block. explicit std_fenced_block(half_t) { } // Constructor for a full fenced block. explicit std_fenced_block(full_t) { std::atomic_thread_fence(std::memory_order_acquire); } // Destructor. ~std_fenced_block() { std::atomic_thread_fence(std::memory_order_release); } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_STD_ATOMIC) #endif // BOOST_ASIO_DETAIL_STD_FENCED_BLOCK_HPP PK��h!\'��=��=��pop_options.hppnu��[��// // detail/pop_options.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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) // // No header guard #if defined(__COMO__) // Comeau C++ #elif defined(__DMC__) // Digital Mars C++ #elif defined(__INTEL_COMPILER) \|\| defined(__ICL) \ \|\| defined(__ICC) \|\| defined(__ECC) // Intel C++ # if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) \|\| (__GNUC__ > 4) # if !defined(BOOST_ASIO_DISABLE_VISIBILITY) # pragma GCC visibility pop # endif // !defined(BOOST_ASIO_DISABLE_VISIBILITY) # endif // (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) \|\| (__GNUC__ > 4) #elif defined(__clang__) // Clang # if defined(__OBJC__) # if !defined(__APPLE_CC__) \|\| (__APPLE_CC__ <= 1) # if defined(BOOST_ASIO_OBJC_WORKAROUND) # undef Protocol # undef id # undef BOOST_ASIO_OBJC_WORKAROUND # endif # endif # endif # if !defined(_WIN32) && !defined(__WIN32__) && !defined(WIN32) # if !defined(BOOST_ASIO_DISABLE_VISIBILITY) # pragma GCC visibility pop # endif // !defined(BOOST_ASIO_DISABLE_VISIBILITY) # endif // !defined(_WIN32) && !defined(__WIN32__) && !defined(WIN32) # pragma GCC diagnostic pop #elif defined(__GNUC__) // GNU C++ # if defined(__MINGW32__) \|\| defined(__CYGWIN__) # pragma pack (pop) # endif # if defined(__OBJC__) # if !defined(__APPLE_CC__) \|\| (__APPLE_CC__ <= 1) # if defined(BOOST_ASIO_OBJC_WORKAROUND) # undef Protocol # undef id # undef BOOST_ASIO_OBJC_WORKAROUND # endif # endif # endif # if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) \|\| (__GNUC__ > 4) # if !defined(BOOST_ASIO_DISABLE_VISIBILITY) # pragma GCC visibility pop # endif // !defined(BOOST_ASIO_DISABLE_VISIBILITY) # endif // (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) \|\| (__GNUC__ > 4) # pragma GCC diagnostic pop #elif defined(__KCC) // Kai C++ #elif defined(__sgi) // SGI MIPSpro C++ #elif defined(__DECCXX) // Compaq Tru64 Unix cxx #elif defined(__ghs) // Greenhills C++ #elif defined(__BORLANDC__) && !defined(__clang__) // Borland C++ # pragma option pop # pragma nopushoptwarn # pragma nopackwarning #elif defined(__MWERKS__) // Metrowerks CodeWarrior #elif defined(__SUNPRO_CC) // Sun Workshop Compiler C++ #elif defined(__HP_aCC) // HP aCC #elif defined(__MRC__) \|\| defined(__SC__) // MPW MrCpp or SCpp #elif defined(__IBMCPP__) // IBM Visual Age #elif defined(_MSC_VER) // Microsoft Visual C++ // // Must remain the last #elif since some other vendors (Metrowerks, for example) // also #define _MSC_VER # pragma warning (pop) # pragma pack (pop) # if defined(__cplusplus_cli) \|\| defined(__cplusplus_winrt) # if defined(BOOST_ASIO_CLR_WORKAROUND) # undef generic # undef BOOST_ASIO_CLR_WORKAROUND # endif # endif #endif PK��h!\��T��T��handler_cont_helpers.hppnu��[��// // detail/handler_cont_helpers.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_HANDLER_CONT_HELPERS_HPP #define BOOST_ASIO_DETAIL_HANDLER_CONT_HELPERS_HPP #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/detail/memory.hpp> #include <boost/asio/handler_continuation_hook.hpp> #include <boost/asio/detail/push_options.hpp> // Calls to asio_handler_is_continuation must be made from a namespace that // does not contain overloads of this function. This namespace is defined here // for that purpose. namespace boost_asio_handler_cont_helpers { template <typename Context> inline bool is_continuation(Context& context) { #if !defined(BOOST_ASIO_HAS_HANDLER_HOOKS) return false; #else using boost::asio::asio_handler_is_continuation; return asio_handler_is_continuation( boost::asio::detail::addressof(context)); #endif } } // namespace boost_asio_handler_cont_helpers #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_HANDLER_CONT_HELPERS_HPP PK��h!\��6��push_options.hppnu��[��// // detail/push_options.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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) // // No header guard #if defined(__COMO__) // Comeau C++ #elif defined(__DMC__) // Digital Mars C++ #elif defined(__INTEL_COMPILER) \|\| defined(__ICL) \ \|\| defined(__ICC) \|\| defined(__ECC) // Intel C++ # if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) \|\| (__GNUC__ > 4) # if !defined(BOOST_ASIO_DISABLE_VISIBILITY) # pragma GCC visibility push (default) # endif // !defined(BOOST_ASIO_DISABLE_VISIBILITY) # endif // (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) \|\| (__GNUC__ > 4) #elif defined(__clang__) // Clang # if defined(__OBJC__) # if !defined(__APPLE_CC__) \|\| (__APPLE_CC__ <= 1) # if !defined(BOOST_ASIO_DISABLE_OBJC_WORKAROUND) # if !defined(Protocol) && !defined(id) # define Protocol cpp_Protocol # define id cpp_id # define BOOST_ASIO_OBJC_WORKAROUND # endif # endif # endif # endif # if !defined(_WIN32) && !defined(__WIN32__) && !defined(WIN32) # if !defined(BOOST_ASIO_DISABLE_VISIBILITY) # pragma GCC visibility push (default) # endif // !defined(BOOST_ASIO_DISABLE_VISIBILITY) # endif // !defined(_WIN32) && !defined(__WIN32__) && !defined(WIN32) # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wnon-virtual-dtor" # if (__clang_major__ >= 6) # pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant" # endif // (__clang_major__ >= 6) #elif defined(__GNUC__) // GNU C++ # if defined(__MINGW32__) \|\| defined(__CYGWIN__) # pragma pack (push, 8) # endif # if defined(__OBJC__) # if !defined(__APPLE_CC__) \|\| (__APPLE_CC__ <= 1) # if !defined(BOOST_ASIO_DISABLE_OBJC_WORKAROUND) # if !defined(Protocol) && !defined(id) # define Protocol cpp_Protocol # define id cpp_id # define BOOST_ASIO_OBJC_WORKAROUND # endif # endif # endif # endif # if (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) \|\| (__GNUC__ > 4) # if !defined(BOOST_ASIO_DISABLE_VISIBILITY) # pragma GCC visibility push (default) # endif // !defined(BOOST_ASIO_DISABLE_VISIBILITY) # endif // (__GNUC__ == 4 && __GNUC_MINOR__ >= 1) \|\| (__GNUC__ > 4) # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wnon-virtual-dtor" # if (__GNUC__ == 4 && __GNUC_MINOR__ >= 7) \|\| (__GNUC__ > 4) # pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant" # endif // (__GNUC__ == 4 && __GNUC_MINOR__ >= 7) \|\| (__GNUC__ > 4) # if (__GNUC__ >= 7) # pragma GCC diagnostic ignored "-Wimplicit-fallthrough" # endif // (__GNUC__ >= 7) #elif defined(__KCC) // Kai C++ #elif defined(__sgi) // SGI MIPSpro C++ #elif defined(__DECCXX) // Compaq Tru64 Unix cxx #elif defined(__ghs) // Greenhills C++ #elif defined(__BORLANDC__) && !defined(__clang__) // Borland C++ # pragma option push -a8 -b -Ve- -Vx- -w-inl -vi- # pragma nopushoptwarn # pragma nopackwarning # if !defined(__MT__) # error Multithreaded RTL must be selected. # endif // !defined(__MT__) #elif defined(__MWERKS__) // Metrowerks CodeWarrior #elif defined(__SUNPRO_CC) // Sun Workshop Compiler C++ #elif defined(__HP_aCC) // HP aCC #elif defined(__MRC__) \|\| defined(__SC__) // MPW MrCpp or SCpp #elif defined(__IBMCPP__) // IBM Visual Age #elif defined(_MSC_VER) // Microsoft Visual C++ // // Must remain the last #elif since some other vendors (Metrowerks, for example) // also #define _MSC_VER # pragma warning (disable:4103) # pragma warning (push) # pragma warning (disable:4127) # pragma warning (disable:4180) # pragma warning (disable:4244) # pragma warning (disable:4355) # pragma warning (disable:4510) # pragma warning (disable:4512) # pragma warning (disable:4610) # pragma warning (disable:4675) # if (_MSC_VER < 1600) // Visual Studio 2008 generates spurious warnings about unused parameters. # pragma warning (disable:4100) # endif // (_MSC_VER < 1600) # if defined(_M_IX86) && defined(_Wp64) // The /Wp64 option is broken. If you want to check 64 bit portability, use a // 64 bit compiler! # pragma warning (disable:4311) # pragma warning (disable:4312) # endif // defined(_M_IX86) && defined(_Wp64) # pragma pack (push, 8) // Note that if the /Og optimisation flag is enabled with MSVC6, the compiler // has a tendency to incorrectly optimise away some calls to member template // functions, even though those functions contain code that should not be // optimised away! Therefore we will always disable this optimisation option // for the MSVC6 compiler. # if (_MSC_VER < 1300) # pragma optimize ("g", off) # endif # if !defined(_MT) # error Multithreaded RTL must be selected. # endif // !defined(_MT) # if defined(__cplusplus_cli) \|\| defined(__cplusplus_winrt) # if !defined(BOOST_ASIO_DISABLE_CLR_WORKAROUND) # if !defined(generic) # define generic cpp_generic # define BOOST_ASIO_CLR_WORKAROUND # endif # endif # endif #endif PK��h!\�� strand_service.hppnu��[��// // detail/strand_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_STRAND_SERVICE_HPP #define BOOST_ASIO_DETAIL_STRAND_SERVICE_HPP #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/io_context.hpp> #include <boost/asio/detail/mutex.hpp> #include <boost/asio/detail/op_queue.hpp> #include <boost/asio/detail/operation.hpp> #include <boost/asio/detail/scoped_ptr.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { // Default service implementation for a strand. class strand_service : public boost::asio::detail::service_base<strand_service> { private: // Helper class to re-post the strand on exit. struct on_do_complete_exit; // Helper class to re-post the strand on exit. struct on_dispatch_exit; public: // The underlying implementation of a strand. class strand_impl : public operation { public: strand_impl(); private: // Only this service will have access to the internal values. friend class strand_service; friend struct on_do_complete_exit; friend struct on_dispatch_exit; // Mutex to protect access to internal data. boost::asio::detail::mutex mutex_; // Indicates whether the strand is currently "locked" by a handler. This // means that there is a handler upcall in progress, or that the strand // itself has been scheduled in order to invoke some pending handlers. bool locked_; // The handlers that are waiting on the strand but should not be run until // after the next time the strand is scheduled. This queue must only be // modified while the mutex is locked. op_queue<operation> waiting_queue_; // The handlers that are ready to be run. Logically speaking, these are the // handlers that hold the strand's lock. The ready queue is only modified // from within the strand and so may be accessed without locking the mutex. op_queue<operation> ready_queue_; }; typedef strand_impl* implementation_type; // Construct a new strand service for the specified io_context. BOOST_ASIO_DECL explicit strand_service(boost::asio::io_context& io_context); // Destroy all user-defined handler objects owned by the service. BOOST_ASIO_DECL void shutdown(); // Construct a new strand implementation. BOOST_ASIO_DECL void construct(implementation_type& impl); // Request the io_context to invoke the given handler. template <typename Handler> void dispatch(implementation_type& impl, Handler& handler); // Request the io_context to invoke the given handler and return immediately. template <typename Handler> void post(implementation_type& impl, Handler& handler); // Determine whether the strand is running in the current thread. BOOST_ASIO_DECL bool running_in_this_thread( const implementation_type& impl) const; private: // Helper function to dispatch a handler. Returns true if the handler should // be dispatched immediately. BOOST_ASIO_DECL bool do_dispatch(implementation_type& impl, operation* op); // Helper fiunction to post a handler. BOOST_ASIO_DECL void do_post(implementation_type& impl, operation* op, bool is_continuation); BOOST_ASIO_DECL static void do_complete(void* owner, operation* base, const boost::system::error_code& ec, std::size_t bytes_transferred); // The io_context used to obtain an I/O executor. io_context& io_context_; // The io_context implementation used to post completions. io_context_impl& io_context_impl_; // Mutex to protect access to the array of implementations. boost::asio::detail::mutex mutex_; // Number of implementations shared between all strand objects. #if defined(BOOST_ASIO_STRAND_IMPLEMENTATIONS) enum { num_implementations = BOOST_ASIO_STRAND_IMPLEMENTATIONS }; #else // defined(BOOST_ASIO_STRAND_IMPLEMENTATIONS) enum { num_implementations = 193 }; #endif // defined(BOOST_ASIO_STRAND_IMPLEMENTATIONS) // Pool of implementations. scoped_ptr<strand_impl> implementations_[num_implementations]; // Extra value used when hashing to prevent recycled memory locations from // getting the same strand implementation. std::size_t salt_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #include <boost/asio/detail/impl/strand_service.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/strand_service.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // BOOST_ASIO_DETAIL_STRAND_SERVICE_HPP PK��h!\��\| �� std_global.hppnu��[��// // detail/std_global.hpp // ~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_STD_GLOBAL_HPP #define BOOST_ASIO_DETAIL_STD_GLOBAL_HPP #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_HAS_STD_CALL_ONCE) #include <exception> #include <mutex> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename T> struct std_global_impl { // Helper function to perform initialisation. static void do_init() { instance_.ptr_ = new T; } // Destructor automatically cleans up the global. ~std_global_impl() { delete ptr_; } static std::once_flag init_once_; static std_global_impl instance_; T* ptr_; }; template <typename T> std::once_flag std_global_impl<T>::init_once_; template <typename T> std_global_impl<T> std_global_impl<T>::instance_; template <typename T> T& std_global() { std::call_once(std_global_impl<T>::init_once_, &std_global_impl<T>::do_init); return std_global_impl<T>::instance_.ptr_; } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_STD_CALL_ONCE) #endif // BOOST_ASIO_DETAIL_STD_GLOBAL_HPP PK��h!\.;�~{ ��{ ��wince_thread.hppnu��[��// // detail/wince_thread.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WINCE_THREAD_HPP #define BOOST_ASIO_DETAIL_WINCE_THREAD_HPP #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_WINDOWS) && defined(UNDER_CE) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/scoped_ptr.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { DWORD WINAPI wince_thread_function(LPVOID arg); class wince_thread : private noncopyable { public: // Constructor. template <typename Function> wince_thread(Function f, unsigned int = 0) { scoped_ptr<func_base> arg(new func<Function>(f)); DWORD thread_id = 0; thread_ = ::CreateThread(0, 0, wince_thread_function, arg.get(), 0, &thread_id); if (!thread_) { DWORD last_error = ::GetLastError(); boost::system::error_code ec(last_error, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "thread"); } arg.release(); } // Destructor. ~wince_thread() { ::CloseHandle(thread_); } // Wait for the thread to exit. void join() { ::WaitForSingleObject(thread_, INFINITE); } // Get number of CPUs. static std::size_t hardware_concurrency() { SYSTEM_INFO system_info; ::GetSystemInfo(&system_info); return system_info.dwNumberOfProcessors; } private: friend DWORD WINAPI wince_thread_function(LPVOID arg); class func_base { public: virtual ~func_base() {} virtual void run() = 0; }; template <typename Function> class func : public func_base { public: func(Function f) : f_(f) { } virtual void run() { f_(); } private: Function f_; }; ::HANDLE thread_; }; inline DWORD WINAPI wince_thread_function(LPVOID arg) { scoped_ptr<wince_thread::func_base> func( static_cast<wince_thread::func_base>(arg)); func->run(); return 0; } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS) && defined(UNDER_CE) #endif // BOOST_ASIO_DETAIL_WINCE_THREAD_HPP PK��h!\�30��0��cstddef.hppnu��[��// // detail/cstddef.hpp // ~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_CSTDDEF_HPP #define BOOST_ASIO_DETAIL_CSTDDEF_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <cstddef> namespace boost { namespace asio { #if defined(BOOST_ASIO_HAS_NULLPTR) using std::nullptr_t; #else // defined(BOOST_ASIO_HAS_NULLPTR) struct nullptr_t {}; #endif // defined(BOOST_ASIO_HAS_NULLPTR) } // namespace asio } // namespace boost #endif // BOOST_ASIO_DETAIL_CSTDDEF_HPP PK��h!\s9U<��<��timer_queue_ptime.hppnu��[��// // detail/timer_queue_ptime.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_TIMER_QUEUE_PTIME_HPP #define BOOST_ASIO_DETAIL_TIMER_QUEUE_PTIME_HPP #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_HAS_BOOST_DATE_TIME) #include <boost/asio/time_traits.hpp> #include <boost/asio/detail/timer_queue.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { struct forwarding_posix_time_traits : time_traits<boost::posix_time::ptime> {}; // Template specialisation for the commonly used instantation. template <> class timer_queue<time_traits<boost::posix_time::ptime> > : public timer_queue_base { public: // The time type. typedef boost::posix_time::ptime time_type; // The duration type. typedef boost::posix_time::time_duration duration_type; // Per-timer data. typedef timer_queue<forwarding_posix_time_traits>::per_timer_data per_timer_data; // Constructor. BOOST_ASIO_DECL timer_queue(); // Destructor. BOOST_ASIO_DECL virtual ~timer_queue(); // Add a new timer to the queue. Returns true if this is the timer that is // earliest in the queue, in which case the reactor's event demultiplexing // function call may need to be interrupted and restarted. BOOST_ASIO_DECL bool enqueue_timer(const time_type& time, per_timer_data& timer, wait_op* op); // Whether there are no timers in the queue. BOOST_ASIO_DECL virtual bool empty() const; // Get the time for the timer that is earliest in the queue. BOOST_ASIO_DECL virtual long wait_duration_msec(long max_duration) const; // Get the time for the timer that is earliest in the queue. BOOST_ASIO_DECL virtual long wait_duration_usec(long max_duration) const; // Dequeue all timers not later than the current time. BOOST_ASIO_DECL virtual void get_ready_timers(op_queue<operation>& ops); // Dequeue all timers. BOOST_ASIO_DECL virtual void get_all_timers(op_queue<operation>& ops); // Cancel and dequeue operations for the given timer. BOOST_ASIO_DECL std::size_t cancel_timer( per_timer_data& timer, op_queue<operation>& ops, std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)()); // Move operations from one timer to another, empty timer. BOOST_ASIO_DECL void move_timer(per_timer_data& target, per_timer_data& source); private: timer_queue<forwarding_posix_time_traits> impl_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/timer_queue_ptime.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_HAS_BOOST_DATE_TIME) #endif // BOOST_ASIO_DETAIL_TIMER_QUEUE_PTIME_HPP PK��h!\e(ۿd��d��macos_fenced_block.hppnu��[��// // detail/macos_fenced_block.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_MACOS_FENCED_BLOCK_HPP #define BOOST_ASIO_DETAIL_MACOS_FENCED_BLOCK_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(__MACH__) && defined(__APPLE__) #include <libkern/OSAtomic.h> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class macos_fenced_block : private noncopyable { public: enum half_t { half }; enum full_t { full }; // Constructor for a half fenced block. explicit macos_fenced_block(half_t) { } // Constructor for a full fenced block. explicit macos_fenced_block(full_t) { OSMemoryBarrier(); } // Destructor. ~macos_fenced_block() { OSMemoryBarrier(); } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(__MACH__) && defined(__APPLE__) #endif // BOOST_ASIO_DETAIL_MACOS_FENCED_BLOCK_HPP PK��h!\z ��B��B��win_iocp_overlapped_ptr.hppnu��[��// // detail/win_iocp_overlapped_ptr.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_IOCP_OVERLAPPED_PTR_HPP #define BOOST_ASIO_DETAIL_WIN_IOCP_OVERLAPPED_PTR_HPP #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_HAS_IOCP) #include <boost/asio/io_context.hpp> #include <boost/asio/query.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/win_iocp_overlapped_op.hpp> #include <boost/asio/detail/win_iocp_io_context.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { // Wraps a handler to create an OVERLAPPED object for use with overlapped I/O. class win_iocp_overlapped_ptr : private noncopyable { public: // Construct an empty win_iocp_overlapped_ptr. win_iocp_overlapped_ptr() : ptr_(0), iocp_service_(0) { } // Construct an win_iocp_overlapped_ptr to contain the specified handler. template <typename Executor, typename Handler> explicit win_iocp_overlapped_ptr(const Executor& ex, BOOST_ASIO_MOVE_ARG(Handler) handler) : ptr_(0), iocp_service_(0) { this->reset(ex, BOOST_ASIO_MOVE_CAST(Handler)(handler)); } // Destructor automatically frees the OVERLAPPED object unless released. ~win_iocp_overlapped_ptr() { reset(); } // Reset to empty. void reset() { if (ptr_) { ptr_->destroy(); ptr_ = 0; iocp_service_->work_finished(); iocp_service_ = 0; } } // Reset to contain the specified handler, freeing any current OVERLAPPED // object. template <typename Executor, typename Handler> void reset(const Executor& ex, Handler handler) { win_iocp_io_context* iocp_service = this->get_iocp_service(ex); typedef win_iocp_overlapped_op<Handler, Executor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(handler, ex); BOOST_ASIO_HANDLER_CREATION((ex.context(), p.p, "iocp_service", iocp_service, 0, "overlapped")); iocp_service->work_started(); reset(); ptr_ = p.p; p.v = p.p = 0; iocp_service_ = iocp_service; } // Get the contained OVERLAPPED object. OVERLAPPED get() { return ptr_; } // Get the contained OVERLAPPED object. const OVERLAPPED* get() const { return ptr_; } // Release ownership of the OVERLAPPED object. OVERLAPPED* release() { if (ptr_) iocp_service_->on_pending(ptr_); OVERLAPPED* tmp = ptr_; ptr_ = 0; iocp_service_ = 0; return tmp; } // Post completion notification for overlapped operation. Releases ownership. void complete(const boost::system::error_code& ec, std::size_t bytes_transferred) { if (ptr_) { iocp_service_->on_completion(ptr_, ec, static_cast<DWORD>(bytes_transferred)); ptr_ = 0; iocp_service_ = 0; } } private: template <typename Executor> static win_iocp_io_context* get_iocp_service(const Executor& ex, typename enable_if< can_query<const Executor&, execution::context_t>::value >::type* = 0) { return &use_service<win_iocp_io_context>( boost::asio::query(ex, execution::context)); } template <typename Executor> static win_iocp_io_context* get_iocp_service(const Executor& ex, typename enable_if< !can_query<const Executor&, execution::context_t>::value >::type* = 0) { return &use_service<win_iocp_io_context>(ex.context()); } static win_iocp_io_context* get_iocp_service( const io_context::executor_type& ex) { return &boost::asio::query(ex, execution::context).impl_; } win_iocp_operation* ptr_; win_iocp_io_context* iocp_service_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #endif // BOOST_ASIO_DETAIL_WIN_IOCP_OVERLAPPED_PTR_HPP PK��h!\�53C]��]��winrt_socket_send_op.hppnu��[��// // detail/winrt_socket_send_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WINRT_SOCKET_SEND_OP_HPP #define BOOST_ASIO_DETAIL_WINRT_SOCKET_SEND_OP_HPP #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_WINDOWS_RUNTIME) #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/winrt_async_op.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename ConstBufferSequence, typename Handler, typename IoExecutor> class winrt_socket_send_op : public winrt_async_op<unsigned int> { public: BOOST_ASIO_DEFINE_HANDLER_PTR(winrt_socket_send_op); winrt_socket_send_op(const ConstBufferSequence& buffers, Handler& handler, const IoExecutor& io_ex) : winrt_async_op<unsigned int>(&winrt_socket_send_op::do_complete), buffers_(buffers), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static void do_complete(void* owner, operation* base, const boost::system::error_code&, std::size_t) { // Take ownership of the operation object. winrt_socket_send_op* o(static_cast<winrt_socket_send_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) // Check whether buffers are still valid. if (owner) { buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence>::validate(o->buffers_); } #endif // defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, o->ec_, o->result_); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: ConstBufferSequence buffers_; Handler handler_; handler_work<Handler, IoExecutor> executor_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_WINRT_SOCKET_SEND_OP_HPP PK��h!\��U�x��x��thread_info_base.hppnu��[��// // detail/thread_info_base.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_THREAD_INFO_BASE_HPP #define BOOST_ASIO_DETAIL_THREAD_INFO_BASE_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <climits> #include <cstddef> #include <boost/asio/detail/noncopyable.hpp> #if defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) \ && !defined(BOOST_ASIO_NO_EXCEPTIONS) # include <exception> # include <boost/asio/multiple_exceptions.hpp> #endif // defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) // && !defined(BOOST_ASIO_NO_EXCEPTIONS) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class thread_info_base : private noncopyable { public: struct default_tag { enum { mem_index = 0 }; }; struct awaitable_frame_tag { enum { mem_index = 1 }; }; struct executor_function_tag { enum { mem_index = 2 }; }; thread_info_base() #if defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) \ && !defined(BOOST_ASIO_NO_EXCEPTIONS) : has_pending_exception_(0) #endif // defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) // && !defined(BOOST_ASIO_NO_EXCEPTIONS) { for (int i = 0; i < max_mem_index; ++i) reusable_memory_[i] = 0; } ~thread_info_base() { for (int i = 0; i < max_mem_index; ++i) { // The following test for non-null pointers is technically redundant, but // it is significantly faster when using a tight io_context::poll() loop // in latency sensitive applications. if (reusable_memory_[i]) ::operator delete(reusable_memory_[i]); } } static void* allocate(thread_info_base* this_thread, std::size_t size) { return allocate(default_tag(), this_thread, size); } static void deallocate(thread_info_base* this_thread, void* pointer, std::size_t size) { deallocate(default_tag(), this_thread, pointer, size); } template <typename Purpose> static void* allocate(Purpose, thread_info_base* this_thread, std::size_t size) { std::size_t chunks = (size + chunk_size - 1) / chunk_size; if (this_thread && this_thread->reusable_memory_[Purpose::mem_index]) { void* const pointer = this_thread->reusable_memory_[Purpose::mem_index]; this_thread->reusable_memory_[Purpose::mem_index] = 0; unsigned char* const mem = static_cast<unsigned char>(pointer); if (static_cast<std::size_t>(mem[0]) >= chunks) { mem[size] = mem[0]; return pointer; } ::operator delete(pointer); } void const pointer = ::operator new(chunks * chunk_size + 1); unsigned char* const mem = static_cast<unsigned char>(pointer); mem[size] = (chunks <= UCHAR_MAX) ? static_cast<unsigned char>(chunks) : 0; return pointer; } template <typename Purpose> static void deallocate(Purpose, thread_info_base this_thread, void* pointer, std::size_t size) { if (size <= chunk_size * UCHAR_MAX) { if (this_thread && this_thread->reusable_memory_[Purpose::mem_index] == 0) { unsigned char* const mem = static_cast<unsigned char>(pointer); mem[0] = mem[size]; this_thread->reusable_memory_[Purpose::mem_index] = pointer; return; } } ::operator delete(pointer); } void capture_current_exception() { #if defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) \ && !defined(BOOST_ASIO_NO_EXCEPTIONS) switch (has_pending_exception_) { case 0: has_pending_exception_ = 1; pending_exception_ = std::current_exception(); break; case 1: has_pending_exception_ = 2; pending_exception_ = std::make_exception_ptr<multiple_exceptions>( multiple_exceptions(pending_exception_)); break; default: break; } #endif // defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) // && !defined(BOOST_ASIO_NO_EXCEPTIONS) } void rethrow_pending_exception() { #if defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) \ && !defined(BOOST_ASIO_NO_EXCEPTIONS) if (has_pending_exception_ > 0) { has_pending_exception_ = 0; std::exception_ptr ex( BOOST_ASIO_MOVE_CAST(std::exception_ptr)( pending_exception_)); std::rethrow_exception(ex); } #endif // defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) // && !defined(BOOST_ASIO_NO_EXCEPTIONS) } private: enum { chunk_size = 4 }; enum { max_mem_index = 3 }; void reusable_memory_[max_mem_index]; #if defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) \ && !defined(BOOST_ASIO_NO_EXCEPTIONS) int has_pending_exception_; std::exception_ptr pending_exception_; #endif // defined(BOOST_ASIO_HAS_STD_EXCEPTION_PTR) // && !defined(BOOST_ASIO_NO_EXCEPTIONS) }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_THREAD_INFO_BASE_HPP PK��h!\�{��non_const_lvalue.hppnu��[��// // detail/non_const_lvalue.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_NON_CONST_LVALUE_HPP #define BOOST_ASIO_DETAIL_NON_CONST_LVALUE_HPP #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/detail/type_traits.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename T> struct non_const_lvalue { #if defined(BOOST_ASIO_HAS_MOVE) explicit non_const_lvalue(T& t) : value(static_cast<typename conditional< is_same<T, typename decay<T>::type>::value, typename decay<T>::type&, T&&>::type>(t)) { } typename conditional<is_same<T, typename decay<T>::type>::value, typename decay<T>::type&, typename decay<T>::type>::type value; #else // defined(BOOST_ASIO_HAS_MOVE) \|\| defined(GENERATING_DOCUMENTATION) explicit non_const_lvalue(const typename decay<T>::type& t) : value(t) { } typename decay<T>::type value; #endif // defined(BOOST_ASIO_HAS_MOVE) }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_NON_CONST_LVALUE_HPP PK��h!\��[��[��tss_ptr.hppnu��[��// // detail/tss_ptr.hpp // ~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_TSS_PTR_HPP #define BOOST_ASIO_DETAIL_TSS_PTR_HPP #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_HAS_THREADS) # include <boost/asio/detail/null_tss_ptr.hpp> #elif defined(BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION) # include <boost/asio/detail/keyword_tss_ptr.hpp> #elif defined(BOOST_ASIO_WINDOWS) # include <boost/asio/detail/win_tss_ptr.hpp> #elif defined(BOOST_ASIO_HAS_PTHREADS) # include <boost/asio/detail/posix_tss_ptr.hpp> #else # error Only Windows and POSIX are supported! #endif #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename T> class tss_ptr #if !defined(BOOST_ASIO_HAS_THREADS) : public null_tss_ptr<T> #elif defined(BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION) : public keyword_tss_ptr<T> #elif defined(BOOST_ASIO_WINDOWS) : public win_tss_ptr<T> #elif defined(BOOST_ASIO_HAS_PTHREADS) : public posix_tss_ptr<T> #endif { public: void operator=(T* value) { #if !defined(BOOST_ASIO_HAS_THREADS) null_tss_ptr<T>::operator=(value); #elif defined(BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION) keyword_tss_ptr<T>::operator=(value); #elif defined(BOOST_ASIO_WINDOWS) win_tss_ptr<T>::operator=(value); #elif defined(BOOST_ASIO_HAS_PTHREADS) posix_tss_ptr<T>::operator=(value); #endif } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_TSS_PTR_HPP PK��h!\qR��keyword_tss_ptr.hppnu��[��// // detail/keyword_tss_ptr.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_KEYWORD_TSS_PTR_HPP #define BOOST_ASIO_DETAIL_KEYWORD_TSS_PTR_HPP #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_HAS_THREAD_KEYWORD_EXTENSION) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename T> class keyword_tss_ptr : private noncopyable { public: // Constructor. keyword_tss_ptr() { } // Destructor. ~keyword_tss_ptr() { } // Get the value. operator T() const { return value_; } // Set the value. void operator=(T value) { value_ = value; } private: static BOOST_ASIO_THREAD_KEYWORD T* value_; }; template <typename T> BOOST_ASIO_THREAD_KEYWORD T* keyword_tss_ptr<T>::value_; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_THREAD_KEYWORD_EXTENSION) #endif // BOOST_ASIO_DETAIL_KEYWORD_TSS_PTR_HPP PK��h!\��m$��$��resolve_endpoint_op.hppnu��[��// // detail/resolve_endpoint_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_RESOLVER_ENDPOINT_OP_HPP #define BOOST_ASIO_DETAIL_RESOLVER_ENDPOINT_OP_HPP #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/detail/bind_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/resolve_op.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/error.hpp> #include <boost/asio/ip/basic_resolver_results.hpp> #if defined(BOOST_ASIO_HAS_IOCP) # include <boost/asio/detail/win_iocp_io_context.hpp> #else // defined(BOOST_ASIO_HAS_IOCP) # include <boost/asio/detail/scheduler.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Protocol, typename Handler, typename IoExecutor> class resolve_endpoint_op : public resolve_op { public: BOOST_ASIO_DEFINE_HANDLER_PTR(resolve_endpoint_op); typedef typename Protocol::endpoint endpoint_type; typedef boost::asio::ip::basic_resolver_results<Protocol> results_type; #if defined(BOOST_ASIO_HAS_IOCP) typedef class win_iocp_io_context scheduler_impl; #else typedef class scheduler scheduler_impl; #endif resolve_endpoint_op(socket_ops::weak_cancel_token_type cancel_token, const endpoint_type& endpoint, scheduler_impl& sched, Handler& handler, const IoExecutor& io_ex) : resolve_op(&resolve_endpoint_op::do_complete), cancel_token_(cancel_token), endpoint_(endpoint), scheduler_(sched), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static void do_complete(void* owner, operation* base, const boost::system::error_code& /ec/, std::size_t /bytes_transferred/) { // Take ownership of the operation object. resolve_endpoint_op* o(static_cast<resolve_endpoint_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; if (owner && owner != &o->scheduler_) { // The operation is being run on the worker io_context. Time to perform // the resolver operation. // Perform the blocking endpoint resolution operation. char host_name[NI_MAXHOST]; char service_name[NI_MAXSERV]; socket_ops::background_getnameinfo(o->cancel_token_, o->endpoint_.data(), o->endpoint_.size(), host_name, NI_MAXHOST, service_name, NI_MAXSERV, o->endpoint_.protocol().type(), o->ec_); o->results_ = results_type::create(o->endpoint_, host_name, service_name); // Pass operation back to main io_context for completion. o->scheduler_.post_deferred_completion(o); p.v = p.p = 0; } else { // The operation has been returned to the main io_context. The completion // handler is ready to be delivered. BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); // Make a copy of the handler so that the memory can be deallocated // before the upcall is made. Even if we're not about to make an upcall, // a sub-object of the handler may be the true owner of the memory // associated with the handler. Consequently, a local copy of the handler // is required to ensure that any owning sub-object remains valid until // after we have deallocated the memory here. detail::binder2<Handler, boost::system::error_code, results_type> handler(o->handler_, o->ec_, o->results_); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "...")); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } } private: socket_ops::weak_cancel_token_type cancel_token_; endpoint_type endpoint_; scheduler_impl& scheduler_; Handler handler_; handler_work<Handler, IoExecutor> work_; results_type results_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_RESOLVER_ENDPOINT_OP_HPP PK��h!\!�+�7��7��scheduler_thread_info.hppnu��[��// // detail/scheduler_thread_info.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_SCHEDULER_THREAD_INFO_HPP #define BOOST_ASIO_DETAIL_SCHEDULER_THREAD_INFO_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/op_queue.hpp> #include <boost/asio/detail/thread_info_base.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class scheduler; class scheduler_operation; struct scheduler_thread_info : public thread_info_base { op_queue<scheduler_operation> private_op_queue; long private_outstanding_work; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_SCHEDULER_THREAD_INFO_HPP PK��h!\��s��win_static_mutex.hppnu��[��// // detail/win_static_mutex.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_STATIC_MUTEX_HPP #define BOOST_ASIO_DETAIL_WIN_STATIC_MUTEX_HPP #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_WINDOWS) #include <boost/asio/detail/scoped_lock.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { struct win_static_mutex { typedef boost::asio::detail::scoped_lock<win_static_mutex> scoped_lock; // Initialise the mutex. BOOST_ASIO_DECL void init(); // Initialisation must be performed in a separate function to the "public" // init() function since the compiler does not support the use of structured // exceptions and C++ exceptions in the same function. BOOST_ASIO_DECL int do_init(); // Lock the mutex. void lock() { ::EnterCriticalSection(&crit_section_); } // Unlock the mutex. void unlock() { ::LeaveCriticalSection(&crit_section_); } bool initialised_; ::CRITICAL_SECTION crit_section_; }; #if defined(UNDER_CE) # define BOOST_ASIO_WIN_STATIC_MUTEX_INIT { false, { 0, 0, 0, 0, 0 } } #else // defined(UNDER_CE) # define BOOST_ASIO_WIN_STATIC_MUTEX_INIT { false, { 0, 0, 0, 0, 0, 0 } } #endif // defined(UNDER_CE) } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/win_static_mutex.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_WINDOWS) #endif // BOOST_ASIO_DETAIL_WIN_STATIC_MUTEX_HPP PK��h!\��null_tss_ptr.hppnu��[��// // detail/null_tss_ptr.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_NULL_TSS_PTR_HPP #define BOOST_ASIO_DETAIL_NULL_TSS_PTR_HPP #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_HAS_THREADS) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename T> class null_tss_ptr : private noncopyable { public: // Constructor. null_tss_ptr() : value_(0) { } // Destructor. ~null_tss_ptr() { } // Get the value. operator T() const { return value_; } // Set the value. void operator=(T value) { value_ = value; } private: T* value_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // !defined(BOOST_ASIO_HAS_THREADS) #endif // BOOST_ASIO_DETAIL_NULL_TSS_PTR_HPP PK��h!\p��[$��$��deadline_timer_service.hppnu��[��// // detail/deadline_timer_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_DEADLINE_TIMER_SERVICE_HPP #define BOOST_ASIO_DETAIL_DEADLINE_TIMER_SERVICE_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <cstddef> #include <boost/asio/error.hpp> #include <boost/asio/execution_context.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/timer_queue.hpp> #include <boost/asio/detail/timer_queue_ptime.hpp> #include <boost/asio/detail/timer_scheduler.hpp> #include <boost/asio/detail/wait_handler.hpp> #include <boost/asio/detail/wait_op.hpp> #if defined(BOOST_ASIO_WINDOWS_RUNTIME) # include <chrono> # include <thread> #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Time_Traits> class deadline_timer_service : public execution_context_service_base<deadline_timer_service<Time_Traits> > { public: // The time type. typedef typename Time_Traits::time_type time_type; // The duration type. typedef typename Time_Traits::duration_type duration_type; // The implementation type of the timer. This type is dependent on the // underlying implementation of the timer service. struct implementation_type : private boost::asio::detail::noncopyable { time_type expiry; bool might_have_pending_waits; typename timer_queue<Time_Traits>::per_timer_data timer_data; }; // Constructor. deadline_timer_service(execution_context& context) : execution_context_service_base< deadline_timer_service<Time_Traits> >(context), scheduler_(boost::asio::use_service<timer_scheduler>(context)) { scheduler_.init_task(); scheduler_.add_timer_queue(timer_queue_); } // Destructor. ~deadline_timer_service() { scheduler_.remove_timer_queue(timer_queue_); } // Destroy all user-defined handler objects owned by the service. void shutdown() { } // Construct a new timer implementation. void construct(implementation_type& impl) { impl.expiry = time_type(); impl.might_have_pending_waits = false; } // Destroy a timer implementation. void destroy(implementation_type& impl) { boost::system::error_code ec; cancel(impl, ec); } // Move-construct a new timer implementation. void move_construct(implementation_type& impl, implementation_type& other_impl) { scheduler_.move_timer(timer_queue_, impl.timer_data, other_impl.timer_data); impl.expiry = other_impl.expiry; other_impl.expiry = time_type(); impl.might_have_pending_waits = other_impl.might_have_pending_waits; other_impl.might_have_pending_waits = false; } // Move-assign from another timer implementation. void move_assign(implementation_type& impl, deadline_timer_service& other_service, implementation_type& other_impl) { if (this != &other_service) if (impl.might_have_pending_waits) scheduler_.cancel_timer(timer_queue_, impl.timer_data); other_service.scheduler_.move_timer(other_service.timer_queue_, impl.timer_data, other_impl.timer_data); impl.expiry = other_impl.expiry; other_impl.expiry = time_type(); impl.might_have_pending_waits = other_impl.might_have_pending_waits; other_impl.might_have_pending_waits = false; } // Move-construct a new timer implementation. void converting_move_construct(implementation_type& impl, deadline_timer_service&, implementation_type& other_impl) { move_construct(impl, other_impl); } // Move-assign from another timer implementation. void converting_move_assign(implementation_type& impl, deadline_timer_service& other_service, implementation_type& other_impl) { move_assign(impl, other_service, other_impl); } // Cancel any asynchronous wait operations associated with the timer. std::size_t cancel(implementation_type& impl, boost::system::error_code& ec) { if (!impl.might_have_pending_waits) { ec = boost::system::error_code(); return 0; } BOOST_ASIO_HANDLER_OPERATION((scheduler_.context(), "deadline_timer", &impl, 0, "cancel")); std::size_t count = scheduler_.cancel_timer(timer_queue_, impl.timer_data); impl.might_have_pending_waits = false; ec = boost::system::error_code(); return count; } // Cancels one asynchronous wait operation associated with the timer. std::size_t cancel_one(implementation_type& impl, boost::system::error_code& ec) { if (!impl.might_have_pending_waits) { ec = boost::system::error_code(); return 0; } BOOST_ASIO_HANDLER_OPERATION((scheduler_.context(), "deadline_timer", &impl, 0, "cancel_one")); std::size_t count = scheduler_.cancel_timer( timer_queue_, impl.timer_data, 1); if (count == 0) impl.might_have_pending_waits = false; ec = boost::system::error_code(); return count; } // Get the expiry time for the timer as an absolute time. time_type expiry(const implementation_type& impl) const { return impl.expiry; } // Get the expiry time for the timer as an absolute time. time_type expires_at(const implementation_type& impl) const { return impl.expiry; } // Get the expiry time for the timer relative to now. duration_type expires_from_now(const implementation_type& impl) const { return Time_Traits::subtract(this->expiry(impl), Time_Traits::now()); } // Set the expiry time for the timer as an absolute time. std::size_t expires_at(implementation_type& impl, const time_type& expiry_time, boost::system::error_code& ec) { std::size_t count = cancel(impl, ec); impl.expiry = expiry_time; ec = boost::system::error_code(); return count; } // Set the expiry time for the timer relative to now. std::size_t expires_after(implementation_type& impl, const duration_type& expiry_time, boost::system::error_code& ec) { return expires_at(impl, Time_Traits::add(Time_Traits::now(), expiry_time), ec); } // Set the expiry time for the timer relative to now. std::size_t expires_from_now(implementation_type& impl, const duration_type& expiry_time, boost::system::error_code& ec) { return expires_at(impl, Time_Traits::add(Time_Traits::now(), expiry_time), ec); } // Perform a blocking wait on the timer. void wait(implementation_type& impl, boost::system::error_code& ec) { time_type now = Time_Traits::now(); ec = boost::system::error_code(); while (Time_Traits::less_than(now, impl.expiry) && !ec) { this->do_wait(Time_Traits::to_posix_duration( Time_Traits::subtract(impl.expiry, now)), ec); now = Time_Traits::now(); } } // Start an asynchronous wait on the timer. template <typename Handler, typename IoExecutor> void async_wait(implementation_type& impl, Handler& handler, const IoExecutor& io_ex) { // Allocate and construct an operation to wrap the handler. typedef wait_handler<Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(handler, io_ex); impl.might_have_pending_waits = true; BOOST_ASIO_HANDLER_CREATION((scheduler_.context(), p.p, "deadline_timer", &impl, 0, "async_wait")); scheduler_.schedule_timer(timer_queue_, impl.expiry, impl.timer_data, p.p); p.v = p.p = 0; } private: // Helper function to wait given a duration type. The duration type should // either be of type boost::posix_time::time_duration, or implement the // required subset of its interface. template <typename Duration> void do_wait(const Duration& timeout, boost::system::error_code& ec) { #if defined(BOOST_ASIO_WINDOWS_RUNTIME) std::this_thread::sleep_for( std::chrono::seconds(timeout.total_seconds()) + std::chrono::microseconds(timeout.total_microseconds())); ec = boost::system::error_code(); #else // defined(BOOST_ASIO_WINDOWS_RUNTIME) ::timeval tv; tv.tv_sec = timeout.total_seconds(); tv.tv_usec = timeout.total_microseconds() % 1000000; socket_ops::select(0, 0, 0, 0, &tv, ec); #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) } // The queue of timers. timer_queue<Time_Traits> timer_queue_; // The object that schedules and executes timers. Usually a reactor. timer_scheduler& scheduler_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_DEADLINE_TIMER_SERVICE_HPP PK��h!\� oL��reactive_socket_recvfrom_op.hppnu��[��// // detail/reactive_socket_recvfrom_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_REACTIVE_SOCKET_RECVFROM_OP_HPP #define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECVFROM_OP_HPP #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/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename MutableBufferSequence, typename Endpoint> class reactive_socket_recvfrom_op_base : public reactor_op { public: reactive_socket_recvfrom_op_base(const boost::system::error_code& success_ec, socket_type socket, int protocol_type, const MutableBufferSequence& buffers, Endpoint& endpoint, socket_base::message_flags flags, func_type complete_func) : reactor_op(success_ec, &reactive_socket_recvfrom_op_base::do_perform, complete_func), socket_(socket), protocol_type_(protocol_type), buffers_(buffers), sender_endpoint_(endpoint), flags_(flags) { } static status do_perform(reactor_op base) { reactive_socket_recvfrom_op_base* o( static_cast<reactive_socket_recvfrom_op_base>(base)); typedef buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence> bufs_type; std::size_t addr_len = o->sender_endpoint_.capacity(); status result; if (bufs_type::is_single_buffer) { result = socket_ops::non_blocking_recvfrom1( o->socket_, bufs_type::first(o->buffers_).data(), bufs_type::first(o->buffers_).size(), o->flags_, o->sender_endpoint_.data(), &addr_len, o->ec_, o->bytes_transferred_) ? done : not_done; } else { bufs_type bufs(o->buffers_); result = socket_ops::non_blocking_recvfrom(o->socket_, bufs.buffers(), bufs.count(), o->flags_, o->sender_endpoint_.data(), &addr_len, o->ec_, o->bytes_transferred_) ? done : not_done; } if (result && !o->ec_) o->sender_endpoint_.resize(addr_len); BOOST_ASIO_HANDLER_REACTOR_OPERATION((o, "non_blocking_recvfrom", o->ec_, o->bytes_transferred_)); return result; } private: socket_type socket_; int protocol_type_; MutableBufferSequence buffers_; Endpoint& sender_endpoint_; socket_base::message_flags flags_; }; template <typename MutableBufferSequence, typename Endpoint, typename Handler, typename IoExecutor> class reactive_socket_recvfrom_op : public reactive_socket_recvfrom_op_base<MutableBufferSequence, Endpoint> { public: BOOST_ASIO_DEFINE_HANDLER_PTR(reactive_socket_recvfrom_op); reactive_socket_recvfrom_op(const boost::system::error_code& success_ec, socket_type socket, int protocol_type, const MutableBufferSequence& buffers, Endpoint& endpoint, socket_base::message_flags flags, Handler& handler, const IoExecutor& io_ex) : reactive_socket_recvfrom_op_base<MutableBufferSequence, Endpoint>( success_ec, socket, protocol_type, buffers, endpoint, flags, &reactive_socket_recvfrom_op::do_complete), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static void do_complete(void* owner, operation* base, const boost::system::error_code& /ec/, std::size_t /bytes_transferred/) { // Take ownership of the handler object. reactive_socket_recvfrom_op* o( static_cast<reactive_socket_recvfrom_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, o->ec_, o->bytes_transferred_); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECVFROM_OP_HPP PK��h!\b, ��io_object_impl.hppnu��[��// // io_object_impl.hpp // ~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IO_OBJECT_IMPL_HPP #define BOOST_ASIO_DETAIL_IO_OBJECT_IMPL_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <new> #include <boost/asio/detail/config.hpp> #include <boost/asio/detail/type_traits.hpp> #include <boost/asio/execution/executor.hpp> #include <boost/asio/execution/context.hpp> #include <boost/asio/io_context.hpp> #include <boost/asio/query.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename IoObjectService, typename Executor = io_context::executor_type> class io_object_impl { public: // The type of the service that will be used to provide I/O operations. typedef IoObjectService service_type; // The underlying implementation type of I/O object. typedef typename service_type::implementation_type implementation_type; // The type of the executor associated with the object. typedef Executor executor_type; // Construct an I/O object using an executor. explicit io_object_impl(const executor_type& ex) : service_(&boost::asio::use_service<IoObjectService>( io_object_impl::get_context(ex))), executor_(ex) { service_->construct(implementation_); } // Construct an I/O object using an execution context. template <typename ExecutionContext> explicit io_object_impl(ExecutionContext& context, typename enable_if<is_convertible< ExecutionContext&, execution_context&>::value>::type* = 0) : service_(&boost::asio::use_service<IoObjectService>(context)), executor_(context.get_executor()) { service_->construct(implementation_); } #if defined(BOOST_ASIO_HAS_MOVE) // Move-construct an I/O object. io_object_impl(io_object_impl&& other) : service_(&other.get_service()), executor_(other.get_executor()) { service_->move_construct(implementation_, other.implementation_); } // Perform a converting move-construction of an I/O object. template <typename IoObjectService1, typename Executor1> io_object_impl(io_object_impl<IoObjectService1, Executor1>&& other) : service_(&boost::asio::use_service<IoObjectService>( io_object_impl::get_context(other.get_executor()))), executor_(other.get_executor()) { service_->converting_move_construct(implementation_, other.get_service(), other.get_implementation()); } #endif // defined(BOOST_ASIO_HAS_MOVE) // Destructor. ~io_object_impl() { service_->destroy(implementation_); } #if defined(BOOST_ASIO_HAS_MOVE) // Move-assign an I/O object. io_object_impl& operator=(io_object_impl&& other) { if (this != &other) { service_->move_assign(implementation_, other.service_, other.implementation_); executor_.~executor_type(); new (&executor_) executor_type(other.executor_); service_ = other.service_; } return this; } #endif // defined(BOOST_ASIO_HAS_MOVE) // Get the executor associated with the object. const executor_type& get_executor() BOOST_ASIO_NOEXCEPT { return executor_; } // Get the service associated with the I/O object. service_type& get_service() { return service_; } // Get the service associated with the I/O object. const service_type& get_service() const { return service_; } // Get the underlying implementation of the I/O object. implementation_type& get_implementation() { return implementation_; } // Get the underlying implementation of the I/O object. const implementation_type& get_implementation() const { return implementation_; } private: // Helper function to get an executor's context. template <typename T> static execution_context& get_context(const T& t, typename enable_if<execution::is_executor<T>::value>::type* = 0) { return boost::asio::query(t, execution::context); } // Helper function to get an executor's context. template <typename T> static execution_context& get_context(const T& t, typename enable_if<!execution::is_executor<T>::value>::type* = 0) { return t.context(); } // Disallow copying and copy assignment. io_object_impl(const io_object_impl&); io_object_impl& operator=(const io_object_impl&); // The service associated with the I/O object. service_type* service_; // The underlying implementation of the I/O object. implementation_type implementation_; // The associated executor. executor_type executor_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_IO_OBJECT_IMPL_HPP PK��h!\��pRz ��z �� reactive_serial_port_service.hppnu��[��// // detail/reactive_serial_port_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.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_DETAIL_REACTIVE_SERIAL_PORT_SERVICE_HPP #define BOOST_ASIO_DETAIL_REACTIVE_SERIAL_PORT_SERVICE_HPP #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_HAS_SERIAL_PORT) #if !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) #include <string> #include <boost/asio/error.hpp> #include <boost/asio/execution_context.hpp> #include <boost/asio/serial_port_base.hpp> #include <boost/asio/detail/descriptor_ops.hpp> #include <boost/asio/detail/reactive_descriptor_service.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { // Extend reactive_descriptor_service to provide serial port support. class reactive_serial_port_service : public execution_context_service_base<reactive_serial_port_service> { public: // The native type of a serial port. typedef reactive_descriptor_service::native_handle_type native_handle_type; // The implementation type of the serial port. typedef reactive_descriptor_service::implementation_type implementation_type; BOOST_ASIO_DECL reactive_serial_port_service(execution_context& context); // Destroy all user-defined handler objects owned by the service. BOOST_ASIO_DECL void shutdown(); // Construct a new serial port implementation. void construct(implementation_type& impl) { descriptor_service_.construct(impl); } // Move-construct a new serial port implementation. void move_construct(implementation_type& impl, implementation_type& other_impl) { descriptor_service_.move_construct(impl, other_impl); } // Move-assign from another serial port implementation. void move_assign(implementation_type& impl, reactive_serial_port_service& other_service, implementation_type& other_impl) { descriptor_service_.move_assign(impl, other_service.descriptor_service_, other_impl); } // Destroy a serial port implementation. void destroy(implementation_type& impl) { descriptor_service_.destroy(impl); } // Open the serial port using the specified device name. BOOST_ASIO_DECL boost::system::error_code open(implementation_type& impl, const std::string& device, boost::system::error_code& ec); // Assign a native descriptor to a serial port implementation. boost::system::error_code assign(implementation_type& impl, const native_handle_type& native_descriptor, boost::system::error_code& ec) { return descriptor_service_.assign(impl, native_descriptor, ec); } // Determine whether the serial port is open. bool is_open(const implementation_type& impl) const { return descriptor_service_.is_open(impl); } // Destroy a serial port implementation. boost::system::error_code close(implementation_type& impl, boost::system::error_code& ec) { return descriptor_service_.close(impl, ec); } // Get the native serial port representation. native_handle_type native_handle(implementation_type& impl) { return descriptor_service_.native_handle(impl); } // Cancel all operations associated with the serial port. boost::system::error_code cancel(implementation_type& impl, boost::system::error_code& ec) { return descriptor_service_.cancel(impl, ec); } // Set an option on the serial port. template <typename SettableSerialPortOption> boost::system::error_code set_option(implementation_type& impl, const SettableSerialPortOption& option, boost::system::error_code& ec) { return do_set_option(impl, &reactive_serial_port_service::store_option<SettableSerialPortOption>, &option, ec); } // Get an option from the serial port. template <typename GettableSerialPortOption> boost::system::error_code get_option(const implementation_type& impl, GettableSerialPortOption& option, boost::system::error_code& ec) const { return do_get_option(impl, &reactive_serial_port_service::load_option<GettableSerialPortOption>, &option, ec); } // Send a break sequence to the serial port. boost::system::error_code send_break(implementation_type& impl, boost::system::error_code& ec) { int result = ::tcsendbreak(descriptor_service_.native_handle(impl), 0); descriptor_ops::get_last_error(ec, result < 0); return ec; } // Write the given data. Returns the number of bytes sent. template <typename ConstBufferSequence> size_t write_some(implementation_type& impl, const ConstBufferSequence& buffers, boost::system::error_code& ec) { return descriptor_service_.write_some(impl, buffers, ec); } // Start an asynchronous write. The data being written must be valid for the // lifetime of the asynchronous operation. template <typename ConstBufferSequence, typename Handler, typename IoExecutor> void async_write_some(implementation_type& impl, const ConstBufferSequence& buffers, Handler& handler, const IoExecutor& io_ex) { descriptor_service_.async_write_some(impl, buffers, handler, io_ex); } // Read some data. Returns the number of bytes received. template <typename MutableBufferSequence> size_t read_some(implementation_type& impl, const MutableBufferSequence& buffers, boost::system::error_code& ec) { return descriptor_service_.read_some(impl, buffers, ec); } // Start an asynchronous read. The buffer for the data being received must be // valid for the lifetime of the asynchronous operation. template <typename MutableBufferSequence, typename Handler, typename IoExecutor> void async_read_some(implementation_type& impl, const MutableBufferSequence& buffers, Handler& handler, const IoExecutor& io_ex) { descriptor_service_.async_read_some(impl, buffers, handler, io_ex); } private: // Function pointer type for storing a serial port option. typedef boost::system::error_code (store_function_type)( const void, termios&, boost::system::error_code&); // Helper function template to store a serial port option. template <typename SettableSerialPortOption> static boost::system::error_code store_option(const void* option, termios& storage, boost::system::error_code& ec) { static_cast<const SettableSerialPortOption>(option)->store(storage, ec); return ec; } // Helper function to set a serial port option. BOOST_ASIO_DECL boost::system::error_code do_set_option( implementation_type& impl, store_function_type store, const void option, boost::system::error_code& ec); // Function pointer type for loading a serial port option. typedef boost::system::error_code (load_function_type)( void, const termios&, boost::system::error_code&); // Helper function template to load a serial port option. template <typename GettableSerialPortOption> static boost::system::error_code load_option(void* option, const termios& storage, boost::system::error_code& ec) { static_cast<GettableSerialPortOption>(option)->load(storage, ec); return ec; } // Helper function to get a serial port option. BOOST_ASIO_DECL boost::system::error_code do_get_option( const implementation_type& impl, load_function_type load, void option, boost::system::error_code& ec) const; // The implementation used for initiating asynchronous operations. reactive_descriptor_service descriptor_service_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/reactive_serial_port_service.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) #endif // defined(BOOST_ASIO_HAS_SERIAL_PORT) #endif // BOOST_ASIO_DETAIL_REACTIVE_SERIAL_PORT_SERVICE_HPP PK��h!\�,v��reactive_socket_recvmsg_op.hppnu��[��// // detail/reactive_socket_recvmsg_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_REACTIVE_SOCKET_RECVMSG_OP_HPP #define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECVMSG_OP_HPP #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/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/socket_base.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename MutableBufferSequence> class reactive_socket_recvmsg_op_base : public reactor_op { public: reactive_socket_recvmsg_op_base(const boost::system::error_code& success_ec, socket_type socket, const MutableBufferSequence& buffers, socket_base::message_flags in_flags, socket_base::message_flags& out_flags, func_type complete_func) : reactor_op(success_ec, &reactive_socket_recvmsg_op_base::do_perform, complete_func), socket_(socket), buffers_(buffers), in_flags_(in_flags), out_flags_(out_flags) { } static status do_perform(reactor_op* base) { reactive_socket_recvmsg_op_base* o( static_cast<reactive_socket_recvmsg_op_base>(base)); buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence> bufs(o->buffers_); status result = socket_ops::non_blocking_recvmsg(o->socket_, bufs.buffers(), bufs.count(), o->in_flags_, o->out_flags_, o->ec_, o->bytes_transferred_) ? done : not_done; BOOST_ASIO_HANDLER_REACTOR_OPERATION((o, "non_blocking_recvmsg", o->ec_, o->bytes_transferred_)); return result; } private: socket_type socket_; MutableBufferSequence buffers_; socket_base::message_flags in_flags_; socket_base::message_flags& out_flags_; }; template <typename MutableBufferSequence, typename Handler, typename IoExecutor> class reactive_socket_recvmsg_op : public reactive_socket_recvmsg_op_base<MutableBufferSequence> { public: BOOST_ASIO_DEFINE_HANDLER_PTR(reactive_socket_recvmsg_op); reactive_socket_recvmsg_op(const boost::system::error_code& success_ec, socket_type socket, const MutableBufferSequence& buffers, socket_base::message_flags in_flags, socket_base::message_flags& out_flags, Handler& handler, const IoExecutor& io_ex) : reactive_socket_recvmsg_op_base<MutableBufferSequence>( success_ec, socket, buffers, in_flags, out_flags, &reactive_socket_recvmsg_op::do_complete), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static void do_complete(void* owner, operation* base, const boost::system::error_code& /ec/, std::size_t /bytes_transferred/) { // Take ownership of the handler object. reactive_socket_recvmsg_op* o( static_cast<reactive_socket_recvmsg_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, o->ec_, o->bytes_transferred_); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_RECVMSG_OP_HPP PK��h!\��v�[��[�� win_iocp_socket_service_base.hppnu��[��// // detail/win_iocp_socket_service_base.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_IOCP_SOCKET_SERVICE_BASE_HPP #define BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_SERVICE_BASE_HPP #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_HAS_IOCP) #include <boost/asio/error.hpp> #include <boost/asio/execution_context.hpp> #include <boost/asio/socket_base.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/mutex.hpp> #include <boost/asio/detail/operation.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/select_reactor.hpp> #include <boost/asio/detail/socket_holder.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/win_iocp_io_context.hpp> #include <boost/asio/detail/win_iocp_null_buffers_op.hpp> #include <boost/asio/detail/win_iocp_socket_connect_op.hpp> #include <boost/asio/detail/win_iocp_socket_send_op.hpp> #include <boost/asio/detail/win_iocp_socket_recv_op.hpp> #include <boost/asio/detail/win_iocp_socket_recvmsg_op.hpp> #include <boost/asio/detail/win_iocp_wait_op.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class win_iocp_socket_service_base { public: // The implementation type of the socket. struct base_implementation_type { // The native socket representation. socket_type socket_; // The current state of the socket. socket_ops::state_type state_; // We use a shared pointer as a cancellation token here to work around the // broken Windows support for cancellation. MSDN says that when you call // closesocket any outstanding WSARecv or WSASend operations will complete // with the error ERROR_OPERATION_ABORTED. In practice they complete with // ERROR_NETNAME_DELETED, which means you can't tell the difference between // a local cancellation and the socket being hard-closed by the peer. socket_ops::shared_cancel_token_type cancel_token_; // Per-descriptor data used by the reactor. select_reactor::per_descriptor_data reactor_data_; #if defined(BOOST_ASIO_ENABLE_CANCELIO) // The ID of the thread from which it is safe to cancel asynchronous // operations. 0 means no asynchronous operations have been started yet. // ~0 means asynchronous operations have been started from more than one // thread, and cancellation is not supported for the socket. DWORD safe_cancellation_thread_id_; #endif // defined(BOOST_ASIO_ENABLE_CANCELIO) // Pointers to adjacent socket implementations in linked list. base_implementation_type* next_; base_implementation_type* prev_; }; // Constructor. BOOST_ASIO_DECL win_iocp_socket_service_base(execution_context& context); // Destroy all user-defined handler objects owned by the service. BOOST_ASIO_DECL void base_shutdown(); // Construct a new socket implementation. BOOST_ASIO_DECL void construct(base_implementation_type& impl); // Move-construct a new socket implementation. BOOST_ASIO_DECL void base_move_construct(base_implementation_type& impl, base_implementation_type& other_impl) BOOST_ASIO_NOEXCEPT; // Move-assign from another socket implementation. BOOST_ASIO_DECL void base_move_assign(base_implementation_type& impl, win_iocp_socket_service_base& other_service, base_implementation_type& other_impl); // Destroy a socket implementation. BOOST_ASIO_DECL void destroy(base_implementation_type& impl); // Determine whether the socket is open. bool is_open(const base_implementation_type& impl) const { return impl.socket_ != invalid_socket; } // Destroy a socket implementation. BOOST_ASIO_DECL boost::system::error_code close( base_implementation_type& impl, boost::system::error_code& ec); // Release ownership of the socket. BOOST_ASIO_DECL socket_type release( base_implementation_type& impl, boost::system::error_code& ec); // Cancel all operations associated with the socket. BOOST_ASIO_DECL boost::system::error_code cancel( base_implementation_type& impl, boost::system::error_code& ec); // Determine whether the socket is at the out-of-band data mark. bool at_mark(const base_implementation_type& impl, boost::system::error_code& ec) const { return socket_ops::sockatmark(impl.socket_, ec); } // Determine the number of bytes available for reading. std::size_t available(const base_implementation_type& impl, boost::system::error_code& ec) const { return socket_ops::available(impl.socket_, ec); } // Place the socket into the state where it will listen for new connections. boost::system::error_code listen(base_implementation_type& impl, int backlog, boost::system::error_code& ec) { socket_ops::listen(impl.socket_, backlog, ec); return ec; } // Perform an IO control command on the socket. template <typename IO_Control_Command> boost::system::error_code io_control(base_implementation_type& impl, IO_Control_Command& command, boost::system::error_code& ec) { socket_ops::ioctl(impl.socket_, impl.state_, command.name(), static_cast<ioctl_arg_type>(command.data()), ec); return ec; } // Gets the non-blocking mode of the socket. bool non_blocking(const base_implementation_type& impl) const { return (impl.state_ & socket_ops::user_set_non_blocking) != 0; } // Sets the non-blocking mode of the socket. boost::system::error_code non_blocking(base_implementation_type& impl, bool mode, boost::system::error_code& ec) { socket_ops::set_user_non_blocking(impl.socket_, impl.state_, mode, ec); return ec; } // Gets the non-blocking mode of the native socket implementation. bool native_non_blocking(const base_implementation_type& impl) const { return (impl.state_ & socket_ops::internal_non_blocking) != 0; } // Sets the non-blocking mode of the native socket implementation. boost::system::error_code native_non_blocking(base_implementation_type& impl, bool mode, boost::system::error_code& ec) { socket_ops::set_internal_non_blocking(impl.socket_, impl.state_, mode, ec); return ec; } // Wait for the socket to become ready to read, ready to write, or to have // pending error conditions. boost::system::error_code wait(base_implementation_type& impl, socket_base::wait_type w, boost::system::error_code& ec) { switch (w) { case socket_base::wait_read: socket_ops::poll_read(impl.socket_, impl.state_, -1, ec); break; case socket_base::wait_write: socket_ops::poll_write(impl.socket_, impl.state_, -1, ec); break; case socket_base::wait_error: socket_ops::poll_error(impl.socket_, impl.state_, -1, ec); break; default: ec = boost::asio::error::invalid_argument; break; } return ec; } // Asynchronously wait for the socket to become ready to read, ready to // write, or to have pending error conditions. template <typename Handler, typename IoExecutor> void async_wait(base_implementation_type& impl, socket_base::wait_type w, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef win_iocp_wait_op<Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(impl.cancel_token_, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((context_, p.p, "socket", &impl, impl.socket_, "async_wait")); switch (w) { case socket_base::wait_read: start_null_buffers_receive_op(impl, 0, p.p); break; case socket_base::wait_write: start_reactor_op(impl, select_reactor::write_op, p.p); break; case socket_base::wait_error: start_reactor_op(impl, select_reactor::except_op, p.p); break; default: p.p->ec_ = boost::asio::error::invalid_argument; iocp_service_.post_immediate_completion(p.p, is_continuation); break; } p.v = p.p = 0; } // Send the given data to the peer. Returns the number of bytes sent. template <typename ConstBufferSequence> size_t send(base_implementation_type& impl, const ConstBufferSequence& buffers, socket_base::message_flags flags, boost::system::error_code& ec) { buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence> bufs(buffers); return socket_ops::sync_send(impl.socket_, impl.state_, bufs.buffers(), bufs.count(), flags, bufs.all_empty(), ec); } // Wait until data can be sent without blocking. size_t send(base_implementation_type& impl, const null_buffers&, socket_base::message_flags, boost::system::error_code& ec) { // Wait for socket to become ready. socket_ops::poll_write(impl.socket_, impl.state_, -1, ec); return 0; } // Start an asynchronous send. The data being sent must be valid for the // lifetime of the asynchronous operation. template <typename ConstBufferSequence, typename Handler, typename IoExecutor> void async_send(base_implementation_type& impl, const ConstBufferSequence& buffers, socket_base::message_flags flags, Handler& handler, const IoExecutor& io_ex) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_socket_send_op< ConstBufferSequence, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(impl.cancel_token_, buffers, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((context_, p.p, "socket", &impl, impl.socket_, "async_send")); buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence> bufs(buffers); start_send_op(impl, bufs.buffers(), bufs.count(), flags, (impl.state_ & socket_ops::stream_oriented) != 0 && bufs.all_empty(), p.p); p.v = p.p = 0; } // Start an asynchronous wait until data can be sent without blocking. template <typename Handler, typename IoExecutor> void async_send(base_implementation_type& impl, const null_buffers&, socket_base::message_flags, Handler& handler, const IoExecutor& io_ex) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_null_buffers_op<Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(impl.cancel_token_, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((context_, p.p, "socket", &impl, impl.socket_, "async_send(null_buffers)")); start_reactor_op(impl, select_reactor::write_op, p.p); p.v = p.p = 0; } // Receive some data from the peer. Returns the number of bytes received. template <typename MutableBufferSequence> size_t receive(base_implementation_type& impl, const MutableBufferSequence& buffers, socket_base::message_flags flags, boost::system::error_code& ec) { buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence> bufs(buffers); return socket_ops::sync_recv(impl.socket_, impl.state_, bufs.buffers(), bufs.count(), flags, bufs.all_empty(), ec); } // Wait until data can be received without blocking. size_t receive(base_implementation_type& impl, const null_buffers&, socket_base::message_flags, boost::system::error_code& ec) { // Wait for socket to become ready. socket_ops::poll_read(impl.socket_, impl.state_, -1, ec); return 0; } // Start an asynchronous receive. The buffer for the data being received // must be valid for the lifetime of the asynchronous operation. template <typename MutableBufferSequence, typename Handler, typename IoExecutor> void async_receive(base_implementation_type& impl, const MutableBufferSequence& buffers, socket_base::message_flags flags, Handler& handler, const IoExecutor& io_ex) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_socket_recv_op< MutableBufferSequence, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(impl.state_, impl.cancel_token_, buffers, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((context_, p.p, "socket", &impl, impl.socket_, "async_receive")); buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence> bufs(buffers); start_receive_op(impl, bufs.buffers(), bufs.count(), flags, (impl.state_ & socket_ops::stream_oriented) != 0 && bufs.all_empty(), p.p); p.v = p.p = 0; } // Wait until data can be received without blocking. template <typename Handler, typename IoExecutor> void async_receive(base_implementation_type& impl, const null_buffers&, socket_base::message_flags flags, Handler& handler, const IoExecutor& io_ex) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_null_buffers_op<Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(impl.cancel_token_, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((context_, p.p, "socket", &impl, impl.socket_, "async_receive(null_buffers)")); start_null_buffers_receive_op(impl, flags, p.p); p.v = p.p = 0; } // Receive some data with associated flags. Returns the number of bytes // received. template <typename MutableBufferSequence> size_t receive_with_flags(base_implementation_type& impl, const MutableBufferSequence& buffers, socket_base::message_flags in_flags, socket_base::message_flags& out_flags, boost::system::error_code& ec) { buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence> bufs(buffers); return socket_ops::sync_recvmsg(impl.socket_, impl.state_, bufs.buffers(), bufs.count(), in_flags, out_flags, ec); } // Wait until data can be received without blocking. size_t receive_with_flags(base_implementation_type& impl, const null_buffers&, socket_base::message_flags, socket_base::message_flags& out_flags, boost::system::error_code& ec) { // Wait for socket to become ready. socket_ops::poll_read(impl.socket_, impl.state_, -1, ec); // Clear out_flags, since we cannot give it any other sensible value when // performing a null_buffers operation. out_flags = 0; return 0; } // Start an asynchronous receive. The buffer for the data being received // must be valid for the lifetime of the asynchronous operation. template <typename MutableBufferSequence, typename Handler, typename IoExecutor> void async_receive_with_flags(base_implementation_type& impl, const MutableBufferSequence& buffers, socket_base::message_flags in_flags, socket_base::message_flags& out_flags, Handler& handler, const IoExecutor& io_ex) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_socket_recvmsg_op< MutableBufferSequence, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(impl.cancel_token_, buffers, out_flags, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((context_, p.p, "socket", &impl, impl.socket_, "async_receive_with_flags")); buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence> bufs(buffers); start_receive_op(impl, bufs.buffers(), bufs.count(), in_flags, false, p.p); p.v = p.p = 0; } // Wait until data can be received without blocking. template <typename Handler, typename IoExecutor> void async_receive_with_flags(base_implementation_type& impl, const null_buffers&, socket_base::message_flags in_flags, socket_base::message_flags& out_flags, Handler& handler, const IoExecutor& io_ex) { // Allocate and construct an operation to wrap the handler. typedef win_iocp_null_buffers_op<Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(impl.cancel_token_, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((context_, p.p, "socket", &impl, impl.socket_, "async_receive_with_flags(null_buffers)")); // Reset out_flags since it can be given no sensible value at this time. out_flags = 0; start_null_buffers_receive_op(impl, in_flags, p.p); p.v = p.p = 0; } // Helper function to restart an asynchronous accept operation. BOOST_ASIO_DECL void restart_accept_op(socket_type s, socket_holder& new_socket, int family, int type, int protocol, void* output_buffer, DWORD address_length, operation* op); protected: // Open a new socket implementation. BOOST_ASIO_DECL boost::system::error_code do_open( base_implementation_type& impl, int family, int type, int protocol, boost::system::error_code& ec); // Assign a native socket to a socket implementation. BOOST_ASIO_DECL boost::system::error_code do_assign( base_implementation_type& impl, int type, socket_type native_socket, boost::system::error_code& ec); // Helper function to start an asynchronous send operation. BOOST_ASIO_DECL void start_send_op(base_implementation_type& impl, WSABUF* buffers, std::size_t buffer_count, socket_base::message_flags flags, bool noop, operation* op); // Helper function to start an asynchronous send_to operation. BOOST_ASIO_DECL void start_send_to_op(base_implementation_type& impl, WSABUF* buffers, std::size_t buffer_count, const socket_addr_type* addr, int addrlen, socket_base::message_flags flags, operation* op); // Helper function to start an asynchronous receive operation. BOOST_ASIO_DECL void start_receive_op(base_implementation_type& impl, WSABUF* buffers, std::size_t buffer_count, socket_base::message_flags flags, bool noop, operation* op); // Helper function to start an asynchronous null_buffers receive operation. BOOST_ASIO_DECL void start_null_buffers_receive_op( base_implementation_type& impl, socket_base::message_flags flags, reactor_op* op); // Helper function to start an asynchronous receive_from operation. BOOST_ASIO_DECL void start_receive_from_op(base_implementation_type& impl, WSABUF* buffers, std::size_t buffer_count, socket_addr_type* addr, socket_base::message_flags flags, int* addrlen, operation* op); // Helper function to start an asynchronous accept operation. BOOST_ASIO_DECL void start_accept_op(base_implementation_type& impl, bool peer_is_open, socket_holder& new_socket, int family, int type, int protocol, void* output_buffer, DWORD address_length, operation* op); // Start an asynchronous read or write operation using the reactor. BOOST_ASIO_DECL void start_reactor_op(base_implementation_type& impl, int op_type, reactor_op* op); // Start the asynchronous connect operation using the reactor. BOOST_ASIO_DECL void start_connect_op(base_implementation_type& impl, int family, int type, const socket_addr_type* remote_addr, std::size_t remote_addrlen, win_iocp_socket_connect_op_base* op); // Helper function to close a socket when the associated object is being // destroyed. BOOST_ASIO_DECL void close_for_destruction(base_implementation_type& impl); // Update the ID of the thread from which cancellation is safe. BOOST_ASIO_DECL void update_cancellation_thread_id( base_implementation_type& impl); // Helper function to get the reactor. If no reactor has been created yet, a // new one is obtained from the execution context and a pointer to it is // cached in this service. BOOST_ASIO_DECL select_reactor& get_reactor(); // The type of a ConnectEx function pointer, as old SDKs may not provide it. typedef BOOL (PASCAL connect_ex_fn)(SOCKET, const socket_addr_type, int, void, DWORD, DWORD, OVERLAPPED); // Helper function to get the ConnectEx pointer. If no ConnectEx pointer has // been obtained yet, one is obtained using WSAIoctl and the pointer is // cached. Returns a null pointer if ConnectEx is not available. BOOST_ASIO_DECL connect_ex_fn get_connect_ex( base_implementation_type& impl, int type); // The type of a NtSetInformationFile function pointer. typedef LONG (NTAPI nt_set_info_fn)(HANDLE, ULONG_PTR, void, ULONG, ULONG); // Helper function to get the NtSetInformationFile function pointer. If no // NtSetInformationFile pointer has been obtained yet, one is obtained using // GetProcAddress and the pointer is cached. Returns a null pointer if // NtSetInformationFile is not available. BOOST_ASIO_DECL nt_set_info_fn get_nt_set_info(); // Helper function to emulate InterlockedCompareExchangePointer functionality // for: // - very old Platform SDKs; and // - platform SDKs where MSVC's /Wp64 option causes spurious warnings. BOOST_ASIO_DECL void* interlocked_compare_exchange_pointer( void** dest, void* exch, void* cmp); // Helper function to emulate InterlockedExchangePointer functionality for: // - very old Platform SDKs; and // - platform SDKs where MSVC's /Wp64 option causes spurious warnings. BOOST_ASIO_DECL void* interlocked_exchange_pointer(void** dest, void* val); // The execution context used to obtain the reactor, if required. execution_context& context_; // The IOCP service used for running asynchronous operations and dispatching // handlers. win_iocp_io_context& iocp_service_; // The reactor used for performing connect operations. This object is created // only if needed. select_reactor* reactor_; // Pointer to ConnectEx implementation. void* connect_ex_; // Pointer to NtSetInformationFile implementation. void* nt_set_info_; // Mutex to protect access to the linked list of implementations. boost::asio::detail::mutex mutex_; // The head of a linked list of all implementations. base_implementation_type* impl_list_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/win_iocp_socket_service_base.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_HAS_IOCP) #endif // BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_SERVICE_BASE_HPP PK��h!\i��F4��4��conditionally_enabled_event.hppnu��[��// // detail/conditionally_enabled_event.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_CONDITIONALLY_ENABLED_EVENT_HPP #define BOOST_ASIO_DETAIL_CONDITIONALLY_ENABLED_EVENT_HPP #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/detail/conditionally_enabled_mutex.hpp> #include <boost/asio/detail/event.hpp> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/null_event.hpp> #include <boost/asio/detail/scoped_lock.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { // Mutex adapter used to conditionally enable or disable locking. class conditionally_enabled_event : private noncopyable { public: // Constructor. conditionally_enabled_event() { } // Destructor. ~conditionally_enabled_event() { } // Signal the event. (Retained for backward compatibility.) void signal(conditionally_enabled_mutex::scoped_lock& lock) { if (lock.mutex_.enabled_) event_.signal(lock); } // Signal all waiters. void signal_all(conditionally_enabled_mutex::scoped_lock& lock) { if (lock.mutex_.enabled_) event_.signal_all(lock); } // Unlock the mutex and signal one waiter. void unlock_and_signal_one( conditionally_enabled_mutex::scoped_lock& lock) { if (lock.mutex_.enabled_) event_.unlock_and_signal_one(lock); } // Unlock the mutex and signal one waiter who may destroy us. void unlock_and_signal_one_for_destruction( conditionally_enabled_mutex::scoped_lock& lock) { if (lock.mutex_.enabled_) event_.unlock_and_signal_one(lock); } // If there's a waiter, unlock the mutex and signal it. bool maybe_unlock_and_signal_one( conditionally_enabled_mutex::scoped_lock& lock) { if (lock.mutex_.enabled_) return event_.maybe_unlock_and_signal_one(lock); else return false; } // Reset the event. void clear(conditionally_enabled_mutex::scoped_lock& lock) { if (lock.mutex_.enabled_) event_.clear(lock); } // Wait for the event to become signalled. void wait(conditionally_enabled_mutex::scoped_lock& lock) { if (lock.mutex_.enabled_) event_.wait(lock); else null_event().wait(lock); } // Timed wait for the event to become signalled. bool wait_for_usec( conditionally_enabled_mutex::scoped_lock& lock, long usec) { if (lock.mutex_.enabled_) return event_.wait_for_usec(lock, usec); else return null_event().wait_for_usec(lock, usec); } private: boost::asio::detail::event event_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_CONDITIONALLY_ENABLED_EVENT_HPP PK��h!\�bX��timer_scheduler_fwd.hppnu��[��// // detail/timer_scheduler_fwd.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_TIMER_SCHEDULER_FWD_HPP #define BOOST_ASIO_DETAIL_TIMER_SCHEDULER_FWD_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> namespace boost { namespace asio { namespace detail { #if defined(BOOST_ASIO_WINDOWS_RUNTIME) typedef class winrt_timer_scheduler timer_scheduler; #elif defined(BOOST_ASIO_HAS_IOCP) typedef class win_iocp_io_context timer_scheduler; #elif defined(BOOST_ASIO_HAS_EPOLL) typedef class epoll_reactor timer_scheduler; #elif defined(BOOST_ASIO_HAS_KQUEUE) typedef class kqueue_reactor timer_scheduler; #elif defined(BOOST_ASIO_HAS_DEV_POLL) typedef class dev_poll_reactor timer_scheduler; #else typedef class select_reactor timer_scheduler; #endif } // namespace detail } // namespace asio } // namespace boost #endif // BOOST_ASIO_DETAIL_TIMER_SCHEDULER_FWD_HPP PK��h!\��posix_tss_ptr.hppnu��[��// // detail/posix_tss_ptr.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_POSIX_TSS_PTR_HPP #define BOOST_ASIO_DETAIL_POSIX_TSS_PTR_HPP #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_HAS_PTHREADS) #include <pthread.h> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { // Helper function to create thread-specific storage. BOOST_ASIO_DECL void posix_tss_ptr_create(pthread_key_t& key); template <typename T> class posix_tss_ptr : private noncopyable { public: // Constructor. posix_tss_ptr() { posix_tss_ptr_create(tss_key_); } // Destructor. ~posix_tss_ptr() { ::pthread_key_delete(tss_key_); } // Get the value. operator T() const { return static_cast<T>(::pthread_getspecific(tss_key_)); } // Set the value. void operator=(T* value) { ::pthread_setspecific(tss_key_, value); } private: // Thread-specific storage to allow unlocked access to determine whether a // thread is a member of the pool. pthread_key_t tss_key_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/posix_tss_ptr.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_HAS_PTHREADS) #endif // BOOST_ASIO_DETAIL_POSIX_TSS_PTR_HPP PK��h!\5֎�6��6��conditionally_enabled_mutex.hppnu��[��// // detail/conditionally_enabled_mutex.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_CONDITIONALLY_ENABLED_MUTEX_HPP #define BOOST_ASIO_DETAIL_CONDITIONALLY_ENABLED_MUTEX_HPP #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/detail/mutex.hpp> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/scoped_lock.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { // Mutex adapter used to conditionally enable or disable locking. class conditionally_enabled_mutex : private noncopyable { public: // Helper class to lock and unlock a mutex automatically. class scoped_lock : private noncopyable { public: // Tag type used to distinguish constructors. enum adopt_lock_t { adopt_lock }; // Constructor adopts a lock that is already held. scoped_lock(conditionally_enabled_mutex& m, adopt_lock_t) : mutex_(m), locked_(m.enabled_) { } // Constructor acquires the lock. explicit scoped_lock(conditionally_enabled_mutex& m) : mutex_(m) { if (m.enabled_) { mutex_.mutex_.lock(); locked_ = true; } else locked_ = false; } // Destructor releases the lock. ~scoped_lock() { if (locked_) mutex_.mutex_.unlock(); } // Explicitly acquire the lock. void lock() { if (mutex_.enabled_ && !locked_) { mutex_.mutex_.lock(); locked_ = true; } } // Explicitly release the lock. void unlock() { if (locked_) { mutex_.unlock(); locked_ = false; } } // Test whether the lock is held. bool locked() const { return locked_; } // Get the underlying mutex. boost::asio::detail::mutex& mutex() { return mutex_.mutex_; } private: friend class conditionally_enabled_event; conditionally_enabled_mutex& mutex_; bool locked_; }; // Constructor. explicit conditionally_enabled_mutex(bool enabled) : enabled_(enabled) { } // Destructor. ~conditionally_enabled_mutex() { } // Determine whether locking is enabled. bool enabled() const { return enabled_; } // Lock the mutex. void lock() { if (enabled_) mutex_.lock(); } // Unlock the mutex. void unlock() { if (enabled_) mutex_.unlock(); } private: friend class scoped_lock; friend class conditionally_enabled_event; boost::asio::detail::mutex mutex_; const bool enabled_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_CONDITIONALLY_ENABLED_MUTEX_HPP PK��h!\A��win_iocp_operation.hppnu��[��// // detail/win_iocp_operation.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_IOCP_OPERATION_HPP #define BOOST_ASIO_DETAIL_WIN_IOCP_OPERATION_HPP #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_HAS_IOCP) #include <boost/asio/detail/handler_tracking.hpp> #include <boost/asio/detail/op_queue.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/system/error_code.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class win_iocp_io_context; // Base class for all operations. A function pointer is used instead of virtual // functions to avoid the associated overhead. class win_iocp_operation : public OVERLAPPED BOOST_ASIO_ALSO_INHERIT_TRACKED_HANDLER { public: typedef win_iocp_operation operation_type; void complete(void* owner, const boost::system::error_code& ec, std::size_t bytes_transferred) { func_(owner, this, ec, bytes_transferred); } void destroy() { func_(0, this, boost::system::error_code(), 0); } protected: typedef void (func_type)( void, win_iocp_operation, const boost::system::error_code&, std::size_t); win_iocp_operation(func_type func) : next_(0), func_(func) { reset(); } // Prevents deletion through this type. ~win_iocp_operation() { } void reset() { Internal = 0; InternalHigh = 0; Offset = 0; OffsetHigh = 0; hEvent = 0; ready_ = 0; } private: friend class op_queue_access; friend class win_iocp_io_context; win_iocp_operation next_; func_type func_; long ready_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #endif // BOOST_ASIO_DETAIL_WIN_IOCP_OPERATION_HPP PK��h!\4�Ũ��scoped_ptr.hppnu��[��// // detail/scoped_ptr.hpp // ~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_SCOPED_PTR_HPP #define BOOST_ASIO_DETAIL_SCOPED_PTR_HPP #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/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename T> class scoped_ptr { public: // Constructor. explicit scoped_ptr(T* p = 0) : p_(p) { } // Destructor. ~scoped_ptr() { delete p_; } // Access. T* get() { return p_; } // Access. T* operator->() { return p_; } // Dereference. T& operator() { return p_; } // Reset pointer. void reset(T* p = 0) { delete p_; p_ = p; } // Release ownership of the pointer. T* release() { T* tmp = p_; p_ = 0; return tmp; } private: // Disallow copying and assignment. scoped_ptr(const scoped_ptr&); scoped_ptr& operator=(const scoped_ptr&); T* p_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_SCOPED_PTR_HPP PK��h!\��win_global.hppnu��[��// // detail/win_global.hpp // ~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_GLOBAL_HPP #define BOOST_ASIO_DETAIL_WIN_GLOBAL_HPP #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/detail/static_mutex.hpp> #include <boost/asio/detail/tss_ptr.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename T> struct win_global_impl { // Destructor automatically cleans up the global. ~win_global_impl() { delete ptr_; } static win_global_impl instance_; static static_mutex mutex_; T* ptr_; static tss_ptr<T> tss_ptr_; }; template <typename T> win_global_impl<T> win_global_impl<T>::instance_ = { 0 }; template <typename T> static_mutex win_global_impl<T>::mutex_ = BOOST_ASIO_STATIC_MUTEX_INIT; template <typename T> tss_ptr<T> win_global_impl<T>::tss_ptr_; template <typename T> T& win_global() { if (static_cast<T>(win_global_impl<T>::tss_ptr_) == 0) { win_global_impl<T>::mutex_.init(); static_mutex::scoped_lock lock(win_global_impl<T>::mutex_); if (win_global_impl<T>::instance_.ptr_ == 0) win_global_impl<T>::instance_.ptr_ = new T; win_global_impl<T>::tss_ptr_ = win_global_impl<T>::instance_.ptr_; } return win_global_impl<T>::tss_ptr_; } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_WIN_GLOBAL_HPP PK��h!\�Q��win_object_handle_service.hppnu��[��// // detail/win_object_handle_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2011 Boris Schaeling (boris@highscore.de) // // 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_DETAIL_WIN_OBJECT_HANDLE_SERVICE_HPP #define BOOST_ASIO_DETAIL_WIN_OBJECT_HANDLE_SERVICE_HPP #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_HAS_WINDOWS_OBJECT_HANDLE) #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/wait_handler.hpp> #include <boost/asio/error.hpp> #include <boost/asio/execution_context.hpp> #if defined(BOOST_ASIO_HAS_IOCP) # include <boost/asio/detail/win_iocp_io_context.hpp> #else // defined(BOOST_ASIO_HAS_IOCP) # include <boost/asio/detail/scheduler.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class win_object_handle_service : public execution_context_service_base<win_object_handle_service> { public: // The native type of an object handle. typedef HANDLE native_handle_type; // The implementation type of the object handle. class implementation_type { public: // Default constructor. implementation_type() : handle_(INVALID_HANDLE_VALUE), wait_handle_(INVALID_HANDLE_VALUE), owner_(0), next_(0), prev_(0) { } private: // Only this service will have access to the internal values. friend class win_object_handle_service; // The native object handle representation. May be accessed or modified // without locking the mutex. native_handle_type handle_; // The handle used to unregister the wait operation. The mutex must be // locked when accessing or modifying this member. HANDLE wait_handle_; // The operations waiting on the object handle. If there is a registered // wait then the mutex must be locked when accessing or modifying this // member op_queue<wait_op> op_queue_; // The service instance that owns the object handle implementation. win_object_handle_service* owner_; // Pointers to adjacent handle implementations in linked list. The mutex // must be locked when accessing or modifying these members. implementation_type* next_; implementation_type* prev_; }; // Constructor. BOOST_ASIO_DECL win_object_handle_service(execution_context& context); // Destroy all user-defined handler objects owned by the service. BOOST_ASIO_DECL void shutdown(); // Construct a new handle implementation. BOOST_ASIO_DECL void construct(implementation_type& impl); // Move-construct a new handle implementation. BOOST_ASIO_DECL void move_construct(implementation_type& impl, implementation_type& other_impl); // Move-assign from another handle implementation. BOOST_ASIO_DECL void move_assign(implementation_type& impl, win_object_handle_service& other_service, implementation_type& other_impl); // Destroy a handle implementation. BOOST_ASIO_DECL void destroy(implementation_type& impl); // Assign a native handle to a handle implementation. BOOST_ASIO_DECL boost::system::error_code assign(implementation_type& impl, const native_handle_type& handle, boost::system::error_code& ec); // Determine whether the handle is open. bool is_open(const implementation_type& impl) const { return impl.handle_ != INVALID_HANDLE_VALUE && impl.handle_ != 0; } // Destroy a handle implementation. BOOST_ASIO_DECL boost::system::error_code close(implementation_type& impl, boost::system::error_code& ec); // Get the native handle representation. native_handle_type native_handle(const implementation_type& impl) const { return impl.handle_; } // Cancel all operations associated with the handle. BOOST_ASIO_DECL boost::system::error_code cancel(implementation_type& impl, boost::system::error_code& ec); // Perform a synchronous wait for the object to enter a signalled state. BOOST_ASIO_DECL void wait(implementation_type& impl, boost::system::error_code& ec); /// Start an asynchronous wait. template <typename Handler, typename IoExecutor> void async_wait(implementation_type& impl, Handler& handler, const IoExecutor& io_ex) { // Allocate and construct an operation to wrap the handler. typedef wait_handler<Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(handler, io_ex); BOOST_ASIO_HANDLER_CREATION((scheduler_.context(), p.p, "object_handle", &impl, reinterpret_cast<uintmax_t>(impl.wait_handle_), "async_wait")); start_wait_op(impl, p.p); p.v = p.p = 0; } private: // Helper function to start an asynchronous wait operation. BOOST_ASIO_DECL void start_wait_op(implementation_type& impl, wait_op op); // Helper function to register a wait operation. BOOST_ASIO_DECL void register_wait_callback( implementation_type& impl, mutex::scoped_lock& lock); // Callback function invoked when the registered wait completes. static BOOST_ASIO_DECL VOID CALLBACK wait_callback( PVOID param, BOOLEAN timeout); // The scheduler used to post completions. #if defined(BOOST_ASIO_HAS_IOCP) typedef class win_iocp_io_context scheduler_impl; #else typedef class scheduler scheduler_impl; #endif scheduler_impl& scheduler_; // Mutex to protect access to internal state. mutex mutex_; // The head of a linked list of all implementations. implementation_type* impl_list_; // Flag to indicate that the dispatcher has been shut down. bool shutdown_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/win_object_handle_service.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_HAS_WINDOWS_OBJECT_HANDLE) #endif // BOOST_ASIO_DETAIL_WIN_OBJECT_HANDLE_SERVICE_HPP PK��h!\v\|h��date_time_fwd.hppnu��[��// // detail/date_time_fwd.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_DATE_TIME_FWD_HPP #define BOOST_ASIO_DETAIL_DATE_TIME_FWD_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> namespace boost { namespace date_time { template<class T, class TimeSystem> class base_time; } // namespace date_time namespace posix_time { class ptime; } // namespace posix_time } // namespace boost #endif // BOOST_ASIO_DETAIL_DATE_TIME_FWD_HPP PK��h!\�o�N� �� bulk_executor_op.hppnu��[��// // detail/bulk_executor_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_BULK_EXECUTOR_OP_HPP #define BOOST_ASIO_DETAIL_BULK_EXECUTOR_OP_HPP #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/detail/bind_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/scheduler_operation.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Handler, typename Alloc, typename Operation = scheduler_operation> class bulk_executor_op : public Operation { public: BOOST_ASIO_DEFINE_HANDLER_ALLOCATOR_PTR(bulk_executor_op); template <typename H> bulk_executor_op(BOOST_ASIO_MOVE_ARG(H) h, const Alloc& allocator, std::size_t i) : Operation(&bulk_executor_op::do_complete), handler_(BOOST_ASIO_MOVE_CAST(H)(h)), allocator_(allocator), index_(i) { } static void do_complete(void* owner, Operation* base, const boost::system::error_code& /ec/, std::size_t /bytes_transferred/) { // Take ownership of the handler object. bulk_executor_op* o(static_cast<bulk_executor_op>(base)); Alloc allocator(o->allocator_); ptr p = { detail::addressof(allocator), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder1<Handler, std::size_t> handler(o->handler_, o->index_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN(()); boost_asio_handler_invoke_helpers::invoke(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: Handler handler_; Alloc allocator_; std::size_t index_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_BULK_EXECUTOR_OP_HPP PK��h!\'�_�~��~��old_win_sdk_compat.hppnu��[��// // detail/old_win_sdk_compat.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_OLD_WIN_SDK_COMPAT_HPP #define BOOST_ASIO_DETAIL_OLD_WIN_SDK_COMPAT_HPP #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_WINDOWS) \|\| defined(__CYGWIN__) // Guess whether we are building against on old Platform SDK. #if !defined(IN6ADDR_ANY_INIT) #define BOOST_ASIO_HAS_OLD_WIN_SDK 1 #endif // !defined(IN6ADDR_ANY_INIT) #if defined(BOOST_ASIO_HAS_OLD_WIN_SDK) // Emulation of types that are missing from old Platform SDKs. // // N.B. this emulation is also used if building for a Windows 2000 target with // a recent (i.e. Vista or later) SDK, as the SDK does not provide IPv6 support // in that case. #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { enum { sockaddr_storage_maxsize = 128, // Maximum size. sockaddr_storage_alignsize = (sizeof(__int64)), // Desired alignment. sockaddr_storage_pad1size = (sockaddr_storage_alignsize - sizeof(short)), sockaddr_storage_pad2size = (sockaddr_storage_maxsize - (sizeof(short) + sockaddr_storage_pad1size + sockaddr_storage_alignsize)) }; struct sockaddr_storage_emulation { short ss_family; char __ss_pad1[sockaddr_storage_pad1size]; __int64 __ss_align; char __ss_pad2[sockaddr_storage_pad2size]; }; struct in6_addr_emulation { union { u_char Byte[16]; u_short Word[8]; } u; }; #if !defined(s6_addr) # define _S6_un u # define _S6_u8 Byte # define s6_addr _S6_un._S6_u8 #endif // !defined(s6_addr) struct sockaddr_in6_emulation { short sin6_family; u_short sin6_port; u_long sin6_flowinfo; in6_addr_emulation sin6_addr; u_long sin6_scope_id; }; struct ipv6_mreq_emulation { in6_addr_emulation ipv6mr_multiaddr; unsigned int ipv6mr_interface; }; struct addrinfo_emulation { int ai_flags; int ai_family; int ai_socktype; int ai_protocol; size_t ai_addrlen; char* ai_canonname; sockaddr* ai_addr; addrinfo_emulation* ai_next; }; #if !defined(AI_PASSIVE) # define AI_PASSIVE 0x1 #endif #if !defined(AI_CANONNAME) # define AI_CANONNAME 0x2 #endif #if !defined(AI_NUMERICHOST) # define AI_NUMERICHOST 0x4 #endif #if !defined(EAI_AGAIN) # define EAI_AGAIN WSATRY_AGAIN #endif #if !defined(EAI_BADFLAGS) # define EAI_BADFLAGS WSAEINVAL #endif #if !defined(EAI_FAIL) # define EAI_FAIL WSANO_RECOVERY #endif #if !defined(EAI_FAMILY) # define EAI_FAMILY WSAEAFNOSUPPORT #endif #if !defined(EAI_MEMORY) # define EAI_MEMORY WSA_NOT_ENOUGH_MEMORY #endif #if !defined(EAI_NODATA) # define EAI_NODATA WSANO_DATA #endif #if !defined(EAI_NONAME) # define EAI_NONAME WSAHOST_NOT_FOUND #endif #if !defined(EAI_SERVICE) # define EAI_SERVICE WSATYPE_NOT_FOUND #endif #if !defined(EAI_SOCKTYPE) # define EAI_SOCKTYPE WSAESOCKTNOSUPPORT #endif #if !defined(NI_NOFQDN) # define NI_NOFQDN 0x01 #endif #if !defined(NI_NUMERICHOST) # define NI_NUMERICHOST 0x02 #endif #if !defined(NI_NAMEREQD) # define NI_NAMEREQD 0x04 #endif #if !defined(NI_NUMERICSERV) # define NI_NUMERICSERV 0x08 #endif #if !defined(NI_DGRAM) # define NI_DGRAM 0x10 #endif #if !defined(IPPROTO_IPV6) # define IPPROTO_IPV6 41 #endif #if !defined(IPV6_UNICAST_HOPS) # define IPV6_UNICAST_HOPS 4 #endif #if !defined(IPV6_MULTICAST_IF) # define IPV6_MULTICAST_IF 9 #endif #if !defined(IPV6_MULTICAST_HOPS) # define IPV6_MULTICAST_HOPS 10 #endif #if !defined(IPV6_MULTICAST_LOOP) # define IPV6_MULTICAST_LOOP 11 #endif #if !defined(IPV6_JOIN_GROUP) # define IPV6_JOIN_GROUP 12 #endif #if !defined(IPV6_LEAVE_GROUP) # define IPV6_LEAVE_GROUP 13 #endif } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_OLD_WIN_SDK) // Even newer Platform SDKs that support IPv6 may not define IPV6_V6ONLY. #if !defined(IPV6_V6ONLY) # define IPV6_V6ONLY 27 #endif // Some SDKs (e.g. Windows CE) don't define IPPROTO_ICMPV6. #if !defined(IPPROTO_ICMPV6) # define IPPROTO_ICMPV6 58 #endif #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_OLD_WIN_SDK_COMPAT_HPP PK��h!\�d�;�� future.hppnu��[��// // detail/future.hpp // ~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_FUTURE_HPP #define BOOST_ASIO_DETAIL_FUTURE_HPP #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_HAS_STD_FUTURE) # include <future> // Even though the future header is available, libstdc++ may not implement the // std::future class itself. However, we need to have already included the // future header to reliably test for _GLIBCXX_HAS_GTHREADS. # if defined(__GNUC__) && !defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # if defined(_GLIBCXX_HAS_GTHREADS) # define BOOST_ASIO_HAS_STD_FUTURE_CLASS 1 # endif // defined(_GLIBCXX_HAS_GTHREADS) # else // defined(__GNUC__) && !defined(BOOST_ASIO_HAS_CLANG_LIBCXX) # define BOOST_ASIO_HAS_STD_FUTURE_CLASS 1 # endif // defined(__GNUC__) && !defined(BOOST_ASIO_HAS_CLANG_LIBCXX) #endif // defined(BOOST_ASIO_HAS_STD_FUTURE) #endif // BOOST_ASIO_DETAIL_FUTURE_HPP PK��h!\N�A��win_iocp_null_buffers_op.hppnu��[��// // detail/win_iocp_null_buffers_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_IOCP_NULL_BUFFERS_OP_HPP #define BOOST_ASIO_DETAIL_WIN_IOCP_NULL_BUFFERS_OP_HPP #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_HAS_IOCP) #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Handler, typename IoExecutor> class win_iocp_null_buffers_op : public reactor_op { public: BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_null_buffers_op); win_iocp_null_buffers_op(socket_ops::weak_cancel_token_type cancel_token, Handler& handler, const IoExecutor& io_ex) : reactor_op(boost::system::error_code(), &win_iocp_null_buffers_op::do_perform, &win_iocp_null_buffers_op::do_complete), cancel_token_(cancel_token), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static status do_perform(reactor_op) { return done; } static void do_complete(void owner, operation* base, const boost::system::error_code& result_ec, std::size_t bytes_transferred) { boost::system::error_code ec(result_ec); // Take ownership of the operation object. win_iocp_null_buffers_op* o(static_cast<win_iocp_null_buffers_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); // The reactor may have stored a result in the operation object. if (o->ec_) ec = o->ec_; // Map non-portable errors to their portable counterparts. if (ec.value() == ERROR_NETNAME_DELETED) { if (o->cancel_token_.expired()) ec = boost::asio::error::operation_aborted; else ec = boost::asio::error::connection_reset; } else if (ec.value() == ERROR_PORT_UNREACHABLE) { ec = boost::asio::error::connection_refused; } // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, ec, bytes_transferred); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: socket_ops::weak_cancel_token_type cancel_token_; Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #endif // BOOST_ASIO_DETAIL_WIN_IOCP_NULL_BUFFERS_OP_HPP PK��h!\r��&�8��8��reactive_descriptor_service.hppnu��[��// // detail/reactive_descriptor_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_REACTIVE_DESCRIPTOR_SERVICE_HPP #define BOOST_ASIO_DETAIL_REACTIVE_DESCRIPTOR_SERVICE_HPP #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_WINDOWS) \ && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ && !defined(__CYGWIN__) #include <boost/asio/buffer.hpp> #include <boost/asio/execution_context.hpp> #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/descriptor_ops.hpp> #include <boost/asio/detail/descriptor_read_op.hpp> #include <boost/asio/detail/descriptor_write_op.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/reactive_null_buffers_op.hpp> #include <boost/asio/detail/reactive_wait_op.hpp> #include <boost/asio/detail/reactor.hpp> #include <boost/asio/posix/descriptor_base.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class reactive_descriptor_service : public execution_context_service_base<reactive_descriptor_service> { public: // The native type of a descriptor. typedef int native_handle_type; // The implementation type of the descriptor. class implementation_type : private boost::asio::detail::noncopyable { public: // Default constructor. implementation_type() : descriptor_(-1), state_(0) { } private: // Only this service will have access to the internal values. friend class reactive_descriptor_service; // The native descriptor representation. int descriptor_; // The current state of the descriptor. descriptor_ops::state_type state_; // Per-descriptor data used by the reactor. reactor::per_descriptor_data reactor_data_; }; // Constructor. BOOST_ASIO_DECL reactive_descriptor_service(execution_context& context); // Destroy all user-defined handler objects owned by the service. BOOST_ASIO_DECL void shutdown(); // Construct a new descriptor implementation. BOOST_ASIO_DECL void construct(implementation_type& impl); // Move-construct a new descriptor implementation. BOOST_ASIO_DECL void move_construct(implementation_type& impl, implementation_type& other_impl) BOOST_ASIO_NOEXCEPT; // Move-assign from another descriptor implementation. BOOST_ASIO_DECL void move_assign(implementation_type& impl, reactive_descriptor_service& other_service, implementation_type& other_impl); // Destroy a descriptor implementation. BOOST_ASIO_DECL void destroy(implementation_type& impl); // Assign a native descriptor to a descriptor implementation. BOOST_ASIO_DECL boost::system::error_code assign(implementation_type& impl, const native_handle_type& native_descriptor, boost::system::error_code& ec); // Determine whether the descriptor is open. bool is_open(const implementation_type& impl) const { return impl.descriptor_ != -1; } // Destroy a descriptor implementation. BOOST_ASIO_DECL boost::system::error_code close(implementation_type& impl, boost::system::error_code& ec); // Get the native descriptor representation. native_handle_type native_handle(const implementation_type& impl) const { return impl.descriptor_; } // Release ownership of the native descriptor representation. BOOST_ASIO_DECL native_handle_type release(implementation_type& impl); // Cancel all operations associated with the descriptor. BOOST_ASIO_DECL boost::system::error_code cancel(implementation_type& impl, boost::system::error_code& ec); // Perform an IO control command on the descriptor. template <typename IO_Control_Command> boost::system::error_code io_control(implementation_type& impl, IO_Control_Command& command, boost::system::error_code& ec) { descriptor_ops::ioctl(impl.descriptor_, impl.state_, command.name(), static_cast<ioctl_arg_type>(command.data()), ec); return ec; } // Gets the non-blocking mode of the descriptor. bool non_blocking(const implementation_type& impl) const { return (impl.state_ & descriptor_ops::user_set_non_blocking) != 0; } // Sets the non-blocking mode of the descriptor. boost::system::error_code non_blocking(implementation_type& impl, bool mode, boost::system::error_code& ec) { descriptor_ops::set_user_non_blocking( impl.descriptor_, impl.state_, mode, ec); return ec; } // Gets the non-blocking mode of the native descriptor implementation. bool native_non_blocking(const implementation_type& impl) const { return (impl.state_ & descriptor_ops::internal_non_blocking) != 0; } // Sets the non-blocking mode of the native descriptor implementation. boost::system::error_code native_non_blocking(implementation_type& impl, bool mode, boost::system::error_code& ec) { descriptor_ops::set_internal_non_blocking( impl.descriptor_, impl.state_, mode, ec); return ec; } // Wait for the descriptor to become ready to read, ready to write, or to have // pending error conditions. boost::system::error_code wait(implementation_type& impl, posix::descriptor_base::wait_type w, boost::system::error_code& ec) { switch (w) { case posix::descriptor_base::wait_read: descriptor_ops::poll_read(impl.descriptor_, impl.state_, ec); break; case posix::descriptor_base::wait_write: descriptor_ops::poll_write(impl.descriptor_, impl.state_, ec); break; case posix::descriptor_base::wait_error: descriptor_ops::poll_error(impl.descriptor_, impl.state_, ec); break; default: ec = boost::asio::error::invalid_argument; break; } return ec; } // Asynchronously wait for the descriptor to become ready to read, ready to // write, or to have pending error conditions. template <typename Handler, typename IoExecutor> void async_wait(implementation_type& impl, posix::descriptor_base::wait_type w, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef reactive_wait_op<Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(success_ec_, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((reactor_.context(), p.p, "descriptor", &impl, impl.descriptor_, "async_wait")); int op_type; switch (w) { case posix::descriptor_base::wait_read: op_type = reactor::read_op; break; case posix::descriptor_base::wait_write: op_type = reactor::write_op; break; case posix::descriptor_base::wait_error: op_type = reactor::except_op; break; default: p.p->ec_ = boost::asio::error::invalid_argument; reactor_.post_immediate_completion(p.p, is_continuation); p.v = p.p = 0; return; } start_op(impl, op_type, p.p, is_continuation, false, false); p.v = p.p = 0; } // Write some data to the descriptor. template <typename ConstBufferSequence> size_t write_some(implementation_type& impl, const ConstBufferSequence& buffers, boost::system::error_code& ec) { typedef buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence> bufs_type; if (bufs_type::is_single_buffer) { return descriptor_ops::sync_write1(impl.descriptor_, impl.state_, bufs_type::first(buffers).data(), bufs_type::first(buffers).size(), ec); } else { bufs_type bufs(buffers); return descriptor_ops::sync_write(impl.descriptor_, impl.state_, bufs.buffers(), bufs.count(), bufs.all_empty(), ec); } } // Wait until data can be written without blocking. size_t write_some(implementation_type& impl, const null_buffers&, boost::system::error_code& ec) { // Wait for descriptor to become ready. descriptor_ops::poll_write(impl.descriptor_, impl.state_, ec); return 0; } // Start an asynchronous write. The data being sent must be valid for the // lifetime of the asynchronous operation. template <typename ConstBufferSequence, typename Handler, typename IoExecutor> void async_write_some(implementation_type& impl, const ConstBufferSequence& buffers, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef descriptor_write_op<ConstBufferSequence, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(success_ec_, impl.descriptor_, buffers, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((reactor_.context(), p.p, "descriptor", &impl, impl.descriptor_, "async_write_some")); start_op(impl, reactor::write_op, p.p, is_continuation, true, buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence>::all_empty(buffers)); p.v = p.p = 0; } // Start an asynchronous wait until data can be written without blocking. template <typename Handler, typename IoExecutor> void async_write_some(implementation_type& impl, const null_buffers&, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef reactive_null_buffers_op<Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(success_ec_, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((reactor_.context(), p.p, "descriptor", &impl, impl.descriptor_, "async_write_some(null_buffers)")); start_op(impl, reactor::write_op, p.p, is_continuation, false, false); p.v = p.p = 0; } // Read some data from the stream. Returns the number of bytes read. template <typename MutableBufferSequence> size_t read_some(implementation_type& impl, const MutableBufferSequence& buffers, boost::system::error_code& ec) { typedef buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence> bufs_type; if (bufs_type::is_single_buffer) { return descriptor_ops::sync_read1(impl.descriptor_, impl.state_, bufs_type::first(buffers).data(), bufs_type::first(buffers).size(), ec); } else { bufs_type bufs(buffers); return descriptor_ops::sync_read(impl.descriptor_, impl.state_, bufs.buffers(), bufs.count(), bufs.all_empty(), ec); } } // Wait until data can be read without blocking. size_t read_some(implementation_type& impl, const null_buffers&, boost::system::error_code& ec) { // Wait for descriptor to become ready. descriptor_ops::poll_read(impl.descriptor_, impl.state_, ec); return 0; } // Start an asynchronous read. The buffer for the data being read must be // valid for the lifetime of the asynchronous operation. template <typename MutableBufferSequence, typename Handler, typename IoExecutor> void async_read_some(implementation_type& impl, const MutableBufferSequence& buffers, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef descriptor_read_op<MutableBufferSequence, Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(success_ec_, impl.descriptor_, buffers, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((reactor_.context(), p.p, "descriptor", &impl, impl.descriptor_, "async_read_some")); start_op(impl, reactor::read_op, p.p, is_continuation, true, buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence>::all_empty(buffers)); p.v = p.p = 0; } // Wait until data can be read without blocking. template <typename Handler, typename IoExecutor> void async_read_some(implementation_type& impl, const null_buffers&, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef reactive_null_buffers_op<Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(success_ec_, handler, io_ex); BOOST_ASIO_HANDLER_CREATION((reactor_.context(), p.p, "descriptor", &impl, impl.descriptor_, "async_read_some(null_buffers)")); start_op(impl, reactor::read_op, p.p, is_continuation, false, false); p.v = p.p = 0; } private: // Start the asynchronous operation. BOOST_ASIO_DECL void start_op(implementation_type& impl, int op_type, reactor_op* op, bool is_continuation, bool is_non_blocking, bool noop); // The selector that performs event demultiplexing for the service. reactor& reactor_; // Cached success value to avoid accessing category singleton. const boost::system::error_code success_ec_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/reactive_descriptor_service.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // !defined(BOOST_ASIO_WINDOWS) // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) // && !defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_REACTIVE_DESCRIPTOR_SERVICE_HPP PK��h!\0�7��winrt_socket_connect_op.hppnu��[��// // detail/winrt_socket_connect_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WINRT_SOCKET_CONNECT_OP_HPP #define BOOST_ASIO_DETAIL_WINRT_SOCKET_CONNECT_OP_HPP #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_WINDOWS_RUNTIME) #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/winrt_async_op.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Handler, typename IoExecutor> class winrt_socket_connect_op : public winrt_async_op<void> { public: BOOST_ASIO_DEFINE_HANDLER_PTR(winrt_socket_connect_op); winrt_socket_connect_op(Handler& handler, const IoExecutor& io_ex) : winrt_async_op<void>(&winrt_socket_connect_op::do_complete), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static void do_complete(void* owner, operation* base, const boost::system::error_code&, std::size_t) { // Take ownership of the operation object. winrt_socket_connect_op* o(static_cast<winrt_socket_connect_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder1<Handler, boost::system::error_code> handler(o->handler_, o->ec_); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: Handler handler_; handler_work<Handler, IoExecutor> executor_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_WINRT_SOCKET_CONNECT_OP_HPP PK��h!\�\|4�a��a��throw_error.hppnu��[��// // detail/throw_error.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_THROW_ERROR_HPP #define BOOST_ASIO_DETAIL_THROW_ERROR_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <boost/system/error_code.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { BOOST_ASIO_DECL void do_throw_error(const boost::system::error_code& err); BOOST_ASIO_DECL void do_throw_error(const boost::system::error_code& err, const char* location); inline void throw_error(const boost::system::error_code& err) { if (err) do_throw_error(err); } inline void throw_error(const boost::system::error_code& err, const char* location) { if (err) do_throw_error(err, location); } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/throw_error.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // BOOST_ASIO_DETAIL_THROW_ERROR_HPP PK��h!\�[�Jd��d��socket_holder.hppnu��[��// // detail/socket_holder.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_SOCKET_HOLDER_HPP #define BOOST_ASIO_DETAIL_SOCKET_HOLDER_HPP #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/detail/noncopyable.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { // Implement the resource acquisition is initialisation idiom for sockets. class socket_holder : private noncopyable { public: // Construct as an uninitialised socket. socket_holder() : socket_(invalid_socket) { } // Construct to take ownership of the specified socket. explicit socket_holder(socket_type s) : socket_(s) { } // Destructor. ~socket_holder() { if (socket_ != invalid_socket) { boost::system::error_code ec; socket_ops::state_type state = 0; socket_ops::close(socket_, state, true, ec); } } // Get the underlying socket. socket_type get() const { return socket_; } // Reset to an uninitialised socket. void reset() { if (socket_ != invalid_socket) { boost::system::error_code ec; socket_ops::state_type state = 0; socket_ops::close(socket_, state, true, ec); socket_ = invalid_socket; } } // Reset to take ownership of the specified socket. void reset(socket_type s) { reset(); socket_ = s; } // Release ownership of the socket. socket_type release() { socket_type tmp = socket_; socket_ = invalid_socket; return tmp; } private: // The underlying socket. socket_type socket_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_SOCKET_HOLDER_HPP PK��h!\��\|��\|�� std_mutex.hppnu��[��// // detail/std_mutex.hpp // ~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_STD_MUTEX_HPP #define BOOST_ASIO_DETAIL_STD_MUTEX_HPP #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_HAS_STD_MUTEX_AND_CONDVAR) #include <mutex> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/scoped_lock.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class std_event; class std_mutex : private noncopyable { public: typedef boost::asio::detail::scoped_lock<std_mutex> scoped_lock; // Constructor. std_mutex() { } // Destructor. ~std_mutex() { } // Lock the mutex. void lock() { mutex_.lock(); } // Unlock the mutex. void unlock() { mutex_.unlock(); } private: friend class std_event; std::mutex mutex_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) #endif // BOOST_ASIO_DETAIL_STD_MUTEX_HPP PK��h!\��}��reactive_null_buffers_op.hppnu��[��// // detail/reactive_null_buffers_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_REACTIVE_NULL_BUFFERS_OP_HPP #define BOOST_ASIO_DETAIL_REACTIVE_NULL_BUFFERS_OP_HPP #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/detail/bind_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Handler, typename IoExecutor> class reactive_null_buffers_op : public reactor_op { public: BOOST_ASIO_DEFINE_HANDLER_PTR(reactive_null_buffers_op); reactive_null_buffers_op(const boost::system::error_code& success_ec, Handler& handler, const IoExecutor& io_ex) : reactor_op(success_ec, &reactive_null_buffers_op::do_perform, &reactive_null_buffers_op::do_complete), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static status do_perform(reactor_op) { return done; } static void do_complete(void owner, operation* base, const boost::system::error_code& /ec/, std::size_t /bytes_transferred/) { // Take ownership of the handler object. reactive_null_buffers_op* o(static_cast<reactive_null_buffers_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, o->ec_, o->bytes_transferred_); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_REACTIVE_NULL_BUFFERS_OP_HPP PK��h!\s}j��work_dispatcher.hppnu��[��// // detail/work_dispatcher.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WORK_DISPATCHER_HPP #define BOOST_ASIO_DETAIL_WORK_DISPATCHER_HPP #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/detail/type_traits.hpp> #include <boost/asio/associated_executor.hpp> #include <boost/asio/associated_allocator.hpp> #include <boost/asio/executor_work_guard.hpp> #include <boost/asio/execution/executor.hpp> #include <boost/asio/execution/allocator.hpp> #include <boost/asio/execution/blocking.hpp> #include <boost/asio/execution/outstanding_work.hpp> #include <boost/asio/prefer.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Handler, typename Executor, typename = void> struct is_work_dispatcher_required : true_type { }; template <typename Handler, typename Executor> struct is_work_dispatcher_required<Handler, Executor, typename enable_if< is_same< typename associated_executor<Handler, Executor>::asio_associated_executor_is_unspecialised, void >::value >::type> : false_type { }; template <typename Handler, typename Executor, typename = void> class work_dispatcher { public: template <typename CompletionHandler> work_dispatcher(BOOST_ASIO_MOVE_ARG(CompletionHandler) handler, const Executor& handler_ex) : handler_(BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler)), executor_(boost::asio::prefer(handler_ex, execution::outstanding_work.tracked)) { } #if defined(BOOST_ASIO_HAS_MOVE) work_dispatcher(const work_dispatcher& other) : handler_(other.handler_), executor_(other.executor_) { } work_dispatcher(work_dispatcher&& other) : handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_)), executor_(BOOST_ASIO_MOVE_CAST(work_executor_type)(other.executor_)) { } #endif // defined(BOOST_ASIO_HAS_MOVE) void operator()() { execution::execute( boost::asio::prefer(executor_, execution::blocking.possibly, execution::allocator((get_associated_allocator)(handler_))), BOOST_ASIO_MOVE_CAST(Handler)(handler_)); } private: typedef typename decay< typename prefer_result<const Executor&, execution::outstanding_work_t::tracked_t >::type >::type work_executor_type; Handler handler_; work_executor_type executor_; }; #if !defined(BOOST_ASIO_NO_TS_EXECUTORS) template <typename Handler, typename Executor> class work_dispatcher<Handler, Executor, typename enable_if<!execution::is_executor<Executor>::value>::type> { public: template <typename CompletionHandler> work_dispatcher(BOOST_ASIO_MOVE_ARG(CompletionHandler) handler, const Executor& handler_ex) : work_(handler_ex), handler_(BOOST_ASIO_MOVE_CAST(CompletionHandler)(handler)) { } #if defined(BOOST_ASIO_HAS_MOVE) work_dispatcher(const work_dispatcher& other) : work_(other.work_), handler_(other.handler_) { } work_dispatcher(work_dispatcher&& other) : work_(BOOST_ASIO_MOVE_CAST(executor_work_guard<Executor>)(other.work_)), handler_(BOOST_ASIO_MOVE_CAST(Handler)(other.handler_)) { } #endif // defined(BOOST_ASIO_HAS_MOVE) void operator()() { typename associated_allocator<Handler>::type alloc( (get_associated_allocator)(handler_)); work_.get_executor().dispatch( BOOST_ASIO_MOVE_CAST(Handler)(handler_), alloc); work_.reset(); } private: executor_work_guard<Executor> work_; Handler handler_; }; #endif // !defined(BOOST_ASIO_NO_TS_EXECUTORS) } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_WORK_DISPATCHER_HPP PK��h!\͕�pr?��r?��socket_types.hppnu��[��// // detail/socket_types.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_SOCKET_TYPES_HPP #define BOOST_ASIO_DETAIL_SOCKET_TYPES_HPP #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_WINDOWS_RUNTIME) // Empty. #elif defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) # if defined(_WINSOCKAPI_) && !defined(_WINSOCK2API_) # error WinSock.h has already been included # endif // defined(_WINSOCKAPI_) && !defined(_WINSOCK2API_) # if defined(__BORLANDC__) # include <stdlib.h> // Needed for __errno # if !defined(_WSPIAPI_H_) # define _WSPIAPI_H_ # define BOOST_ASIO_WSPIAPI_H_DEFINED # endif // !defined(_WSPIAPI_H_) # endif // defined(__BORLANDC__) # include <winsock2.h> # include <ws2tcpip.h> # if defined(WINAPI_FAMILY) # if ((WINAPI_FAMILY & WINAPI_PARTITION_DESKTOP) != 0) # include <windows.h> # endif // ((WINAPI_FAMILY & WINAPI_PARTITION_DESKTOP) != 0) # endif // defined(WINAPI_FAMILY) # if !defined(BOOST_ASIO_WINDOWS_APP) # include <mswsock.h> # endif // !defined(BOOST_ASIO_WINDOWS_APP) # if defined(BOOST_ASIO_WSPIAPI_H_DEFINED) # undef _WSPIAPI_H_ # undef BOOST_ASIO_WSPIAPI_H_DEFINED # endif // defined(BOOST_ASIO_WSPIAPI_H_DEFINED) # if !defined(BOOST_ASIO_NO_DEFAULT_LINKED_LIBS) # if defined(UNDER_CE) # pragma comment(lib, "ws2.lib") # elif defined(_MSC_VER) \|\| defined(__BORLANDC__) # pragma comment(lib, "ws2_32.lib") # if !defined(BOOST_ASIO_WINDOWS_APP) # pragma comment(lib, "mswsock.lib") # endif // !defined(BOOST_ASIO_WINDOWS_APP) # endif // defined(_MSC_VER) \|\| defined(__BORLANDC__) # endif // !defined(BOOST_ASIO_NO_DEFAULT_LINKED_LIBS) # include <boost/asio/detail/old_win_sdk_compat.hpp> #else # include <sys/ioctl.h> # if (defined(__MACH__) && defined(__APPLE__)) \ \|\| defined(__FreeBSD__) \|\| defined(__NetBSD__) \ \|\| defined(__OpenBSD__) \|\| defined(__linux__) \ \|\| defined(__EMSCRIPTEN__) # include <poll.h> # elif !defined(__SYMBIAN32__) # include <sys/poll.h> # endif # include <sys/types.h> # include <sys/stat.h> # include <fcntl.h> # if defined(__hpux) # include <sys/time.h> # endif # if !defined(__hpux) \|\| defined(__SELECT) # include <sys/select.h> # endif # include <sys/socket.h> # include <sys/uio.h> # include <sys/un.h> # include <netinet/in.h> # if !defined(__SYMBIAN32__) # include <netinet/tcp.h> # endif # include <arpa/inet.h> # include <netdb.h> # include <net/if.h> # include <limits.h> # if defined(__sun) # include <sys/filio.h> # include <sys/sockio.h> # endif #endif #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { #if defined(BOOST_ASIO_WINDOWS_RUNTIME) const int max_addr_v4_str_len = 256; const int max_addr_v6_str_len = 256; typedef unsigned __int32 u_long_type; typedef unsigned __int16 u_short_type; struct in4_addr_type { u_long_type s_addr; }; struct in4_mreq_type { in4_addr_type imr_multiaddr, imr_interface; }; struct in6_addr_type { unsigned char s6_addr[16]; }; struct in6_mreq_type { in6_addr_type ipv6mr_multiaddr; unsigned long ipv6mr_interface; }; struct socket_addr_type { int sa_family; }; struct sockaddr_in4_type { int sin_family; in4_addr_type sin_addr; u_short_type sin_port; }; struct sockaddr_in6_type { int sin6_family; in6_addr_type sin6_addr; u_short_type sin6_port; u_long_type sin6_flowinfo; u_long_type sin6_scope_id; }; struct sockaddr_storage_type { int ss_family; unsigned char ss_bytes[128 - sizeof(int)]; }; struct addrinfo_type { int ai_flags; int ai_family, ai_socktype, ai_protocol; int ai_addrlen; const void* ai_addr; const char* ai_canonname; addrinfo_type* ai_next; }; struct linger_type { u_short_type l_onoff, l_linger; }; typedef u_long_type ioctl_arg_type; typedef int signed_size_type; # define BOOST_ASIO_OS_DEF(c) BOOST_ASIO_OS_DEF_##c # define BOOST_ASIO_OS_DEF_AF_UNSPEC 0 # define BOOST_ASIO_OS_DEF_AF_INET 2 # define BOOST_ASIO_OS_DEF_AF_INET6 23 # define BOOST_ASIO_OS_DEF_SOCK_STREAM 1 # define BOOST_ASIO_OS_DEF_SOCK_DGRAM 2 # define BOOST_ASIO_OS_DEF_SOCK_RAW 3 # define BOOST_ASIO_OS_DEF_SOCK_SEQPACKET 5 # define BOOST_ASIO_OS_DEF_IPPROTO_IP 0 # define BOOST_ASIO_OS_DEF_IPPROTO_IPV6 41 # define BOOST_ASIO_OS_DEF_IPPROTO_TCP 6 # define BOOST_ASIO_OS_DEF_IPPROTO_UDP 17 # define BOOST_ASIO_OS_DEF_IPPROTO_ICMP 1 # define BOOST_ASIO_OS_DEF_IPPROTO_ICMPV6 58 # define BOOST_ASIO_OS_DEF_FIONBIO 1 # define BOOST_ASIO_OS_DEF_FIONREAD 2 # define BOOST_ASIO_OS_DEF_INADDR_ANY 0 # define BOOST_ASIO_OS_DEF_MSG_OOB 0x1 # define BOOST_ASIO_OS_DEF_MSG_PEEK 0x2 # define BOOST_ASIO_OS_DEF_MSG_DONTROUTE 0x4 # define BOOST_ASIO_OS_DEF_MSG_EOR 0 // Not supported. # define BOOST_ASIO_OS_DEF_SHUT_RD 0x0 # define BOOST_ASIO_OS_DEF_SHUT_WR 0x1 # define BOOST_ASIO_OS_DEF_SHUT_RDWR 0x2 # define BOOST_ASIO_OS_DEF_SOMAXCONN 0x7fffffff # define BOOST_ASIO_OS_DEF_SOL_SOCKET 0xffff # define BOOST_ASIO_OS_DEF_SO_BROADCAST 0x20 # define BOOST_ASIO_OS_DEF_SO_DEBUG 0x1 # define BOOST_ASIO_OS_DEF_SO_DONTROUTE 0x10 # define BOOST_ASIO_OS_DEF_SO_KEEPALIVE 0x8 # define BOOST_ASIO_OS_DEF_SO_LINGER 0x80 # define BOOST_ASIO_OS_DEF_SO_OOBINLINE 0x100 # define BOOST_ASIO_OS_DEF_SO_SNDBUF 0x1001 # define BOOST_ASIO_OS_DEF_SO_RCVBUF 0x1002 # define BOOST_ASIO_OS_DEF_SO_SNDLOWAT 0x1003 # define BOOST_ASIO_OS_DEF_SO_RCVLOWAT 0x1004 # define BOOST_ASIO_OS_DEF_SO_REUSEADDR 0x4 # define BOOST_ASIO_OS_DEF_TCP_NODELAY 0x1 # define BOOST_ASIO_OS_DEF_IP_MULTICAST_IF 2 # define BOOST_ASIO_OS_DEF_IP_MULTICAST_TTL 3 # define BOOST_ASIO_OS_DEF_IP_MULTICAST_LOOP 4 # define BOOST_ASIO_OS_DEF_IP_ADD_MEMBERSHIP 5 # define BOOST_ASIO_OS_DEF_IP_DROP_MEMBERSHIP 6 # define BOOST_ASIO_OS_DEF_IP_TTL 7 # define BOOST_ASIO_OS_DEF_IPV6_UNICAST_HOPS 4 # define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_IF 9 # define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_HOPS 10 # define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_LOOP 11 # define BOOST_ASIO_OS_DEF_IPV6_JOIN_GROUP 12 # define BOOST_ASIO_OS_DEF_IPV6_LEAVE_GROUP 13 # define BOOST_ASIO_OS_DEF_AI_CANONNAME 0x2 # define BOOST_ASIO_OS_DEF_AI_PASSIVE 0x1 # define BOOST_ASIO_OS_DEF_AI_NUMERICHOST 0x4 # define BOOST_ASIO_OS_DEF_AI_NUMERICSERV 0x8 # define BOOST_ASIO_OS_DEF_AI_V4MAPPED 0x800 # define BOOST_ASIO_OS_DEF_AI_ALL 0x100 # define BOOST_ASIO_OS_DEF_AI_ADDRCONFIG 0x400 #elif defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) typedef SOCKET socket_type; const SOCKET invalid_socket = INVALID_SOCKET; const int socket_error_retval = SOCKET_ERROR; const int max_addr_v4_str_len = 256; const int max_addr_v6_str_len = 256; typedef sockaddr socket_addr_type; typedef in_addr in4_addr_type; typedef ip_mreq in4_mreq_type; typedef sockaddr_in sockaddr_in4_type; # if defined(BOOST_ASIO_HAS_OLD_WIN_SDK) typedef in6_addr_emulation in6_addr_type; typedef ipv6_mreq_emulation in6_mreq_type; typedef sockaddr_in6_emulation sockaddr_in6_type; typedef sockaddr_storage_emulation sockaddr_storage_type; typedef addrinfo_emulation addrinfo_type; # else typedef in6_addr in6_addr_type; typedef ipv6_mreq in6_mreq_type; typedef sockaddr_in6 sockaddr_in6_type; typedef sockaddr_storage sockaddr_storage_type; typedef addrinfo addrinfo_type; # endif typedef ::linger linger_type; typedef unsigned long ioctl_arg_type; typedef u_long u_long_type; typedef u_short u_short_type; typedef int signed_size_type; struct sockaddr_un_type { u_short sun_family; char sun_path[108]; }; # define BOOST_ASIO_OS_DEF(c) BOOST_ASIO_OS_DEF_##c # define BOOST_ASIO_OS_DEF_AF_UNSPEC AF_UNSPEC # define BOOST_ASIO_OS_DEF_AF_INET AF_INET # define BOOST_ASIO_OS_DEF_AF_INET6 AF_INET6 # define BOOST_ASIO_OS_DEF_SOCK_STREAM SOCK_STREAM # define BOOST_ASIO_OS_DEF_SOCK_DGRAM SOCK_DGRAM # define BOOST_ASIO_OS_DEF_SOCK_RAW SOCK_RAW # define BOOST_ASIO_OS_DEF_SOCK_SEQPACKET SOCK_SEQPACKET # define BOOST_ASIO_OS_DEF_IPPROTO_IP IPPROTO_IP # define BOOST_ASIO_OS_DEF_IPPROTO_IPV6 IPPROTO_IPV6 # define BOOST_ASIO_OS_DEF_IPPROTO_TCP IPPROTO_TCP # define BOOST_ASIO_OS_DEF_IPPROTO_UDP IPPROTO_UDP # define BOOST_ASIO_OS_DEF_IPPROTO_ICMP IPPROTO_ICMP # define BOOST_ASIO_OS_DEF_IPPROTO_ICMPV6 IPPROTO_ICMPV6 # define BOOST_ASIO_OS_DEF_FIONBIO FIONBIO # define BOOST_ASIO_OS_DEF_FIONREAD FIONREAD # define BOOST_ASIO_OS_DEF_INADDR_ANY INADDR_ANY # define BOOST_ASIO_OS_DEF_MSG_OOB MSG_OOB # define BOOST_ASIO_OS_DEF_MSG_PEEK MSG_PEEK # define BOOST_ASIO_OS_DEF_MSG_DONTROUTE MSG_DONTROUTE # define BOOST_ASIO_OS_DEF_MSG_EOR 0 // Not supported on Windows. # define BOOST_ASIO_OS_DEF_SHUT_RD SD_RECEIVE # define BOOST_ASIO_OS_DEF_SHUT_WR SD_SEND # define BOOST_ASIO_OS_DEF_SHUT_RDWR SD_BOTH # define BOOST_ASIO_OS_DEF_SOMAXCONN SOMAXCONN # define BOOST_ASIO_OS_DEF_SOL_SOCKET SOL_SOCKET # define BOOST_ASIO_OS_DEF_SO_BROADCAST SO_BROADCAST # define BOOST_ASIO_OS_DEF_SO_DEBUG SO_DEBUG # define BOOST_ASIO_OS_DEF_SO_DONTROUTE SO_DONTROUTE # define BOOST_ASIO_OS_DEF_SO_KEEPALIVE SO_KEEPALIVE # define BOOST_ASIO_OS_DEF_SO_LINGER SO_LINGER # define BOOST_ASIO_OS_DEF_SO_OOBINLINE SO_OOBINLINE # define BOOST_ASIO_OS_DEF_SO_SNDBUF SO_SNDBUF # define BOOST_ASIO_OS_DEF_SO_RCVBUF SO_RCVBUF # define BOOST_ASIO_OS_DEF_SO_SNDLOWAT SO_SNDLOWAT # define BOOST_ASIO_OS_DEF_SO_RCVLOWAT SO_RCVLOWAT # define BOOST_ASIO_OS_DEF_SO_REUSEADDR SO_REUSEADDR # define BOOST_ASIO_OS_DEF_TCP_NODELAY TCP_NODELAY # define BOOST_ASIO_OS_DEF_IP_MULTICAST_IF IP_MULTICAST_IF # define BOOST_ASIO_OS_DEF_IP_MULTICAST_TTL IP_MULTICAST_TTL # define BOOST_ASIO_OS_DEF_IP_MULTICAST_LOOP IP_MULTICAST_LOOP # define BOOST_ASIO_OS_DEF_IP_ADD_MEMBERSHIP IP_ADD_MEMBERSHIP # define BOOST_ASIO_OS_DEF_IP_DROP_MEMBERSHIP IP_DROP_MEMBERSHIP # define BOOST_ASIO_OS_DEF_IP_TTL IP_TTL # define BOOST_ASIO_OS_DEF_IPV6_UNICAST_HOPS IPV6_UNICAST_HOPS # define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_IF IPV6_MULTICAST_IF # define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_HOPS IPV6_MULTICAST_HOPS # define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_LOOP IPV6_MULTICAST_LOOP # define BOOST_ASIO_OS_DEF_IPV6_JOIN_GROUP IPV6_JOIN_GROUP # define BOOST_ASIO_OS_DEF_IPV6_LEAVE_GROUP IPV6_LEAVE_GROUP # define BOOST_ASIO_OS_DEF_AI_CANONNAME AI_CANONNAME # define BOOST_ASIO_OS_DEF_AI_PASSIVE AI_PASSIVE # define BOOST_ASIO_OS_DEF_AI_NUMERICHOST AI_NUMERICHOST # if defined(AI_NUMERICSERV) # define BOOST_ASIO_OS_DEF_AI_NUMERICSERV AI_NUMERICSERV # else # define BOOST_ASIO_OS_DEF_AI_NUMERICSERV 0 # endif # if defined(AI_V4MAPPED) # define BOOST_ASIO_OS_DEF_AI_V4MAPPED AI_V4MAPPED # else # define BOOST_ASIO_OS_DEF_AI_V4MAPPED 0 # endif # if defined(AI_ALL) # define BOOST_ASIO_OS_DEF_AI_ALL AI_ALL # else # define BOOST_ASIO_OS_DEF_AI_ALL 0 # endif # if defined(AI_ADDRCONFIG) # define BOOST_ASIO_OS_DEF_AI_ADDRCONFIG AI_ADDRCONFIG # else # define BOOST_ASIO_OS_DEF_AI_ADDRCONFIG 0 # endif # if defined (_WIN32_WINNT) const int max_iov_len = 64; # else const int max_iov_len = 16; # endif #else typedef int socket_type; const int invalid_socket = -1; const int socket_error_retval = -1; const int max_addr_v4_str_len = INET_ADDRSTRLEN; #if defined(INET6_ADDRSTRLEN) const int max_addr_v6_str_len = INET6_ADDRSTRLEN + 1 + IF_NAMESIZE; #else // defined(INET6_ADDRSTRLEN) const int max_addr_v6_str_len = 256; #endif // defined(INET6_ADDRSTRLEN) typedef sockaddr socket_addr_type; typedef in_addr in4_addr_type; # if defined(__hpux) // HP-UX doesn't provide ip_mreq when _XOPEN_SOURCE_EXTENDED is defined. struct in4_mreq_type { struct in_addr imr_multiaddr; struct in_addr imr_interface; }; # else typedef ip_mreq in4_mreq_type; # endif typedef sockaddr_in sockaddr_in4_type; typedef in6_addr in6_addr_type; typedef ipv6_mreq in6_mreq_type; typedef sockaddr_in6 sockaddr_in6_type; typedef sockaddr_storage sockaddr_storage_type; typedef sockaddr_un sockaddr_un_type; typedef addrinfo addrinfo_type; typedef ::linger linger_type; typedef int ioctl_arg_type; typedef uint32_t u_long_type; typedef uint16_t u_short_type; #if defined(BOOST_ASIO_HAS_SSIZE_T) typedef ssize_t signed_size_type; #else // defined(BOOST_ASIO_HAS_SSIZE_T) typedef int signed_size_type; #endif // defined(BOOST_ASIO_HAS_SSIZE_T) # define BOOST_ASIO_OS_DEF(c) BOOST_ASIO_OS_DEF_##c # define BOOST_ASIO_OS_DEF_AF_UNSPEC AF_UNSPEC # define BOOST_ASIO_OS_DEF_AF_INET AF_INET # define BOOST_ASIO_OS_DEF_AF_INET6 AF_INET6 # define BOOST_ASIO_OS_DEF_SOCK_STREAM SOCK_STREAM # define BOOST_ASIO_OS_DEF_SOCK_DGRAM SOCK_DGRAM # define BOOST_ASIO_OS_DEF_SOCK_RAW SOCK_RAW # define BOOST_ASIO_OS_DEF_SOCK_SEQPACKET SOCK_SEQPACKET # define BOOST_ASIO_OS_DEF_IPPROTO_IP IPPROTO_IP # define BOOST_ASIO_OS_DEF_IPPROTO_IPV6 IPPROTO_IPV6 # define BOOST_ASIO_OS_DEF_IPPROTO_TCP IPPROTO_TCP # define BOOST_ASIO_OS_DEF_IPPROTO_UDP IPPROTO_UDP # define BOOST_ASIO_OS_DEF_IPPROTO_ICMP IPPROTO_ICMP # define BOOST_ASIO_OS_DEF_IPPROTO_ICMPV6 IPPROTO_ICMPV6 # define BOOST_ASIO_OS_DEF_FIONBIO FIONBIO # define BOOST_ASIO_OS_DEF_FIONREAD FIONREAD # define BOOST_ASIO_OS_DEF_INADDR_ANY INADDR_ANY # define BOOST_ASIO_OS_DEF_MSG_OOB MSG_OOB # define BOOST_ASIO_OS_DEF_MSG_PEEK MSG_PEEK # define BOOST_ASIO_OS_DEF_MSG_DONTROUTE MSG_DONTROUTE # define BOOST_ASIO_OS_DEF_MSG_EOR MSG_EOR # define BOOST_ASIO_OS_DEF_SHUT_RD SHUT_RD # define BOOST_ASIO_OS_DEF_SHUT_WR SHUT_WR # define BOOST_ASIO_OS_DEF_SHUT_RDWR SHUT_RDWR # define BOOST_ASIO_OS_DEF_SOMAXCONN SOMAXCONN # define BOOST_ASIO_OS_DEF_SOL_SOCKET SOL_SOCKET # define BOOST_ASIO_OS_DEF_SO_BROADCAST SO_BROADCAST # define BOOST_ASIO_OS_DEF_SO_DEBUG SO_DEBUG # define BOOST_ASIO_OS_DEF_SO_DONTROUTE SO_DONTROUTE # define BOOST_ASIO_OS_DEF_SO_KEEPALIVE SO_KEEPALIVE # define BOOST_ASIO_OS_DEF_SO_LINGER SO_LINGER # define BOOST_ASIO_OS_DEF_SO_OOBINLINE SO_OOBINLINE # define BOOST_ASIO_OS_DEF_SO_SNDBUF SO_SNDBUF # define BOOST_ASIO_OS_DEF_SO_RCVBUF SO_RCVBUF # define BOOST_ASIO_OS_DEF_SO_SNDLOWAT SO_SNDLOWAT # define BOOST_ASIO_OS_DEF_SO_RCVLOWAT SO_RCVLOWAT # define BOOST_ASIO_OS_DEF_SO_REUSEADDR SO_REUSEADDR # define BOOST_ASIO_OS_DEF_TCP_NODELAY TCP_NODELAY # define BOOST_ASIO_OS_DEF_IP_MULTICAST_IF IP_MULTICAST_IF # define BOOST_ASIO_OS_DEF_IP_MULTICAST_TTL IP_MULTICAST_TTL # define BOOST_ASIO_OS_DEF_IP_MULTICAST_LOOP IP_MULTICAST_LOOP # define BOOST_ASIO_OS_DEF_IP_ADD_MEMBERSHIP IP_ADD_MEMBERSHIP # define BOOST_ASIO_OS_DEF_IP_DROP_MEMBERSHIP IP_DROP_MEMBERSHIP # define BOOST_ASIO_OS_DEF_IP_TTL IP_TTL # define BOOST_ASIO_OS_DEF_IPV6_UNICAST_HOPS IPV6_UNICAST_HOPS # define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_IF IPV6_MULTICAST_IF # define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_HOPS IPV6_MULTICAST_HOPS # define BOOST_ASIO_OS_DEF_IPV6_MULTICAST_LOOP IPV6_MULTICAST_LOOP # define BOOST_ASIO_OS_DEF_IPV6_JOIN_GROUP IPV6_JOIN_GROUP # define BOOST_ASIO_OS_DEF_IPV6_LEAVE_GROUP IPV6_LEAVE_GROUP # define BOOST_ASIO_OS_DEF_AI_CANONNAME AI_CANONNAME # define BOOST_ASIO_OS_DEF_AI_PASSIVE AI_PASSIVE # define BOOST_ASIO_OS_DEF_AI_NUMERICHOST AI_NUMERICHOST # if defined(AI_NUMERICSERV) # define BOOST_ASIO_OS_DEF_AI_NUMERICSERV AI_NUMERICSERV # else # define BOOST_ASIO_OS_DEF_AI_NUMERICSERV 0 # endif // Note: QNX Neutrino 6.3 defines AI_V4MAPPED, AI_ALL and AI_ADDRCONFIG but // does not implement them. Therefore they are specifically excluded here. # if defined(AI_V4MAPPED) && !defined(__QNXNTO__) # define BOOST_ASIO_OS_DEF_AI_V4MAPPED AI_V4MAPPED # else # define BOOST_ASIO_OS_DEF_AI_V4MAPPED 0 # endif # if defined(AI_ALL) && !defined(__QNXNTO__) # define BOOST_ASIO_OS_DEF_AI_ALL AI_ALL # else # define BOOST_ASIO_OS_DEF_AI_ALL 0 # endif # if defined(AI_ADDRCONFIG) && !defined(__QNXNTO__) # define BOOST_ASIO_OS_DEF_AI_ADDRCONFIG AI_ADDRCONFIG # else # define BOOST_ASIO_OS_DEF_AI_ADDRCONFIG 0 # endif # if defined(IOV_MAX) const int max_iov_len = IOV_MAX; # else // POSIX platforms are not required to define IOV_MAX. const int max_iov_len = 16; # endif #endif const int custom_socket_option_level = 0xA5100000; const int enable_connection_aborted_option = 1; const int always_fail_option = 2; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_SOCKET_TYPES_HPP PK��h!\��hts��s��reactor_op_queue.hppnu��[��// // detail/reactor_op_queue.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_REACTOR_OP_QUEUE_HPP #define BOOST_ASIO_DETAIL_REACTOR_OP_QUEUE_HPP #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/detail/hash_map.hpp> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/op_queue.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Descriptor> class reactor_op_queue : private noncopyable { public: typedef Descriptor key_type; struct mapped_type : op_queue<reactor_op> { mapped_type() {} mapped_type(const mapped_type&) {} void operator=(const mapped_type&) {} }; typedef typename hash_map<key_type, mapped_type>::value_type value_type; typedef typename hash_map<key_type, mapped_type>::iterator iterator; // Constructor. reactor_op_queue() : operations_() { } // Obtain iterators to all registered descriptors. iterator begin() { return operations_.begin(); } iterator end() { return operations_.end(); } // Add a new operation to the queue. Returns true if this is the only // operation for the given descriptor, in which case the reactor's event // demultiplexing function call may need to be interrupted and restarted. bool enqueue_operation(Descriptor descriptor, reactor_op* op) { std::pair<iterator, bool> entry = operations_.insert(value_type(descriptor, mapped_type())); entry.first->second.push(op); return entry.second; } // Cancel all operations associated with the descriptor identified by the // supplied iterator. Any operations pending for the descriptor will be // cancelled. Returns true if any operations were cancelled, in which case // the reactor's event demultiplexing function may need to be interrupted and // restarted. bool cancel_operations(iterator i, op_queue<operation>& ops, const boost::system::error_code& ec = boost::asio::error::operation_aborted) { if (i != operations_.end()) { while (reactor_op* op = i->second.front()) { op->ec_ = ec; i->second.pop(); ops.push(op); } operations_.erase(i); return true; } return false; } // Cancel all operations associated with the descriptor. Any operations // pending for the descriptor will be cancelled. Returns true if any // operations were cancelled, in which case the reactor's event // demultiplexing function may need to be interrupted and restarted. bool cancel_operations(Descriptor descriptor, op_queue<operation>& ops, const boost::system::error_code& ec = boost::asio::error::operation_aborted) { return this->cancel_operations(operations_.find(descriptor), ops, ec); } // Whether there are no operations in the queue. bool empty() const { return operations_.empty(); } // Determine whether there are any operations associated with the descriptor. bool has_operation(Descriptor descriptor) const { return operations_.find(descriptor) != operations_.end(); } // Perform the operations corresponding to the descriptor identified by the // supplied iterator. Returns true if there are still unfinished operations // queued for the descriptor. bool perform_operations(iterator i, op_queue<operation>& ops) { if (i != operations_.end()) { while (reactor_op* op = i->second.front()) { if (op->perform()) { i->second.pop(); ops.push(op); } else { return true; } } operations_.erase(i); } return false; } // Perform the operations corresponding to the descriptor. Returns true if // there are still unfinished operations queued for the descriptor. bool perform_operations(Descriptor descriptor, op_queue<operation>& ops) { return this->perform_operations(operations_.find(descriptor), ops); } // Get all operations owned by the queue. void get_all_operations(op_queue<operation>& ops) { iterator i = operations_.begin(); while (i != operations_.end()) { iterator op_iter = i++; ops.push(op_iter->second); operations_.erase(op_iter); } } private: // The operations that are currently executing asynchronously. hash_map<key_type, mapped_type> operations_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_REACTOR_OP_QUEUE_HPP PK��h!\��posix_mutex.hppnu��[��// // detail/posix_mutex.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_POSIX_MUTEX_HPP #define BOOST_ASIO_DETAIL_POSIX_MUTEX_HPP #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_HAS_PTHREADS) #include <pthread.h> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/scoped_lock.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class posix_event; class posix_mutex : private noncopyable { public: typedef boost::asio::detail::scoped_lock<posix_mutex> scoped_lock; // Constructor. BOOST_ASIO_DECL posix_mutex(); // Destructor. ~posix_mutex() { ::pthread_mutex_destroy(&mutex_); // Ignore EBUSY. } // Lock the mutex. void lock() { (void)::pthread_mutex_lock(&mutex_); // Ignore EINVAL. } // Unlock the mutex. void unlock() { (void)::pthread_mutex_unlock(&mutex_); // Ignore EINVAL. } private: friend class posix_event; ::pthread_mutex_t mutex_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/posix_mutex.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_HAS_PTHREADS) #endif // BOOST_ASIO_DETAIL_POSIX_MUTEX_HPP PK��h!\iܩ?��reactive_socket_connect_op.hppnu��[��// // detail/reactive_socket_connect_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_REACTIVE_SOCKET_CONNECT_OP_HPP #define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_CONNECT_OP_HPP #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/detail/bind_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class reactive_socket_connect_op_base : public reactor_op { public: reactive_socket_connect_op_base(const boost::system::error_code& success_ec, socket_type socket, func_type complete_func) : reactor_op(success_ec, &reactive_socket_connect_op_base::do_perform, complete_func), socket_(socket) { } static status do_perform(reactor_op* base) { reactive_socket_connect_op_base* o( static_cast<reactive_socket_connect_op_base>(base)); status result = socket_ops::non_blocking_connect( o->socket_, o->ec_) ? done : not_done; BOOST_ASIO_HANDLER_REACTOR_OPERATION((o, "non_blocking_connect", o->ec_)); return result; } private: socket_type socket_; }; template <typename Handler, typename IoExecutor> class reactive_socket_connect_op : public reactive_socket_connect_op_base { public: BOOST_ASIO_DEFINE_HANDLER_PTR(reactive_socket_connect_op); reactive_socket_connect_op(const boost::system::error_code& success_ec, socket_type socket, Handler& handler, const IoExecutor& io_ex) : reactive_socket_connect_op_base(success_ec, socket, &reactive_socket_connect_op::do_complete), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static void do_complete(void* owner, operation* base, const boost::system::error_code& /ec/, std::size_t /bytes_transferred/) { // Take ownership of the handler object. reactive_socket_connect_op* o (static_cast<reactive_socket_connect_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder1<Handler, boost::system::error_code> handler(o->handler_, o->ec_); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_CONNECT_OP_HPP PK��h!\�GF� �� winapp_thread.hppnu��[��// // detail/winapp_thread.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WINAPP_THREAD_HPP #define BOOST_ASIO_DETAIL_WINAPP_THREAD_HPP #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_WINDOWS) && defined(BOOST_ASIO_WINDOWS_APP) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/scoped_ptr.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { DWORD WINAPI winapp_thread_function(LPVOID arg); class winapp_thread : private noncopyable { public: // Constructor. template <typename Function> winapp_thread(Function f, unsigned int = 0) { scoped_ptr<func_base> arg(new func<Function>(f)); DWORD thread_id = 0; thread_ = ::CreateThread(0, 0, winapp_thread_function, arg.get(), 0, &thread_id); if (!thread_) { DWORD last_error = ::GetLastError(); boost::system::error_code ec(last_error, boost::asio::error::get_system_category()); boost::asio::detail::throw_error(ec, "thread"); } arg.release(); } // Destructor. ~winapp_thread() { ::CloseHandle(thread_); } // Wait for the thread to exit. void join() { ::WaitForSingleObjectEx(thread_, INFINITE, false); } // Get number of CPUs. static std::size_t hardware_concurrency() { SYSTEM_INFO system_info; ::GetNativeSystemInfo(&system_info); return system_info.dwNumberOfProcessors; } private: friend DWORD WINAPI winapp_thread_function(LPVOID arg); class func_base { public: virtual ~func_base() {} virtual void run() = 0; }; template <typename Function> class func : public func_base { public: func(Function f) : f_(f) { } virtual void run() { f_(); } private: Function f_; }; ::HANDLE thread_; }; inline DWORD WINAPI winapp_thread_function(LPVOID arg) { scoped_ptr<winapp_thread::func_base> func( static_cast<winapp_thread::func_base>(arg)); func->run(); return 0; } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS) && defined(BOOST_ASIO_WINDOWS_APP) #endif // BOOST_ASIO_DETAIL_WINAPP_THREAD_HPP PK��h!\sS��timer_queue_base.hppnu��[��// // detail/timer_queue_base.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_TIMER_QUEUE_BASE_HPP #define BOOST_ASIO_DETAIL_TIMER_QUEUE_BASE_HPP #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/detail/noncopyable.hpp> #include <boost/asio/detail/op_queue.hpp> #include <boost/asio/detail/operation.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class timer_queue_base : private noncopyable { public: // Constructor. timer_queue_base() : next_(0) {} // Destructor. virtual ~timer_queue_base() {} // Whether there are no timers in the queue. virtual bool empty() const = 0; // Get the time to wait until the next timer. virtual long wait_duration_msec(long max_duration) const = 0; // Get the time to wait until the next timer. virtual long wait_duration_usec(long max_duration) const = 0; // Dequeue all ready timers. virtual void get_ready_timers(op_queue<operation>& ops) = 0; // Dequeue all timers. virtual void get_all_timers(op_queue<operation>& ops) = 0; private: friend class timer_queue_set; // Next timer queue in the set. timer_queue_base next_; }; template <typename Time_Traits> class timer_queue; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_TIMER_QUEUE_BASE_HPP PK��h!\ ��O��O��handler_type_requirements.hppnu��[��// // detail/handler_type_requirements.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_HANDLER_TYPE_REQUIREMENTS_HPP #define BOOST_ASIO_DETAIL_HANDLER_TYPE_REQUIREMENTS_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> // Older versions of gcc have difficulty compiling the sizeof expressions where // we test the handler type requirements. We'll disable checking of handler type // requirements for those compilers, but otherwise enable it by default. #if !defined(BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS) # if !defined(__GNUC__) \|\| (__GNUC__ >= 4) # define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS 1 # endif // !defined(__GNUC__) \|\| (__GNUC__ >= 4) #endif // !defined(BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS) // With C++0x we can use a combination of enhanced SFINAE and static_assert to // generate better template error messages. As this technique is not yet widely // portable, we'll only enable it for tested compilers. #if !defined(BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT) # if defined(__GNUC__) # if ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) \|\| (__GNUC__ > 4) # if defined(__GXX_EXPERIMENTAL_CXX0X__) # define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1 # endif // defined(__GXX_EXPERIMENTAL_CXX0X__) # endif // ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)) \|\| (__GNUC__ > 4) # endif // defined(__GNUC__) # if defined(BOOST_ASIO_MSVC) # if (_MSC_VER >= 1600) # define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1 # endif // (_MSC_VER >= 1600) # endif // defined(BOOST_ASIO_MSVC) # if defined(__clang__) # if __has_feature(__cxx_static_assert__) # define BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT 1 # endif // __has_feature(cxx_static_assert) # endif // defined(__clang__) #endif // !defined(BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS) #if defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS) # include <boost/asio/async_result.hpp> #endif // defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS) namespace boost { namespace asio { namespace detail { #if defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS) # if defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT) template <typename Handler> auto zero_arg_copyable_handler_test(Handler h, void) -> decltype( sizeof(Handler(static_cast<const Handler&>(h))), ((h)()), char(0)); template <typename Handler> char (&zero_arg_copyable_handler_test(Handler, ...))[2]; template <typename Handler, typename Arg1> auto one_arg_handler_test(Handler h, Arg1 a1) -> decltype( sizeof(Handler(BOOST_ASIO_MOVE_CAST(Handler)(h))), ((h)(a1)), char(0)); template <typename Handler> char (&one_arg_handler_test(Handler h, ...))[2]; template <typename Handler, typename Arg1, typename Arg2> auto two_arg_handler_test(Handler h, Arg1 a1, Arg2* a2) -> decltype( sizeof(Handler(BOOST_ASIO_MOVE_CAST(Handler)(h))), ((h)(a1, a2)), char(0)); template <typename Handler> char (&two_arg_handler_test(Handler, ...))[2]; template <typename Handler, typename Arg1, typename Arg2> auto two_arg_move_handler_test(Handler h, Arg1* a1, Arg2* a2) -> decltype( sizeof(Handler(BOOST_ASIO_MOVE_CAST(Handler)(h))), ((h)(a1, BOOST_ASIO_MOVE_CAST(Arg2)(a2))), char(0)); template <typename Handler> char (&two_arg_move_handler_test(Handler, ...))[2]; # define BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT(expr, msg) \ static_assert(expr, msg); # else // defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT) # define BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT(expr, msg) # endif // defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS_ASSERT) template <typename T> T& lvref(); template <typename T> T& lvref(T); template <typename T> const T& clvref(); template <typename T> const T& clvref(T); #if defined(BOOST_ASIO_HAS_MOVE) template <typename T> T rvref(); template <typename T> T rvref(T); #else // defined(BOOST_ASIO_HAS_MOVE) template <typename T> const T& rvref(); template <typename T> const T& rvref(T); #endif // defined(BOOST_ASIO_HAS_MOVE) template <typename T> char argbyv(T); template <int> struct handler_type_requirements { }; #define BOOST_ASIO_LEGACY_COMPLETION_HANDLER_CHECK( \ handler_type, handler) \ \ typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ void()) asio_true_handler_type; \ \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::zero_arg_copyable_handler_test( \ boost::asio::detail::clvref< \ asio_true_handler_type>(), 0)) == 1, \ "CompletionHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ boost::asio::detail::clvref< \ asio_true_handler_type>())) + \ sizeof( \ boost::asio::detail::lvref< \ asio_true_handler_type>()(), \ char(0))> BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_READ_HANDLER_CHECK( \ handler_type, handler) \ \ typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ void(boost::system::error_code, std::size_t)) \ asio_true_handler_type; \ \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::two_arg_handler_test( \ boost::asio::detail::rvref< \ asio_true_handler_type>(), \ static_cast<const boost::system::error_code>(0), \ static_cast<const std::size_t>(0))) == 1, \ "ReadHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ boost::asio::detail::rvref< \ asio_true_handler_type>())) + \ sizeof( \ boost::asio::detail::lvref< \ asio_true_handler_type>()( \ boost::asio::detail::lvref<const boost::system::error_code>(), \ boost::asio::detail::lvref<const std::size_t>()), \ char(0))> BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_WRITE_HANDLER_CHECK( \ handler_type, handler) \ \ typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ void(boost::system::error_code, std::size_t)) \ asio_true_handler_type; \ \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::two_arg_handler_test( \ boost::asio::detail::rvref< \ asio_true_handler_type>(), \ static_cast<const boost::system::error_code>(0), \ static_cast<const std::size_t>(0))) == 1, \ "WriteHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ boost::asio::detail::rvref< \ asio_true_handler_type>())) + \ sizeof( \ boost::asio::detail::lvref< \ asio_true_handler_type>()( \ boost::asio::detail::lvref<const boost::system::error_code>(), \ boost::asio::detail::lvref<const std::size_t>()), \ char(0))> BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_ACCEPT_HANDLER_CHECK( \ handler_type, handler) \ \ typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ void(boost::system::error_code)) \ asio_true_handler_type; \ \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::one_arg_handler_test( \ boost::asio::detail::rvref< \ asio_true_handler_type>(), \ static_cast<const boost::system::error_code>(0))) == 1, \ "AcceptHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ boost::asio::detail::rvref< \ asio_true_handler_type>())) + \ sizeof( \ boost::asio::detail::lvref< \ asio_true_handler_type>()( \ boost::asio::detail::lvref<const boost::system::error_code>()), \ char(0))> BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_MOVE_ACCEPT_HANDLER_CHECK( \ handler_type, handler, socket_type) \ \ typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ void(boost::system::error_code, socket_type)) \ asio_true_handler_type; \ \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::two_arg_move_handler_test( \ boost::asio::detail::rvref< \ asio_true_handler_type>(), \ static_cast<const boost::system::error_code>(0), \ static_cast<socket_type>(0))) == 1, \ "MoveAcceptHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ boost::asio::detail::rvref< \ asio_true_handler_type>())) + \ sizeof( \ boost::asio::detail::lvref< \ asio_true_handler_type>()( \ boost::asio::detail::lvref<const boost::system::error_code>(), \ boost::asio::detail::rvref<socket_type>()), \ char(0))> BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_CONNECT_HANDLER_CHECK( \ handler_type, handler) \ \ typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ void(boost::system::error_code)) \ asio_true_handler_type; \ \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::one_arg_handler_test( \ boost::asio::detail::rvref< \ asio_true_handler_type>(), \ static_cast<const boost::system::error_code>(0))) == 1, \ "ConnectHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ boost::asio::detail::rvref< \ asio_true_handler_type>())) + \ sizeof( \ boost::asio::detail::lvref< \ asio_true_handler_type>()( \ boost::asio::detail::lvref<const boost::system::error_code>()), \ char(0))> BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_RANGE_CONNECT_HANDLER_CHECK( \ handler_type, handler, endpoint_type) \ \ typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ void(boost::system::error_code, endpoint_type)) \ asio_true_handler_type; \ \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::two_arg_handler_test( \ boost::asio::detail::rvref< \ asio_true_handler_type>(), \ static_cast<const boost::system::error_code>(0), \ static_cast<const endpoint_type>(0))) == 1, \ "RangeConnectHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ boost::asio::detail::rvref< \ asio_true_handler_type>())) + \ sizeof( \ boost::asio::detail::lvref< \ asio_true_handler_type>()( \ boost::asio::detail::lvref<const boost::system::error_code>(), \ boost::asio::detail::lvref<const endpoint_type>()), \ char(0))> BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_ITERATOR_CONNECT_HANDLER_CHECK( \ handler_type, handler, iter_type) \ \ typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ void(boost::system::error_code, iter_type)) \ asio_true_handler_type; \ \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::two_arg_handler_test( \ boost::asio::detail::rvref< \ asio_true_handler_type>(), \ static_cast<const boost::system::error_code>(0), \ static_cast<const iter_type>(0))) == 1, \ "IteratorConnectHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ boost::asio::detail::rvref< \ asio_true_handler_type>())) + \ sizeof( \ boost::asio::detail::lvref< \ asio_true_handler_type>()( \ boost::asio::detail::lvref<const boost::system::error_code>(), \ boost::asio::detail::lvref<const iter_type>()), \ char(0))> BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_RESOLVE_HANDLER_CHECK( \ handler_type, handler, range_type) \ \ typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ void(boost::system::error_code, range_type)) \ asio_true_handler_type; \ \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::two_arg_handler_test( \ boost::asio::detail::rvref< \ asio_true_handler_type>(), \ static_cast<const boost::system::error_code>(0), \ static_cast<const range_type>(0))) == 1, \ "ResolveHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ boost::asio::detail::rvref< \ asio_true_handler_type>())) + \ sizeof( \ boost::asio::detail::lvref< \ asio_true_handler_type>()( \ boost::asio::detail::lvref<const boost::system::error_code>(), \ boost::asio::detail::lvref<const range_type>()), \ char(0))> BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_WAIT_HANDLER_CHECK( \ handler_type, handler) \ \ typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ void(boost::system::error_code)) \ asio_true_handler_type; \ \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::one_arg_handler_test( \ boost::asio::detail::rvref< \ asio_true_handler_type>(), \ static_cast<const boost::system::error_code>(0))) == 1, \ "WaitHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ boost::asio::detail::rvref< \ asio_true_handler_type>())) + \ sizeof( \ boost::asio::detail::lvref< \ asio_true_handler_type>()( \ boost::asio::detail::lvref<const boost::system::error_code>()), \ char(0))> BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_SIGNAL_HANDLER_CHECK( \ handler_type, handler) \ \ typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ void(boost::system::error_code, int)) \ asio_true_handler_type; \ \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::two_arg_handler_test( \ boost::asio::detail::rvref< \ asio_true_handler_type>(), \ static_cast<const boost::system::error_code>(0), \ static_cast<const int>(0))) == 1, \ "SignalHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ boost::asio::detail::rvref< \ asio_true_handler_type>())) + \ sizeof( \ boost::asio::detail::lvref< \ asio_true_handler_type>()( \ boost::asio::detail::lvref<const boost::system::error_code>(), \ boost::asio::detail::lvref<const int>()), \ char(0))> BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_HANDSHAKE_HANDLER_CHECK( \ handler_type, handler) \ \ typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ void(boost::system::error_code)) \ asio_true_handler_type; \ \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::one_arg_handler_test( \ boost::asio::detail::rvref< \ asio_true_handler_type>(), \ static_cast<const boost::system::error_code>(0))) == 1, \ "HandshakeHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ boost::asio::detail::rvref< \ asio_true_handler_type>())) + \ sizeof( \ boost::asio::detail::lvref< \ asio_true_handler_type>()( \ boost::asio::detail::lvref<const boost::system::error_code>()), \ char(0))> BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_BUFFERED_HANDSHAKE_HANDLER_CHECK( \ handler_type, handler) \ \ typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ void(boost::system::error_code, std::size_t)) \ asio_true_handler_type; \ \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::two_arg_handler_test( \ boost::asio::detail::rvref< \ asio_true_handler_type>(), \ static_cast<const boost::system::error_code>(0), \ static_cast<const std::size_t>(0))) == 1, \ "BufferedHandshakeHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ boost::asio::detail::rvref< \ asio_true_handler_type>())) + \ sizeof( \ boost::asio::detail::lvref< \ asio_true_handler_type>()( \ boost::asio::detail::lvref<const boost::system::error_code>(), \ boost::asio::detail::lvref<const std::size_t>()), \ char(0))> BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_SHUTDOWN_HANDLER_CHECK( \ handler_type, handler) \ \ typedef BOOST_ASIO_HANDLER_TYPE(handler_type, \ void(boost::system::error_code)) \ asio_true_handler_type; \ \ BOOST_ASIO_HANDLER_TYPE_REQUIREMENTS_ASSERT( \ sizeof(boost::asio::detail::one_arg_handler_test( \ boost::asio::detail::rvref< \ asio_true_handler_type>(), \ static_cast<const boost::system::error_code>(0))) == 1, \ "ShutdownHandler type requirements not met") \ \ typedef boost::asio::detail::handler_type_requirements< \ sizeof( \ boost::asio::detail::argbyv( \ boost::asio::detail::rvref< \ asio_true_handler_type>())) + \ sizeof( \ boost::asio::detail::lvref< \ asio_true_handler_type>()( \ boost::asio::detail::lvref<const boost::system::error_code>()), \ char(0))> BOOST_ASIO_UNUSED_TYPEDEF #else // !defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS) #define BOOST_ASIO_LEGACY_COMPLETION_HANDLER_CHECK( \ handler_type, handler) \ typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_READ_HANDLER_CHECK( \ handler_type, handler) \ typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_WRITE_HANDLER_CHECK( \ handler_type, handler) \ typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_ACCEPT_HANDLER_CHECK( \ handler_type, handler) \ typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_MOVE_ACCEPT_HANDLER_CHECK( \ handler_type, handler, socket_type) \ typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_CONNECT_HANDLER_CHECK( \ handler_type, handler) \ typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_RANGE_CONNECT_HANDLER_CHECK( \ handler_type, handler, iter_type) \ typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_ITERATOR_CONNECT_HANDLER_CHECK( \ handler_type, handler, iter_type) \ typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_RESOLVE_HANDLER_CHECK( \ handler_type, handler, iter_type) \ typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_WAIT_HANDLER_CHECK( \ handler_type, handler) \ typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_SIGNAL_HANDLER_CHECK( \ handler_type, handler) \ typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_HANDSHAKE_HANDLER_CHECK( \ handler_type, handler) \ typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_BUFFERED_HANDSHAKE_HANDLER_CHECK( \ handler_type, handler) \ typedef int BOOST_ASIO_UNUSED_TYPEDEF #define BOOST_ASIO_SHUTDOWN_HANDLER_CHECK( \ handler_type, handler) \ typedef int BOOST_ASIO_UNUSED_TYPEDEF #endif // !defined(BOOST_ASIO_ENABLE_HANDLER_TYPE_REQUIREMENTS) } // namespace detail } // namespace asio } // namespace boost #endif // BOOST_ASIO_DETAIL_HANDLER_TYPE_REQUIREMENTS_HPP PK��h!\�]��null_reactor.hppnu��[��// // detail/null_reactor.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_NULL_REACTOR_HPP #define BOOST_ASIO_DETAIL_NULL_REACTOR_HPP #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_HAS_IOCP) \|\| defined(BOOST_ASIO_WINDOWS_RUNTIME) #include <boost/asio/detail/scheduler_operation.hpp> #include <boost/asio/execution_context.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class null_reactor : public execution_context_service_base<null_reactor> { public: // Constructor. null_reactor(boost::asio::execution_context& ctx) : execution_context_service_base<null_reactor>(ctx) { } // Destructor. ~null_reactor() { } // Destroy all user-defined handler objects owned by the service. void shutdown() { } // No-op because should never be called. void run(long /usec/, op_queue<scheduler_operation>& /ops/) { } // No-op. void interrupt() { } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) \|\| defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_NULL_REACTOR_HPP PK��h!\�9!��resolve_query_op.hppnu��[��// // detail/resolve_query_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_RESOLVE_QUERY_OP_HPP #define BOOST_ASIO_DETAIL_RESOLVE_QUERY_OP_HPP #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/detail/bind_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/resolve_op.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/error.hpp> #include <boost/asio/ip/basic_resolver_query.hpp> #include <boost/asio/ip/basic_resolver_results.hpp> #if defined(BOOST_ASIO_HAS_IOCP) # include <boost/asio/detail/win_iocp_io_context.hpp> #else // defined(BOOST_ASIO_HAS_IOCP) # include <boost/asio/detail/scheduler.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Protocol, typename Handler, typename IoExecutor> class resolve_query_op : public resolve_op { public: BOOST_ASIO_DEFINE_HANDLER_PTR(resolve_query_op); typedef boost::asio::ip::basic_resolver_query<Protocol> query_type; typedef boost::asio::ip::basic_resolver_results<Protocol> results_type; #if defined(BOOST_ASIO_HAS_IOCP) typedef class win_iocp_io_context scheduler_impl; #else typedef class scheduler scheduler_impl; #endif resolve_query_op(socket_ops::weak_cancel_token_type cancel_token, const query_type& qry, scheduler_impl& sched, Handler& handler, const IoExecutor& io_ex) : resolve_op(&resolve_query_op::do_complete), cancel_token_(cancel_token), query_(qry), scheduler_(sched), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex), addrinfo_(0) { } ~resolve_query_op() { if (addrinfo_) socket_ops::freeaddrinfo(addrinfo_); } static void do_complete(void owner, operation* base, const boost::system::error_code& /ec/, std::size_t /bytes_transferred/) { // Take ownership of the operation object. resolve_query_op* o(static_cast<resolve_query_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; if (owner && owner != &o->scheduler_) { // The operation is being run on the worker io_context. Time to perform // the resolver operation. // Perform the blocking host resolution operation. socket_ops::background_getaddrinfo(o->cancel_token_, o->query_.host_name().c_str(), o->query_.service_name().c_str(), o->query_.hints(), &o->addrinfo_, o->ec_); // Pass operation back to main io_context for completion. o->scheduler_.post_deferred_completion(o); p.v = p.p = 0; } else { // The operation has been returned to the main io_context. The completion // handler is ready to be delivered. BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); // Make a copy of the handler so that the memory can be deallocated // before the upcall is made. Even if we're not about to make an upcall, // a sub-object of the handler may be the true owner of the memory // associated with the handler. Consequently, a local copy of the handler // is required to ensure that any owning sub-object remains valid until // after we have deallocated the memory here. detail::binder2<Handler, boost::system::error_code, results_type> handler(o->handler_, o->ec_, results_type()); p.h = boost::asio::detail::addressof(handler.handler_); if (o->addrinfo_) { handler.arg2_ = results_type::create(o->addrinfo_, o->query_.host_name(), o->query_.service_name()); } p.reset(); if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "...")); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } } private: socket_ops::weak_cancel_token_type cancel_token_; query_type query_; scheduler_impl& scheduler_; Handler handler_; handler_work<Handler, IoExecutor> work_; boost::asio::detail::addrinfo_type* addrinfo_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_RESOLVE_QUERY_OP_HPP PK��h!\S��s��s��win_iocp_socket_recvmsg_op.hppnu��[��// // detail/win_iocp_socket_recvmsg_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_IOCP_SOCKET_RECVMSG_OP_HPP #define BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_RECVMSG_OP_HPP #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_HAS_IOCP) #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/operation.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/error.hpp> #include <boost/asio/socket_base.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename MutableBufferSequence, typename Handler, typename IoExecutor> class win_iocp_socket_recvmsg_op : public operation { public: BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_socket_recvmsg_op); win_iocp_socket_recvmsg_op( socket_ops::weak_cancel_token_type cancel_token, const MutableBufferSequence& buffers, socket_base::message_flags& out_flags, Handler& handler, const IoExecutor& io_ex) : operation(&win_iocp_socket_recvmsg_op::do_complete), cancel_token_(cancel_token), buffers_(buffers), out_flags_(out_flags), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static void do_complete(void* owner, operation* base, const boost::system::error_code& result_ec, std::size_t bytes_transferred) { boost::system::error_code ec(result_ec); // Take ownership of the operation object. win_iocp_socket_recvmsg_op* o( static_cast<win_iocp_socket_recvmsg_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) // Check whether buffers are still valid. if (owner) { buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence>::validate(o->buffers_); } #endif // defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) socket_ops::complete_iocp_recvmsg(o->cancel_token_, ec); o->out_flags_ = 0; // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, ec, bytes_transferred); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: socket_ops::weak_cancel_token_type cancel_token_; MutableBufferSequence buffers_; socket_base::message_flags& out_flags_; Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #endif // BOOST_ASIO_DETAIL_WIN_IOCP_SOCKET_RECVMSG_OP_HPP PK��h!\��`��<��<��buffer_sequence_adapter.hppnu��[��// // detail/buffer_sequence_adapter.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_BUFFER_SEQUENCE_ADAPTER_HPP #define BOOST_ASIO_DETAIL_BUFFER_SEQUENCE_ADAPTER_HPP #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/buffer.hpp> #include <boost/asio/detail/array_fwd.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class buffer_sequence_adapter_base { #if defined(BOOST_ASIO_WINDOWS_RUNTIME) public: // The maximum number of buffers to support in a single operation. enum { max_buffers = 1 }; protected: typedef Windows::Storage::Streams::IBuffer^ native_buffer_type; BOOST_ASIO_DECL static void init_native_buffer( native_buffer_type& buf, const boost::asio::mutable_buffer& buffer); BOOST_ASIO_DECL static void init_native_buffer( native_buffer_type& buf, const boost::asio::const_buffer& buffer); #elif defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) public: // The maximum number of buffers to support in a single operation. enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len }; protected: typedef WSABUF native_buffer_type; static void init_native_buffer(WSABUF& buf, const boost::asio::mutable_buffer& buffer) { buf.buf = static_cast<char>(buffer.data()); buf.len = static_cast<ULONG>(buffer.size()); } static void init_native_buffer(WSABUF& buf, const boost::asio::const_buffer& buffer) { buf.buf = const_cast<char>(static_cast<const char>(buffer.data())); buf.len = static_cast<ULONG>(buffer.size()); } #else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) public: // The maximum number of buffers to support in a single operation. enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len }; protected: typedef iovec native_buffer_type; static void init_iov_base(void& base, void* addr) { base = addr; } template <typename T> static void init_iov_base(T& base, void* addr) { base = static_cast<T>(addr); } static void init_native_buffer(iovec& iov, const boost::asio::mutable_buffer& buffer) { init_iov_base(iov.iov_base, buffer.data()); iov.iov_len = buffer.size(); } static void init_native_buffer(iovec& iov, const boost::asio::const_buffer& buffer) { init_iov_base(iov.iov_base, const_cast<void>(buffer.data())); iov.iov_len = buffer.size(); } #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) }; // Helper class to translate buffers into the native buffer representation. template <typename Buffer, typename Buffers> class buffer_sequence_adapter : buffer_sequence_adapter_base { public: enum { is_single_buffer = false }; explicit buffer_sequence_adapter(const Buffers& buffer_sequence) : count_(0), total_buffer_size_(0) { buffer_sequence_adapter::init( boost::asio::buffer_sequence_begin(buffer_sequence), boost::asio::buffer_sequence_end(buffer_sequence)); } native_buffer_type buffers() { return buffers_; } std::size_t count() const { return count_; } std::size_t total_size() const { return total_buffer_size_; } bool all_empty() const { return total_buffer_size_ == 0; } static bool all_empty(const Buffers& buffer_sequence) { return buffer_sequence_adapter::all_empty( boost::asio::buffer_sequence_begin(buffer_sequence), boost::asio::buffer_sequence_end(buffer_sequence)); } static void validate(const Buffers& buffer_sequence) { buffer_sequence_adapter::validate( boost::asio::buffer_sequence_begin(buffer_sequence), boost::asio::buffer_sequence_end(buffer_sequence)); } static Buffer first(const Buffers& buffer_sequence) { return buffer_sequence_adapter::first( boost::asio::buffer_sequence_begin(buffer_sequence), boost::asio::buffer_sequence_end(buffer_sequence)); } enum { linearisation_storage_size = 8192 }; static Buffer linearise(const Buffers& buffer_sequence, const boost::asio::mutable_buffer& storage) { return buffer_sequence_adapter::linearise( boost::asio::buffer_sequence_begin(buffer_sequence), boost::asio::buffer_sequence_end(buffer_sequence), storage); } private: template <typename Iterator> void init(Iterator begin, Iterator end) { Iterator iter = begin; for (; iter != end && count_ < max_buffers; ++iter, ++count_) { Buffer buffer(iter); init_native_buffer(buffers_[count_], buffer); total_buffer_size_ += buffer.size(); } } template <typename Iterator> static bool all_empty(Iterator begin, Iterator end) { Iterator iter = begin; std::size_t i = 0; for (; iter != end && i < max_buffers; ++iter, ++i) if (Buffer(iter).size() > 0) return false; return true; } template <typename Iterator> static void validate(Iterator begin, Iterator end) { Iterator iter = begin; for (; iter != end; ++iter) { Buffer buffer(iter); buffer.data(); } } template <typename Iterator> static Buffer first(Iterator begin, Iterator end) { Iterator iter = begin; for (; iter != end; ++iter) { Buffer buffer(iter); if (buffer.size() != 0) return buffer; } return Buffer(); } template <typename Iterator> static Buffer linearise(Iterator begin, Iterator end, const boost::asio::mutable_buffer& storage) { boost::asio::mutable_buffer unused_storage = storage; Iterator iter = begin; while (iter != end && unused_storage.size() != 0) { Buffer buffer(iter); ++iter; if (buffer.size() == 0) continue; if (unused_storage.size() == storage.size()) { if (iter == end) return buffer; if (buffer.size() >= unused_storage.size()) return buffer; } unused_storage += boost::asio::buffer_copy(unused_storage, buffer); } return Buffer(storage.data(), storage.size() - unused_storage.size()); } native_buffer_type buffers_[max_buffers]; std::size_t count_; std::size_t total_buffer_size_; }; template <typename Buffer> class buffer_sequence_adapter<Buffer, boost::asio::mutable_buffer> : buffer_sequence_adapter_base { public: enum { is_single_buffer = true }; explicit buffer_sequence_adapter( const boost::asio::mutable_buffer& buffer_sequence) { init_native_buffer(buffer_, Buffer(buffer_sequence)); total_buffer_size_ = buffer_sequence.size(); } native_buffer_type buffers() { return &buffer_; } std::size_t count() const { return 1; } std::size_t total_size() const { return total_buffer_size_; } bool all_empty() const { return total_buffer_size_ == 0; } static bool all_empty(const boost::asio::mutable_buffer& buffer_sequence) { return buffer_sequence.size() == 0; } static void validate(const boost::asio::mutable_buffer& buffer_sequence) { buffer_sequence.data(); } static Buffer first(const boost::asio::mutable_buffer& buffer_sequence) { return Buffer(buffer_sequence); } enum { linearisation_storage_size = 1 }; static Buffer linearise(const boost::asio::mutable_buffer& buffer_sequence, const Buffer&) { return Buffer(buffer_sequence); } private: native_buffer_type buffer_; std::size_t total_buffer_size_; }; template <typename Buffer> class buffer_sequence_adapter<Buffer, boost::asio::const_buffer> : buffer_sequence_adapter_base { public: enum { is_single_buffer = true }; explicit buffer_sequence_adapter( const boost::asio::const_buffer& buffer_sequence) { init_native_buffer(buffer_, Buffer(buffer_sequence)); total_buffer_size_ = buffer_sequence.size(); } native_buffer_type* buffers() { return &buffer_; } std::size_t count() const { return 1; } std::size_t total_size() const { return total_buffer_size_; } bool all_empty() const { return total_buffer_size_ == 0; } static bool all_empty(const boost::asio::const_buffer& buffer_sequence) { return buffer_sequence.size() == 0; } static void validate(const boost::asio::const_buffer& buffer_sequence) { buffer_sequence.data(); } static Buffer first(const boost::asio::const_buffer& buffer_sequence) { return Buffer(buffer_sequence); } enum { linearisation_storage_size = 1 }; static Buffer linearise(const boost::asio::const_buffer& buffer_sequence, const Buffer&) { return Buffer(buffer_sequence); } private: native_buffer_type buffer_; std::size_t total_buffer_size_; }; #if !defined(BOOST_ASIO_NO_DEPRECATED) template <typename Buffer> class buffer_sequence_adapter<Buffer, boost::asio::mutable_buffers_1> : buffer_sequence_adapter_base { public: enum { is_single_buffer = true }; explicit buffer_sequence_adapter( const boost::asio::mutable_buffers_1& buffer_sequence) { init_native_buffer(buffer_, Buffer(buffer_sequence)); total_buffer_size_ = buffer_sequence.size(); } native_buffer_type* buffers() { return &buffer_; } std::size_t count() const { return 1; } std::size_t total_size() const { return total_buffer_size_; } bool all_empty() const { return total_buffer_size_ == 0; } static bool all_empty(const boost::asio::mutable_buffers_1& buffer_sequence) { return buffer_sequence.size() == 0; } static void validate(const boost::asio::mutable_buffers_1& buffer_sequence) { buffer_sequence.data(); } static Buffer first(const boost::asio::mutable_buffers_1& buffer_sequence) { return Buffer(buffer_sequence); } enum { linearisation_storage_size = 1 }; static Buffer linearise(const boost::asio::mutable_buffers_1& buffer_sequence, const Buffer&) { return Buffer(buffer_sequence); } private: native_buffer_type buffer_; std::size_t total_buffer_size_; }; template <typename Buffer> class buffer_sequence_adapter<Buffer, boost::asio::const_buffers_1> : buffer_sequence_adapter_base { public: enum { is_single_buffer = true }; explicit buffer_sequence_adapter( const boost::asio::const_buffers_1& buffer_sequence) { init_native_buffer(buffer_, Buffer(buffer_sequence)); total_buffer_size_ = buffer_sequence.size(); } native_buffer_type* buffers() { return &buffer_; } std::size_t count() const { return 1; } std::size_t total_size() const { return total_buffer_size_; } bool all_empty() const { return total_buffer_size_ == 0; } static bool all_empty(const boost::asio::const_buffers_1& buffer_sequence) { return buffer_sequence.size() == 0; } static void validate(const boost::asio::const_buffers_1& buffer_sequence) { buffer_sequence.data(); } static Buffer first(const boost::asio::const_buffers_1& buffer_sequence) { return Buffer(buffer_sequence); } enum { linearisation_storage_size = 1 }; static Buffer linearise(const boost::asio::const_buffers_1& buffer_sequence, const Buffer&) { return Buffer(buffer_sequence); } private: native_buffer_type buffer_; std::size_t total_buffer_size_; }; #endif // !defined(BOOST_ASIO_NO_DEPRECATED) template <typename Buffer, typename Elem> class buffer_sequence_adapter<Buffer, boost::array<Elem, 2> > : buffer_sequence_adapter_base { public: enum { is_single_buffer = false }; explicit buffer_sequence_adapter( const boost::array<Elem, 2>& buffer_sequence) { init_native_buffer(buffers_[0], Buffer(buffer_sequence[0])); init_native_buffer(buffers_[1], Buffer(buffer_sequence[1])); total_buffer_size_ = buffer_sequence[0].size() + buffer_sequence[1].size(); } native_buffer_type* buffers() { return buffers_; } std::size_t count() const { return 2; } std::size_t total_size() const { return total_buffer_size_; } bool all_empty() const { return total_buffer_size_ == 0; } static bool all_empty(const boost::array<Elem, 2>& buffer_sequence) { return buffer_sequence[0].size() == 0 && buffer_sequence[1].size() == 0; } static void validate(const boost::array<Elem, 2>& buffer_sequence) { buffer_sequence[0].data(); buffer_sequence[1].data(); } static Buffer first(const boost::array<Elem, 2>& buffer_sequence) { return Buffer(buffer_sequence[0].size() != 0 ? buffer_sequence[0] : buffer_sequence[1]); } enum { linearisation_storage_size = 8192 }; static Buffer linearise(const boost::array<Elem, 2>& buffer_sequence, const boost::asio::mutable_buffer& storage) { if (buffer_sequence[0].size() == 0) return Buffer(buffer_sequence[1]); if (buffer_sequence[1].size() == 0) return Buffer(buffer_sequence[0]); return Buffer(storage.data(), boost::asio::buffer_copy(storage, buffer_sequence)); } private: native_buffer_type buffers_[2]; std::size_t total_buffer_size_; }; #if defined(BOOST_ASIO_HAS_STD_ARRAY) template <typename Buffer, typename Elem> class buffer_sequence_adapter<Buffer, std::array<Elem, 2> > : buffer_sequence_adapter_base { public: enum { is_single_buffer = false }; explicit buffer_sequence_adapter( const std::array<Elem, 2>& buffer_sequence) { init_native_buffer(buffers_[0], Buffer(buffer_sequence[0])); init_native_buffer(buffers_[1], Buffer(buffer_sequence[1])); total_buffer_size_ = buffer_sequence[0].size() + buffer_sequence[1].size(); } native_buffer_type* buffers() { return buffers_; } std::size_t count() const { return 2; } std::size_t total_size() const { return total_buffer_size_; } bool all_empty() const { return total_buffer_size_ == 0; } static bool all_empty(const std::array<Elem, 2>& buffer_sequence) { return buffer_sequence[0].size() == 0 && buffer_sequence[1].size() == 0; } static void validate(const std::array<Elem, 2>& buffer_sequence) { buffer_sequence[0].data(); buffer_sequence[1].data(); } static Buffer first(const std::array<Elem, 2>& buffer_sequence) { return Buffer(buffer_sequence[0].size() != 0 ? buffer_sequence[0] : buffer_sequence[1]); } enum { linearisation_storage_size = 8192 }; static Buffer linearise(const std::array<Elem, 2>& buffer_sequence, const boost::asio::mutable_buffer& storage) { if (buffer_sequence[0].size() == 0) return Buffer(buffer_sequence[1]); if (buffer_sequence[1].size() == 0) return Buffer(buffer_sequence[0]); return Buffer(storage.data(), boost::asio::buffer_copy(storage, buffer_sequence)); } private: native_buffer_type buffers_[2]; std::size_t total_buffer_size_; }; #endif // defined(BOOST_ASIO_HAS_STD_ARRAY) } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/buffer_sequence_adapter.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // BOOST_ASIO_DETAIL_BUFFER_SEQUENCE_ADAPTER_HPP PK��h!\{ޯ��descriptor_ops.hppnu��[��// // detail/descriptor_ops.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_DESCRIPTOR_OPS_HPP #define BOOST_ASIO_DETAIL_DESCRIPTOR_OPS_HPP #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_WINDOWS) \ && !defined(BOOST_ASIO_WINDOWS_RUNTIME) \ && !defined(__CYGWIN__) #include <cstddef> #include <boost/asio/error.hpp> #include <boost/system/error_code.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { namespace descriptor_ops { // Descriptor state bits. enum { // The user wants a non-blocking descriptor. user_set_non_blocking = 1, // The descriptor has been set non-blocking. internal_non_blocking = 2, // Helper "state" used to determine whether the descriptor is non-blocking. non_blocking = user_set_non_blocking \| internal_non_blocking, // The descriptor may have been dup()-ed. possible_dup = 4 }; typedef unsigned char state_type; inline void get_last_error( boost::system::error_code& ec, bool is_error_condition) { if (!is_error_condition) { ec.assign(0, ec.category()); } else { ec = boost::system::error_code(errno, boost::asio::error::get_system_category()); } } BOOST_ASIO_DECL int open(const char* path, int flags, boost::system::error_code& ec); BOOST_ASIO_DECL int close(int d, state_type& state, boost::system::error_code& ec); BOOST_ASIO_DECL bool set_user_non_blocking(int d, state_type& state, bool value, boost::system::error_code& ec); BOOST_ASIO_DECL bool set_internal_non_blocking(int d, state_type& state, bool value, boost::system::error_code& ec); typedef iovec buf; BOOST_ASIO_DECL std::size_t sync_read(int d, state_type state, buf* bufs, std::size_t count, bool all_empty, boost::system::error_code& ec); BOOST_ASIO_DECL std::size_t sync_read1(int d, state_type state, void* data, std::size_t size, boost::system::error_code& ec); BOOST_ASIO_DECL bool non_blocking_read(int d, buf* bufs, std::size_t count, boost::system::error_code& ec, std::size_t& bytes_transferred); BOOST_ASIO_DECL bool non_blocking_read1(int d, void* data, std::size_t size, boost::system::error_code& ec, std::size_t& bytes_transferred); BOOST_ASIO_DECL std::size_t sync_write(int d, state_type state, const buf* bufs, std::size_t count, bool all_empty, boost::system::error_code& ec); BOOST_ASIO_DECL std::size_t sync_write1(int d, state_type state, const void* data, std::size_t size, boost::system::error_code& ec); BOOST_ASIO_DECL bool non_blocking_write(int d, const buf* bufs, std::size_t count, boost::system::error_code& ec, std::size_t& bytes_transferred); BOOST_ASIO_DECL bool non_blocking_write1(int d, const void* data, std::size_t size, boost::system::error_code& ec, std::size_t& bytes_transferred); BOOST_ASIO_DECL int ioctl(int d, state_type& state, long cmd, ioctl_arg_type* arg, boost::system::error_code& ec); BOOST_ASIO_DECL int fcntl(int d, int cmd, boost::system::error_code& ec); BOOST_ASIO_DECL int fcntl(int d, int cmd, long arg, boost::system::error_code& ec); BOOST_ASIO_DECL int poll_read(int d, state_type state, boost::system::error_code& ec); BOOST_ASIO_DECL int poll_write(int d, state_type state, boost::system::error_code& ec); BOOST_ASIO_DECL int poll_error(int d, state_type state, boost::system::error_code& ec); } // namespace descriptor_ops } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/descriptor_ops.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // !defined(BOOST_ASIO_WINDOWS) // && !defined(BOOST_ASIO_WINDOWS_RUNTIME) // && !defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_DESCRIPTOR_OPS_HPP PK��h!\�SB��B��resolve_op.hppnu��[��// // detail/resolve_op.hpp // ~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_RESOLVE_OP_HPP #define BOOST_ASIO_DETAIL_RESOLVE_OP_HPP #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/error.hpp> #include <boost/asio/detail/operation.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class resolve_op : public operation { public: // The error code to be passed to the completion handler. boost::system::error_code ec_; protected: resolve_op(func_type complete_func) : operation(complete_func) { } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_RESOLVE_OP_HPP PK��h!\V�g�[��[��io_control.hppnu��[��// // detail/io_control.hpp // ~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_IO_CONTROL_HPP #define BOOST_ASIO_DETAIL_IO_CONTROL_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <cstddef> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { namespace io_control { // I/O control command for getting number of bytes available. class bytes_readable { public: // Default constructor. bytes_readable() : value_(0) { } // Construct with a specific command value. bytes_readable(std::size_t value) : value_(static_cast<detail::ioctl_arg_type>(value)) { } // Get the name of the IO control command. int name() const { return static_cast<int>(BOOST_ASIO_OS_DEF(FIONREAD)); } // Set the value of the I/O control command. void set(std::size_t value) { value_ = static_cast<detail::ioctl_arg_type>(value); } // Get the current value of the I/O control command. std::size_t get() const { return static_cast<std::size_t>(value_); } // Get the address of the command data. detail::ioctl_arg_type* data() { return &value_; } // Get the address of the command data. const detail::ioctl_arg_type* data() const { return &value_; } private: detail::ioctl_arg_type value_; }; } // namespace io_control } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_IO_CONTROL_HPP PK��h!\yKcm"��m"��select_reactor.hppnu��[��// // detail/select_reactor.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_SELECT_REACTOR_HPP #define BOOST_ASIO_DETAIL_SELECT_REACTOR_HPP #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_HAS_IOCP) \ \|\| (!defined(BOOST_ASIO_HAS_DEV_POLL) \ && !defined(BOOST_ASIO_HAS_EPOLL) \ && !defined(BOOST_ASIO_HAS_KQUEUE) \ && !defined(BOOST_ASIO_WINDOWS_RUNTIME)) #include <cstddef> #include <boost/asio/detail/fd_set_adapter.hpp> #include <boost/asio/detail/limits.hpp> #include <boost/asio/detail/mutex.hpp> #include <boost/asio/detail/op_queue.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/reactor_op_queue.hpp> #include <boost/asio/detail/select_interrupter.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/timer_queue_base.hpp> #include <boost/asio/detail/timer_queue_set.hpp> #include <boost/asio/detail/wait_op.hpp> #include <boost/asio/execution_context.hpp> #if defined(BOOST_ASIO_HAS_IOCP) # include <boost/asio/detail/thread.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class select_reactor : public execution_context_service_base<select_reactor> { public: #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) enum op_types { read_op = 0, write_op = 1, except_op = 2, max_select_ops = 3, connect_op = 3, max_ops = 4 }; #else // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) enum op_types { read_op = 0, write_op = 1, except_op = 2, max_select_ops = 3, connect_op = 1, max_ops = 3 }; #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) // Per-descriptor data. struct per_descriptor_data { }; // Constructor. BOOST_ASIO_DECL select_reactor(boost::asio::execution_context& ctx); // Destructor. BOOST_ASIO_DECL ~select_reactor(); // Destroy all user-defined handler objects owned by the service. BOOST_ASIO_DECL void shutdown(); // Recreate internal descriptors following a fork. BOOST_ASIO_DECL void notify_fork( boost::asio::execution_context::fork_event fork_ev); // Initialise the task, but only if the reactor is not in its own thread. BOOST_ASIO_DECL void init_task(); // Register a socket with the reactor. Returns 0 on success, system error // code on failure. BOOST_ASIO_DECL int register_descriptor(socket_type, per_descriptor_data&); // Register a descriptor with an associated single operation. Returns 0 on // success, system error code on failure. BOOST_ASIO_DECL int register_internal_descriptor( int op_type, socket_type descriptor, per_descriptor_data& descriptor_data, reactor_op* op); // Post a reactor operation for immediate completion. void post_immediate_completion(reactor_op* op, bool is_continuation) { scheduler_.post_immediate_completion(op, is_continuation); } // Start a new operation. The reactor operation will be performed when the // given descriptor is flagged as ready, or an error has occurred. BOOST_ASIO_DECL void start_op(int op_type, socket_type descriptor, per_descriptor_data&, reactor_op* op, bool is_continuation, bool); // Cancel all operations associated with the given descriptor. The // handlers associated with the descriptor will be invoked with the // operation_aborted error. BOOST_ASIO_DECL void cancel_ops(socket_type descriptor, per_descriptor_data&); // Cancel any operations that are running against the descriptor and remove // its registration from the reactor. The reactor resources associated with // the descriptor must be released by calling cleanup_descriptor_data. BOOST_ASIO_DECL void deregister_descriptor(socket_type descriptor, per_descriptor_data&, bool closing); // Remove the descriptor's registration from the reactor. The reactor // resources associated with the descriptor must be released by calling // cleanup_descriptor_data. BOOST_ASIO_DECL void deregister_internal_descriptor( socket_type descriptor, per_descriptor_data&); // Perform any post-deregistration cleanup tasks associated with the // descriptor data. BOOST_ASIO_DECL void cleanup_descriptor_data(per_descriptor_data&); // Move descriptor registration from one descriptor_data object to another. BOOST_ASIO_DECL void move_descriptor(socket_type descriptor, per_descriptor_data& target_descriptor_data, per_descriptor_data& source_descriptor_data); // Add a new timer queue to the reactor. template <typename Time_Traits> void add_timer_queue(timer_queue<Time_Traits>& queue); // Remove a timer queue from the reactor. template <typename Time_Traits> void remove_timer_queue(timer_queue<Time_Traits>& queue); // Schedule a new operation in the given timer queue to expire at the // specified absolute time. template <typename Time_Traits> void schedule_timer(timer_queue<Time_Traits>& queue, const typename Time_Traits::time_type& time, typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op); // Cancel the timer operations associated with the given token. Returns the // number of operations that have been posted or dispatched. template <typename Time_Traits> std::size_t cancel_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& timer, std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)()); // Move the timer operations associated with the given timer. template <typename Time_Traits> void move_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& target, typename timer_queue<Time_Traits>::per_timer_data& source); // Run select once until interrupted or events are ready to be dispatched. BOOST_ASIO_DECL void run(long usec, op_queue<operation>& ops); // Interrupt the select loop. BOOST_ASIO_DECL void interrupt(); private: #if defined(BOOST_ASIO_HAS_IOCP) // Run the select loop in the thread. BOOST_ASIO_DECL void run_thread(); #endif // defined(BOOST_ASIO_HAS_IOCP) // Helper function to add a new timer queue. BOOST_ASIO_DECL void do_add_timer_queue(timer_queue_base& queue); // Helper function to remove a timer queue. BOOST_ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue); // Get the timeout value for the select call. BOOST_ASIO_DECL timeval* get_timeout(long usec, timeval& tv); // Cancel all operations associated with the given descriptor. This function // does not acquire the select_reactor's mutex. BOOST_ASIO_DECL void cancel_ops_unlocked(socket_type descriptor, const boost::system::error_code& ec); // The scheduler implementation used to post completions. # if defined(BOOST_ASIO_HAS_IOCP) typedef class win_iocp_io_context scheduler_type; # else // defined(BOOST_ASIO_HAS_IOCP) typedef class scheduler scheduler_type; # endif // defined(BOOST_ASIO_HAS_IOCP) scheduler_type& scheduler_; // Mutex to protect access to internal data. boost::asio::detail::mutex mutex_; // The interrupter is used to break a blocking select call. select_interrupter interrupter_; // The queues of read, write and except operations. reactor_op_queue<socket_type> op_queue_[max_ops]; // The file descriptor sets to be passed to the select system call. fd_set_adapter fd_sets_[max_select_ops]; // The timer queues. timer_queue_set timer_queues_; #if defined(BOOST_ASIO_HAS_IOCP) // Helper class to run the reactor loop in a thread. class thread_function; friend class thread_function; // Does the reactor loop thread need to stop. bool stop_thread_; // The thread that is running the reactor loop. boost::asio::detail::thread* thread_; #endif // defined(BOOST_ASIO_HAS_IOCP) // Whether the service has been shut down. bool shutdown_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #include <boost/asio/detail/impl/select_reactor.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/select_reactor.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_HAS_IOCP) // \|\| (!defined(BOOST_ASIO_HAS_DEV_POLL) // && !defined(BOOST_ASIO_HAS_EPOLL) // && !defined(BOOST_ASIO_HAS_KQUEUE) // && !defined(BOOST_ASIO_WINDOWS_RUNTIME)) #endif // BOOST_ASIO_DETAIL_SELECT_REACTOR_HPP PK��h!\�31��null_static_mutex.hppnu��[��// // detail/null_static_mutex.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_NULL_STATIC_MUTEX_HPP #define BOOST_ASIO_DETAIL_NULL_STATIC_MUTEX_HPP #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_HAS_THREADS) #include <boost/asio/detail/scoped_lock.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { struct null_static_mutex { typedef boost::asio::detail::scoped_lock<null_static_mutex> scoped_lock; // Initialise the mutex. void init() { } // Lock the mutex. void lock() { } // Unlock the mutex. void unlock() { } int unused_; }; #define BOOST_ASIO_NULL_STATIC_MUTEX_INIT { 0 } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // !defined(BOOST_ASIO_HAS_THREADS) #endif // BOOST_ASIO_DETAIL_NULL_STATIC_MUTEX_HPP PK��h!\A/��descriptor_write_op.hppnu��[��// // detail/descriptor_write_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_DESCRIPTOR_WRITE_OP_HPP #define BOOST_ASIO_DETAIL_DESCRIPTOR_WRITE_OP_HPP #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_WINDOWS) && !defined(__CYGWIN__) #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/descriptor_ops.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename ConstBufferSequence> class descriptor_write_op_base : public reactor_op { public: descriptor_write_op_base(const boost::system::error_code& success_ec, int descriptor, const ConstBufferSequence& buffers, func_type complete_func) : reactor_op(success_ec, &descriptor_write_op_base::do_perform, complete_func), descriptor_(descriptor), buffers_(buffers) { } static status do_perform(reactor_op* base) { descriptor_write_op_base* o(static_cast<descriptor_write_op_base>(base)); typedef buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence> bufs_type; status result; if (bufs_type::is_single_buffer) { result = descriptor_ops::non_blocking_write1(o->descriptor_, bufs_type::first(o->buffers_).data(), bufs_type::first(o->buffers_).size(), o->ec_, o->bytes_transferred_) ? done : not_done; } else { bufs_type bufs(o->buffers_); result = descriptor_ops::non_blocking_write(o->descriptor_, bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_) ? done : not_done; } BOOST_ASIO_HANDLER_REACTOR_OPERATION((o, "non_blocking_write", o->ec_, o->bytes_transferred_)); return result; } private: int descriptor_; ConstBufferSequence buffers_; }; template <typename ConstBufferSequence, typename Handler, typename IoExecutor> class descriptor_write_op : public descriptor_write_op_base<ConstBufferSequence> { public: BOOST_ASIO_DEFINE_HANDLER_PTR(descriptor_write_op); descriptor_write_op(const boost::system::error_code& success_ec, int descriptor, const ConstBufferSequence& buffers, Handler& handler, const IoExecutor& io_ex) : descriptor_write_op_base<ConstBufferSequence>(success_ec, descriptor, buffers, &descriptor_write_op::do_complete), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static void do_complete(void* owner, operation* base, const boost::system::error_code& /ec/, std::size_t /bytes_transferred/) { // Take ownership of the handler object. descriptor_write_op* o(static_cast<descriptor_write_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, o->ec_, o->bytes_transferred_); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_DESCRIPTOR_WRITE_OP_HPP PK��h!\G&�� winrt_utils.hppnu��[��// // detail/winrt_utils.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WINRT_UTILS_HPP #define BOOST_ASIO_DETAIL_WINRT_UTILS_HPP #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_WINDOWS_RUNTIME) #include <codecvt> #include <cstdlib> #include <future> #include <locale> #include <robuffer.h> #include <windows.storage.streams.h> #include <wrl/implements.h> #include <boost/asio/buffer.hpp> #include <boost/system/error_code.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { namespace winrt_utils { inline Platform::String^ string(const char* from) { std::wstring tmp(from, from + std::strlen(from)); return ref new Platform::String(tmp.c_str()); } inline Platform::String^ string(const std::string& from) { std::wstring tmp(from.begin(), from.end()); return ref new Platform::String(tmp.c_str()); } inline std::string string(Platform::String^ from) { std::wstring_convert<std::codecvt_utf8<wchar_t>> converter; return converter.to_bytes(from->Data()); } inline Platform::String^ string(unsigned short from) { return string(std::to_string(from)); } template <typename T> inline Platform::String^ string(const T& from) { return string(from.to_string()); } inline int integer(Platform::String^ from) { return _wtoi(from->Data()); } template <typename T> inline Windows::Networking::HostName^ host_name(const T& from) { return ref new Windows::Networking::HostName((string)(from)); } template <typename ConstBufferSequence> inline Windows::Storage::Streams::IBuffer^ buffer_dup( const ConstBufferSequence& buffers) { using Microsoft::WRL::ComPtr; using boost::asio::buffer_size; std::size_t size = buffer_size(buffers); auto b = ref new Windows::Storage::Streams::Buffer(size); ComPtr<IInspectable> insp = reinterpret_cast<IInspectable>(b); ComPtr<Windows::Storage::Streams::IBufferByteAccess> bacc; insp.As(&bacc); byte bytes = nullptr; bacc->Buffer(&bytes); boost::asio::buffer_copy(boost::asio::buffer(bytes, size), buffers); b->Length = size; return b; } } // namespace winrt_utils } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_WINRT_UTILS_HPP PK��h!\��(r��r��win_iocp_overlapped_op.hppnu��[��// // detail/win_iocp_overlapped_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_IOCP_OVERLAPPED_OP_HPP #define BOOST_ASIO_DETAIL_WIN_IOCP_OVERLAPPED_OP_HPP #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_HAS_IOCP) #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/operation.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Handler, typename IoExecutor> class win_iocp_overlapped_op : public operation { public: BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_overlapped_op); win_iocp_overlapped_op(Handler& handler, const IoExecutor& io_ex) : operation(&win_iocp_overlapped_op::do_complete), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static void do_complete(void* owner, operation* base, const boost::system::error_code& ec, std::size_t bytes_transferred) { // Take ownership of the operation object. win_iocp_overlapped_op* o(static_cast<win_iocp_overlapped_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, ec, bytes_transferred); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #endif // BOOST_ASIO_DETAIL_WIN_IOCP_OVERLAPPED_OP_HPP PK��h!\�� reactive_socket_accept_op.hppnu��[��// // detail/reactive_socket_accept_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_REACTIVE_SOCKET_ACCEPT_OP_HPP #define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_ACCEPT_OP_HPP #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/detail/bind_handler.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/socket_holder.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Socket, typename Protocol> class reactive_socket_accept_op_base : public reactor_op { public: reactive_socket_accept_op_base(const boost::system::error_code& success_ec, socket_type socket, socket_ops::state_type state, Socket& peer, const Protocol& protocol, typename Protocol::endpoint* peer_endpoint, func_type complete_func) : reactor_op(success_ec, &reactive_socket_accept_op_base::do_perform, complete_func), socket_(socket), state_(state), peer_(peer), protocol_(protocol), peer_endpoint_(peer_endpoint), addrlen_(peer_endpoint ? peer_endpoint->capacity() : 0) { } static status do_perform(reactor_op* base) { reactive_socket_accept_op_base* o( static_cast<reactive_socket_accept_op_base>(base)); socket_type new_socket = invalid_socket; status result = socket_ops::non_blocking_accept(o->socket_, o->state_, o->peer_endpoint_ ? o->peer_endpoint_->data() : 0, o->peer_endpoint_ ? &o->addrlen_ : 0, o->ec_, new_socket) ? done : not_done; o->new_socket_.reset(new_socket); BOOST_ASIO_HANDLER_REACTOR_OPERATION((o, "non_blocking_accept", o->ec_)); return result; } void do_assign() { if (new_socket_.get() != invalid_socket) { if (peer_endpoint_) peer_endpoint_->resize(addrlen_); peer_.assign(protocol_, new_socket_.get(), ec_); if (!ec_) new_socket_.release(); } } private: socket_type socket_; socket_ops::state_type state_; socket_holder new_socket_; Socket& peer_; Protocol protocol_; typename Protocol::endpoint* peer_endpoint_; std::size_t addrlen_; }; template <typename Socket, typename Protocol, typename Handler, typename IoExecutor> class reactive_socket_accept_op : public reactive_socket_accept_op_base<Socket, Protocol> { public: BOOST_ASIO_DEFINE_HANDLER_PTR(reactive_socket_accept_op); reactive_socket_accept_op(const boost::system::error_code& success_ec, socket_type socket, socket_ops::state_type state, Socket& peer, const Protocol& protocol, typename Protocol::endpoint* peer_endpoint, Handler& handler, const IoExecutor& io_ex) : reactive_socket_accept_op_base<Socket, Protocol>( success_ec, socket, state, peer, protocol, peer_endpoint, &reactive_socket_accept_op::do_complete), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static void do_complete(void* owner, operation* base, const boost::system::error_code& /ec/, std::size_t /bytes_transferred/) { // Take ownership of the handler object. reactive_socket_accept_op* o(static_cast<reactive_socket_accept_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; // On success, assign new connection to peer socket object. if (owner) o->do_assign(); BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder1<Handler, boost::system::error_code> handler(o->handler_, o->ec_); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: Handler handler_; handler_work<Handler, IoExecutor> work_; }; #if defined(BOOST_ASIO_HAS_MOVE) template <typename Protocol, typename PeerIoExecutor, typename Handler, typename IoExecutor> class reactive_socket_move_accept_op : private Protocol::socket::template rebind_executor<PeerIoExecutor>::other, public reactive_socket_accept_op_base< typename Protocol::socket::template rebind_executor<PeerIoExecutor>::other, Protocol> { public: BOOST_ASIO_DEFINE_HANDLER_PTR(reactive_socket_move_accept_op); reactive_socket_move_accept_op(const boost::system::error_code& success_ec, const PeerIoExecutor& peer_io_ex, socket_type socket, socket_ops::state_type state, const Protocol& protocol, typename Protocol::endpoint* peer_endpoint, Handler& handler, const IoExecutor& io_ex) : peer_socket_type(peer_io_ex), reactive_socket_accept_op_base<peer_socket_type, Protocol>( success_ec, socket, state, this, protocol, peer_endpoint, &reactive_socket_move_accept_op::do_complete), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static void do_complete(void owner, operation* base, const boost::system::error_code& /ec/, std::size_t /bytes_transferred/) { // Take ownership of the handler object. reactive_socket_move_accept_op* o( static_cast<reactive_socket_move_accept_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; // On success, assign new connection to peer socket object. if (owner) o->do_assign(); BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::move_binder2<Handler, boost::system::error_code, peer_socket_type> handler(0, BOOST_ASIO_MOVE_CAST(Handler)(o->handler_), o->ec_, BOOST_ASIO_MOVE_CAST(peer_socket_type)(o)); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, "...")); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: typedef typename Protocol::socket::template rebind_executor<PeerIoExecutor>::other peer_socket_type; Handler handler_; handler_work<Handler, IoExecutor> work_; }; #endif // defined(BOOST_ASIO_HAS_MOVE) } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_ACCEPT_OP_HPP PK��h!\0�G� �� eventfd_select_interrupter.hppnu��[��// // detail/eventfd_select_interrupter.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2008 Roelof Naude (roelof.naude at gmail 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_DETAIL_EVENTFD_SELECT_INTERRUPTER_HPP #define BOOST_ASIO_DETAIL_EVENTFD_SELECT_INTERRUPTER_HPP #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_HAS_EVENTFD) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class eventfd_select_interrupter { public: // Constructor. BOOST_ASIO_DECL eventfd_select_interrupter(); // Destructor. BOOST_ASIO_DECL ~eventfd_select_interrupter(); // Recreate the interrupter's descriptors. Used after a fork. BOOST_ASIO_DECL void recreate(); // Interrupt the select call. BOOST_ASIO_DECL void interrupt(); // Reset the select interrupter. Returns true if the reset was successful. BOOST_ASIO_DECL bool reset(); // Get the read descriptor to be passed to select. int read_descriptor() const { return read_descriptor_; } private: // Open the descriptors. Throws on error. BOOST_ASIO_DECL void open_descriptors(); // Close the descriptors. BOOST_ASIO_DECL void close_descriptors(); // The read end of a connection used to interrupt the select call. This file // descriptor is passed to select such that when it is time to stop, a single // 64bit value will be written on the other end of the connection and this // descriptor will become readable. int read_descriptor_; // The write end of a connection used to interrupt the select call. A single // 64bit non-zero value may be written to this to wake up the select which is // waiting for the other end to become readable. This descriptor will only // differ from the read descriptor when a pipe is used. int write_descriptor_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/eventfd_select_interrupter.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_HAS_EVENTFD) #endif // BOOST_ASIO_DETAIL_EVENTFD_SELECT_INTERRUPTER_HPP PK��h!\J�aOd��d��executor_function.hppnu��[��// // detail/executor_function.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_EXECUTOR_FUNCTION_HPP #define BOOST_ASIO_DETAIL_EXECUTOR_FUNCTION_HPP #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/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { #if defined(BOOST_ASIO_HAS_MOVE) // Lightweight, move-only function object wrapper. class executor_function { public: template <typename F, typename Alloc> explicit executor_function(F f, const Alloc& a) { // Allocate and construct an object to wrap the function. typedef impl<F, Alloc> impl_type; typename impl_type::ptr p = { detail::addressof(a), impl_type::ptr::allocate(a), 0 }; impl_ = new (p.v) impl_type(BOOST_ASIO_MOVE_CAST(F)(f), a); p.v = 0; } executor_function(executor_function&& other) BOOST_ASIO_NOEXCEPT : impl_(other.impl_) { other.impl_ = 0; } ~executor_function() { if (impl_) impl_->complete_(impl_, false); } void operator()() { if (impl_) { impl_base i = impl_; impl_ = 0; i->complete_(i, true); } } private: // Base class for polymorphic function implementations. struct impl_base { void (complete_)(impl_base, bool); }; // Polymorphic function implementation. template <typename Function, typename Alloc> struct impl : impl_base { BOOST_ASIO_DEFINE_TAGGED_HANDLER_ALLOCATOR_PTR( thread_info_base::executor_function_tag, impl); template <typename F> impl(BOOST_ASIO_MOVE_ARG(F) f, const Alloc& a) : function_(BOOST_ASIO_MOVE_CAST(F)(f)), allocator_(a) { complete_ = &executor_function::complete<Function, Alloc>; } Function function_; Alloc allocator_; }; // Helper to complete function invocation. template <typename Function, typename Alloc> static void complete(impl_base* base, bool call) { // Take ownership of the function object. impl<Function, Alloc>* i(static_cast<impl<Function, Alloc>>(base)); Alloc allocator(i->allocator_); typename impl<Function, Alloc>::ptr p = { detail::addressof(allocator), i, i }; // Make a copy of the function so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the function may be the true owner of the memory // associated with the function. Consequently, a local copy of the function // is required to ensure that any owning sub-object remains valid until // after we have deallocated the memory here. Function function(BOOST_ASIO_MOVE_CAST(Function)(i->function_)); p.reset(); // Make the upcall if required. if (call) { boost_asio_handler_invoke_helpers::invoke(function, function); } } impl_base impl_; }; #else // defined(BOOST_ASIO_HAS_MOVE) // Not so lightweight, copyable function object wrapper. class executor_function { public: template <typename F, typename Alloc> explicit executor_function(const F& f, const Alloc&) : impl_(new impl<typename decay<F>::type>(f)) { } void operator()() { impl_->complete_(impl_.get()); } private: // Base class for polymorphic function implementations. struct impl_base { void (complete_)(impl_base); }; // Polymorphic function implementation. template <typename F> struct impl : impl_base { impl(const F& f) : function_(f) { complete_ = &executor_function::complete<F>; } F function_; }; // Helper to complete function invocation. template <typename F> static void complete(impl_base* i) { static_cast<impl<F>>(i)->function_(); } shared_ptr<impl_base> impl_; }; #endif // defined(BOOST_ASIO_HAS_MOVE) // Lightweight, non-owning, copyable function object wrapper. class executor_function_view { public: template <typename F> explicit executor_function_view(F& f) BOOST_ASIO_NOEXCEPT : complete_(&executor_function_view::complete<F>), function_(&f) { } void operator()() { complete_(function_); } private: // Helper to complete function invocation. template <typename F> static void complete(void f) { (static_cast<F>(f))(); } void (complete_)(void); void* function_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_EXECUTOR_FUNCTION_HPP PK��h!\�]��null_fenced_block.hppnu��[��// // detail/null_fenced_block.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_NULL_FENCED_BLOCK_HPP #define BOOST_ASIO_DETAIL_NULL_FENCED_BLOCK_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class null_fenced_block : private noncopyable { public: enum half_or_full_t { half, full }; // Constructor. explicit null_fenced_block(half_or_full_t) { } // Destructor. ~null_fenced_block() { } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_NULL_FENCED_BLOCK_HPP PK��h!\p}�x��reactor_op.hppnu��[��// // detail/reactor_op.hpp // ~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_REACTOR_OP_HPP #define BOOST_ASIO_DETAIL_REACTOR_OP_HPP #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/detail/operation.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class reactor_op : public operation { public: // The error code to be passed to the completion handler. boost::system::error_code ec_; // The number of bytes transferred, to be passed to the completion handler. std::size_t bytes_transferred_; // Status returned by perform function. May be used to decide whether it is // worth performing more operations on the descriptor immediately. enum status { not_done, done, done_and_exhausted }; // Perform the operation. Returns true if it is finished. status perform() { return perform_func_(this); } protected: typedef status (perform_func_type)(reactor_op); reactor_op(const boost::system::error_code& success_ec, perform_func_type perform_func, func_type complete_func) : operation(complete_func), ec_(success_ec), bytes_transferred_(0), perform_func_(perform_func) { } private: perform_func_type perform_func_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_REACTOR_OP_HPP PK��h!\x��@#��@#��winrt_async_manager.hppnu��[��// // detail/winrt_async_manager.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WINRT_ASYNC_MANAGER_HPP #define BOOST_ASIO_DETAIL_WINRT_ASYNC_MANAGER_HPP #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_WINDOWS_RUNTIME) #include <future> #include <boost/asio/detail/atomic_count.hpp> #include <boost/asio/detail/winrt_async_op.hpp> #include <boost/asio/error.hpp> #include <boost/asio/execution_context.hpp> #if defined(BOOST_ASIO_HAS_IOCP) # include <boost/asio/detail/win_iocp_io_context.hpp> #else // defined(BOOST_ASIO_HAS_IOCP) # include <boost/asio/detail/scheduler.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class winrt_async_manager : public execution_context_service_base<winrt_async_manager> { public: // Constructor. winrt_async_manager(execution_context& context) : execution_context_service_base<winrt_async_manager>(context), scheduler_(use_service<scheduler_impl>(context)), outstanding_ops_(1) { } // Destructor. ~winrt_async_manager() { } // Destroy all user-defined handler objects owned by the service. void shutdown() { if (--outstanding_ops_ > 0) { // Block until last operation is complete. std::future<void> f = promise_.get_future(); f.wait(); } } void sync(Windows::Foundation::IAsyncAction^ action, boost::system::error_code& ec) { using namespace Windows::Foundation; using Windows::Foundation::AsyncStatus; auto promise = std::make_shared<std::promise<boost::system::error_code>>(); auto future = promise->get_future(); action->Completed = ref new AsyncActionCompletedHandler( [promise](IAsyncAction^ action, AsyncStatus status) { switch (status) { case AsyncStatus::Canceled: promise->set_value(boost::asio::error::operation_aborted); break; case AsyncStatus::Error: case AsyncStatus::Completed: default: boost::system::error_code ec( action->ErrorCode.Value, boost::system::system_category()); promise->set_value(ec); break; } }); ec = future.get(); } template <typename TResult> TResult sync(Windows::Foundation::IAsyncOperation<TResult>^ operation, boost::system::error_code& ec) { using namespace Windows::Foundation; using Windows::Foundation::AsyncStatus; auto promise = std::make_shared<std::promise<boost::system::error_code>>(); auto future = promise->get_future(); operation->Completed = ref new AsyncOperationCompletedHandler<TResult>( [promise](IAsyncOperation<TResult>^ operation, AsyncStatus status) { switch (status) { case AsyncStatus::Canceled: promise->set_value(boost::asio::error::operation_aborted); break; case AsyncStatus::Error: case AsyncStatus::Completed: default: boost::system::error_code ec( operation->ErrorCode.Value, boost::system::system_category()); promise->set_value(ec); break; } }); ec = future.get(); return operation->GetResults(); } template <typename TResult, typename TProgress> TResult sync( Windows::Foundation::IAsyncOperationWithProgress< TResult, TProgress>^ operation, boost::system::error_code& ec) { using namespace Windows::Foundation; using Windows::Foundation::AsyncStatus; auto promise = std::make_shared<std::promise<boost::system::error_code>>(); auto future = promise->get_future(); operation->Completed = ref new AsyncOperationWithProgressCompletedHandler<TResult, TProgress>( [promise](IAsyncOperationWithProgress<TResult, TProgress>^ operation, AsyncStatus status) { switch (status) { case AsyncStatus::Canceled: promise->set_value(boost::asio::error::operation_aborted); break; case AsyncStatus::Started: break; case AsyncStatus::Error: case AsyncStatus::Completed: default: boost::system::error_code ec( operation->ErrorCode.Value, boost::system::system_category()); promise->set_value(ec); break; } }); ec = future.get(); return operation->GetResults(); } void async(Windows::Foundation::IAsyncAction^ action, winrt_async_op<void>* handler) { using namespace Windows::Foundation; using Windows::Foundation::AsyncStatus; auto on_completed = ref new AsyncActionCompletedHandler( [this, handler](IAsyncAction^ action, AsyncStatus status) { switch (status) { case AsyncStatus::Canceled: handler->ec_ = boost::asio::error::operation_aborted; break; case AsyncStatus::Started: return; case AsyncStatus::Completed: case AsyncStatus::Error: default: handler->ec_ = boost::system::error_code( action->ErrorCode.Value, boost::system::system_category()); break; } scheduler_.post_deferred_completion(handler); if (--outstanding_ops_ == 0) promise_.set_value(); }); scheduler_.work_started(); ++outstanding_ops_; action->Completed = on_completed; } template <typename TResult> void async(Windows::Foundation::IAsyncOperation<TResult>^ operation, winrt_async_op<TResult>* handler) { using namespace Windows::Foundation; using Windows::Foundation::AsyncStatus; auto on_completed = ref new AsyncOperationCompletedHandler<TResult>( [this, handler](IAsyncOperation<TResult>^ operation, AsyncStatus status) { switch (status) { case AsyncStatus::Canceled: handler->ec_ = boost::asio::error::operation_aborted; break; case AsyncStatus::Started: return; case AsyncStatus::Completed: handler->result_ = operation->GetResults(); // Fall through. case AsyncStatus::Error: default: handler->ec_ = boost::system::error_code( operation->ErrorCode.Value, boost::system::system_category()); break; } scheduler_.post_deferred_completion(handler); if (--outstanding_ops_ == 0) promise_.set_value(); }); scheduler_.work_started(); ++outstanding_ops_; operation->Completed = on_completed; } template <typename TResult, typename TProgress> void async( Windows::Foundation::IAsyncOperationWithProgress< TResult, TProgress>^ operation, winrt_async_op<TResult>* handler) { using namespace Windows::Foundation; using Windows::Foundation::AsyncStatus; auto on_completed = ref new AsyncOperationWithProgressCompletedHandler<TResult, TProgress>( [this, handler](IAsyncOperationWithProgress< TResult, TProgress>^ operation, AsyncStatus status) { switch (status) { case AsyncStatus::Canceled: handler->ec_ = boost::asio::error::operation_aborted; break; case AsyncStatus::Started: return; case AsyncStatus::Completed: handler->result_ = operation->GetResults(); // Fall through. case AsyncStatus::Error: default: handler->ec_ = boost::system::error_code( operation->ErrorCode.Value, boost::system::system_category()); break; } scheduler_.post_deferred_completion(handler); if (--outstanding_ops_ == 0) promise_.set_value(); }); scheduler_.work_started(); ++outstanding_ops_; operation->Completed = on_completed; } private: // The scheduler implementation used to post completed handlers. #if defined(BOOST_ASIO_HAS_IOCP) typedef class win_iocp_io_context scheduler_impl; #else typedef class scheduler scheduler_impl; #endif scheduler_impl& scheduler_; // Count of outstanding operations. atomic_count outstanding_ops_; // Used to keep wait for outstanding operations to complete. std::promise<void> promise_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_WINRT_ASYNC_MANAGER_HPP PK��h!\�� timer_queue_set.hppnu��[��// // detail/timer_queue_set.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_TIMER_QUEUE_SET_HPP #define BOOST_ASIO_DETAIL_TIMER_QUEUE_SET_HPP #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/detail/timer_queue_base.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class timer_queue_set { public: // Constructor. BOOST_ASIO_DECL timer_queue_set(); // Add a timer queue to the set. BOOST_ASIO_DECL void insert(timer_queue_base* q); // Remove a timer queue from the set. BOOST_ASIO_DECL void erase(timer_queue_base* q); // Determine whether all queues are empty. BOOST_ASIO_DECL bool all_empty() const; // Get the wait duration in milliseconds. BOOST_ASIO_DECL long wait_duration_msec(long max_duration) const; // Get the wait duration in microseconds. BOOST_ASIO_DECL long wait_duration_usec(long max_duration) const; // Dequeue all ready timers. BOOST_ASIO_DECL void get_ready_timers(op_queue<operation>& ops); // Dequeue all timers. BOOST_ASIO_DECL void get_all_timers(op_queue<operation>& ops); private: timer_queue_base* first_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/timer_queue_set.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // BOOST_ASIO_DETAIL_TIMER_QUEUE_SET_HPP PK��h!\�:��null_global.hppnu��[��// // detail/null_global.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_NULL_GLOBAL_HPP #define BOOST_ASIO_DETAIL_NULL_GLOBAL_HPP #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/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename T> struct null_global_impl { null_global_impl() : ptr_(0) { } // Destructor automatically cleans up the global. ~null_global_impl() { delete ptr_; } static null_global_impl instance_; T ptr_; }; template <typename T> null_global_impl<T> null_global_impl<T>::instance_; template <typename T> T& null_global() { if (null_global_impl<T>::instance_.ptr_ == 0) null_global_impl<T>::instance_.ptr_ = new T; return null_global_impl<T>::instance_.ptr_; } } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_NULL_GLOBAL_HPP PK��h!\7�u��resolver_service_base.hppnu��[��// // detail/resolver_service_base.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_RESOLVER_SERVICE_BASE_HPP #define BOOST_ASIO_DETAIL_RESOLVER_SERVICE_BASE_HPP #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/error.hpp> #include <boost/asio/execution_context.hpp> #include <boost/asio/detail/mutex.hpp> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/resolve_op.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/scoped_ptr.hpp> #include <boost/asio/detail/thread.hpp> #if defined(BOOST_ASIO_HAS_IOCP) # include <boost/asio/detail/win_iocp_io_context.hpp> #else // defined(BOOST_ASIO_HAS_IOCP) # include <boost/asio/detail/scheduler.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class resolver_service_base { public: // The implementation type of the resolver. A cancellation token is used to // indicate to the background thread that the operation has been cancelled. typedef socket_ops::shared_cancel_token_type implementation_type; // Constructor. BOOST_ASIO_DECL resolver_service_base(execution_context& context); // Destructor. BOOST_ASIO_DECL ~resolver_service_base(); // Destroy all user-defined handler objects owned by the service. BOOST_ASIO_DECL void base_shutdown(); // Perform any fork-related housekeeping. BOOST_ASIO_DECL void base_notify_fork( execution_context::fork_event fork_ev); // Construct a new resolver implementation. BOOST_ASIO_DECL void construct(implementation_type& impl); // Destroy a resolver implementation. BOOST_ASIO_DECL void destroy(implementation_type&); // Move-construct a new resolver implementation. BOOST_ASIO_DECL void move_construct(implementation_type& impl, implementation_type& other_impl); // Move-assign from another resolver implementation. BOOST_ASIO_DECL void move_assign(implementation_type& impl, resolver_service_base& other_service, implementation_type& other_impl); // Move-construct a new timer implementation. void converting_move_construct(implementation_type& impl, resolver_service_base&, implementation_type& other_impl) { move_construct(impl, other_impl); } // Move-assign from another timer implementation. void converting_move_assign(implementation_type& impl, resolver_service_base& other_service, implementation_type& other_impl) { move_assign(impl, other_service, other_impl); } // Cancel pending asynchronous operations. BOOST_ASIO_DECL void cancel(implementation_type& impl); protected: // Helper function to start an asynchronous resolve operation. BOOST_ASIO_DECL void start_resolve_op(resolve_op op); #if !defined(BOOST_ASIO_WINDOWS_RUNTIME) // Helper class to perform exception-safe cleanup of addrinfo objects. class auto_addrinfo : private boost::asio::detail::noncopyable { public: explicit auto_addrinfo(boost::asio::detail::addrinfo_type* ai) : ai_(ai) { } ~auto_addrinfo() { if (ai_) socket_ops::freeaddrinfo(ai_); } operator boost::asio::detail::addrinfo_type() { return ai_; } private: boost::asio::detail::addrinfo_type ai_; }; #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) // Helper class to run the work scheduler in a thread. class work_scheduler_runner; // Start the work scheduler if it's not already running. BOOST_ASIO_DECL void start_work_thread(); // The scheduler implementation used to post completions. #if defined(BOOST_ASIO_HAS_IOCP) typedef class win_iocp_io_context scheduler_impl; #else typedef class scheduler scheduler_impl; #endif scheduler_impl& scheduler_; private: // Mutex to protect access to internal data. boost::asio::detail::mutex mutex_; // Private scheduler used for performing asynchronous host resolution. boost::asio::detail::scoped_ptr<scheduler_impl> work_scheduler_; // Thread used for running the work io_context's run loop. boost::asio::detail::scoped_ptr<boost::asio::detail::thread> work_thread_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/resolver_service_base.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // BOOST_ASIO_DETAIL_RESOLVER_SERVICE_BASE_HPP PK��h!\��3��3��variadic_templates.hppnu��[��// // detail/variadic_templates.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_VARIADIC_TEMPLATES_HPP #define BOOST_ASIO_DETAIL_VARIADIC_TEMPLATES_HPP #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_HAS_VARIADIC_TEMPLATES) # define BOOST_ASIO_VARIADIC_TPARAMS(n) BOOST_ASIO_VARIADIC_TPARAMS_##n # define BOOST_ASIO_VARIADIC_TPARAMS_1 \ typename T1 # define BOOST_ASIO_VARIADIC_TPARAMS_2 \ typename T1, typename T2 # define BOOST_ASIO_VARIADIC_TPARAMS_3 \ typename T1, typename T2, typename T3 # define BOOST_ASIO_VARIADIC_TPARAMS_4 \ typename T1, typename T2, typename T3, typename T4 # define BOOST_ASIO_VARIADIC_TPARAMS_5 \ typename T1, typename T2, typename T3, typename T4, typename T5 # define BOOST_ASIO_VARIADIC_TPARAMS_6 \ typename T1, typename T2, typename T3, typename T4, typename T5, \ typename T6 # define BOOST_ASIO_VARIADIC_TPARAMS_7 \ typename T1, typename T2, typename T3, typename T4, typename T5, \ typename T6, typename T7 # define BOOST_ASIO_VARIADIC_TPARAMS_8 \ typename T1, typename T2, typename T3, typename T4, typename T5, \ typename T6, typename T7, typename T8 # define BOOST_ASIO_VARIADIC_TARGS(n) BOOST_ASIO_VARIADIC_TARGS_##n # define BOOST_ASIO_VARIADIC_TARGS_1 T1 # define BOOST_ASIO_VARIADIC_TARGS_2 T1, T2 # define BOOST_ASIO_VARIADIC_TARGS_3 T1, T2, T3 # define BOOST_ASIO_VARIADIC_TARGS_4 T1, T2, T3, T4 # define BOOST_ASIO_VARIADIC_TARGS_5 T1, T2, T3, T4, T5 # define BOOST_ASIO_VARIADIC_TARGS_6 T1, T2, T3, T4, T5, T6 # define BOOST_ASIO_VARIADIC_TARGS_7 T1, T2, T3, T4, T5, T6, T7 # define BOOST_ASIO_VARIADIC_TARGS_8 T1, T2, T3, T4, T5, T6, T7, T8 # define BOOST_ASIO_VARIADIC_BYVAL_PARAMS(n) \ BOOST_ASIO_VARIADIC_BYVAL_PARAMS_##n # define BOOST_ASIO_VARIADIC_BYVAL_PARAMS_1 T1 x1 # define BOOST_ASIO_VARIADIC_BYVAL_PARAMS_2 T1 x1, T2 x2 # define BOOST_ASIO_VARIADIC_BYVAL_PARAMS_3 T1 x1, T2 x2, T3 x3 # define BOOST_ASIO_VARIADIC_BYVAL_PARAMS_4 T1 x1, T2 x2, T3 x3, T4 x4 # define BOOST_ASIO_VARIADIC_BYVAL_PARAMS_5 T1 x1, T2 x2, T3 x3, T4 x4, T5 x5 # define BOOST_ASIO_VARIADIC_BYVAL_PARAMS_6 T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, \ T6 x6 # define BOOST_ASIO_VARIADIC_BYVAL_PARAMS_7 T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, \ T6 x6, T7 x7 # define BOOST_ASIO_VARIADIC_BYVAL_PARAMS_8 T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, \ T6 x6, T7 x7, T8 x8 # define BOOST_ASIO_VARIADIC_BYVAL_ARGS(n) \ BOOST_ASIO_VARIADIC_BYVAL_ARGS_##n # define BOOST_ASIO_VARIADIC_BYVAL_ARGS_1 x1 # define BOOST_ASIO_VARIADIC_BYVAL_ARGS_2 x1, x2 # define BOOST_ASIO_VARIADIC_BYVAL_ARGS_3 x1, x2, x3 # define BOOST_ASIO_VARIADIC_BYVAL_ARGS_4 x1, x2, x3, x4 # define BOOST_ASIO_VARIADIC_BYVAL_ARGS_5 x1, x2, x3, x4, x5 # define BOOST_ASIO_VARIADIC_BYVAL_ARGS_6 x1, x2, x3, x4, x5, x6 # define BOOST_ASIO_VARIADIC_BYVAL_ARGS_7 x1, x2, x3, x4, x5, x6, x7 # define BOOST_ASIO_VARIADIC_BYVAL_ARGS_8 x1, x2, x3, x4, x5, x6, x7, x8 # define BOOST_ASIO_VARIADIC_CONSTREF_PARAMS(n) \ BOOST_ASIO_VARIADIC_CONSTREF_PARAMS_##n # define BOOST_ASIO_VARIADIC_CONSTREF_PARAMS_1 \ const T1& x1 # define BOOST_ASIO_VARIADIC_CONSTREF_PARAMS_2 \ const T1& x1, const T2& x2 # define BOOST_ASIO_VARIADIC_CONSTREF_PARAMS_3 \ const T1& x1, const T2& x2, const T3& x3 # define BOOST_ASIO_VARIADIC_CONSTREF_PARAMS_4 \ const T1& x1, const T2& x2, const T3& x3, const T4& x4 # define BOOST_ASIO_VARIADIC_CONSTREF_PARAMS_5 \ const T1& x1, const T2& x2, const T3& x3, const T4& x4, const T5& x5 # define BOOST_ASIO_VARIADIC_CONSTREF_PARAMS_6 \ const T1& x1, const T2& x2, const T3& x3, const T4& x4, const T5& x5, \ const T6& x6 # define BOOST_ASIO_VARIADIC_CONSTREF_PARAMS_7 \ const T1& x1, const T2& x2, const T3& x3, const T4& x4, const T5& x5, \ const T6& x6, const T7& x7 # define BOOST_ASIO_VARIADIC_CONSTREF_PARAMS_8 \ const T1& x1, const T2& x2, const T3& x3, const T4& x4, const T5& x5, \ const T6& x6, const T7& x7, const T8& x8 # define BOOST_ASIO_VARIADIC_MOVE_PARAMS(n) \ BOOST_ASIO_VARIADIC_MOVE_PARAMS_##n # define BOOST_ASIO_VARIADIC_MOVE_PARAMS_1 \ BOOST_ASIO_MOVE_ARG(T1) x1 # define BOOST_ASIO_VARIADIC_MOVE_PARAMS_2 \ BOOST_ASIO_MOVE_ARG(T1) x1, BOOST_ASIO_MOVE_ARG(T2) x2 # define BOOST_ASIO_VARIADIC_MOVE_PARAMS_3 \ BOOST_ASIO_MOVE_ARG(T1) x1, BOOST_ASIO_MOVE_ARG(T2) x2, \ BOOST_ASIO_MOVE_ARG(T3) x3 # define BOOST_ASIO_VARIADIC_MOVE_PARAMS_4 \ BOOST_ASIO_MOVE_ARG(T1) x1, BOOST_ASIO_MOVE_ARG(T2) x2, \ BOOST_ASIO_MOVE_ARG(T3) x3, BOOST_ASIO_MOVE_ARG(T4) x4 # define BOOST_ASIO_VARIADIC_MOVE_PARAMS_5 \ BOOST_ASIO_MOVE_ARG(T1) x1, BOOST_ASIO_MOVE_ARG(T2) x2, \ BOOST_ASIO_MOVE_ARG(T3) x3, BOOST_ASIO_MOVE_ARG(T4) x4, \ BOOST_ASIO_MOVE_ARG(T5) x5 # define BOOST_ASIO_VARIADIC_MOVE_PARAMS_6 \ BOOST_ASIO_MOVE_ARG(T1) x1, BOOST_ASIO_MOVE_ARG(T2) x2, \ BOOST_ASIO_MOVE_ARG(T3) x3, BOOST_ASIO_MOVE_ARG(T4) x4, \ BOOST_ASIO_MOVE_ARG(T5) x5, BOOST_ASIO_MOVE_ARG(T6) x6 # define BOOST_ASIO_VARIADIC_MOVE_PARAMS_7 \ BOOST_ASIO_MOVE_ARG(T1) x1, BOOST_ASIO_MOVE_ARG(T2) x2, \ BOOST_ASIO_MOVE_ARG(T3) x3, BOOST_ASIO_MOVE_ARG(T4) x4, \ BOOST_ASIO_MOVE_ARG(T5) x5, BOOST_ASIO_MOVE_ARG(T6) x6, \ BOOST_ASIO_MOVE_ARG(T7) x7 # define BOOST_ASIO_VARIADIC_MOVE_PARAMS_8 \ BOOST_ASIO_MOVE_ARG(T1) x1, BOOST_ASIO_MOVE_ARG(T2) x2, \ BOOST_ASIO_MOVE_ARG(T3) x3, BOOST_ASIO_MOVE_ARG(T4) x4, \ BOOST_ASIO_MOVE_ARG(T5) x5, BOOST_ASIO_MOVE_ARG(T6) x6, \ BOOST_ASIO_MOVE_ARG(T7) x7, BOOST_ASIO_MOVE_ARG(T8) x8 # define BOOST_ASIO_VARIADIC_UNNAMED_MOVE_PARAMS(n) \ BOOST_ASIO_VARIADIC_UNNAMED_MOVE_PARAMS_##n # define BOOST_ASIO_VARIADIC_UNNAMED_MOVE_PARAMS_1 \ BOOST_ASIO_MOVE_ARG(T1) # define BOOST_ASIO_VARIADIC_UNNAMED_MOVE_PARAMS_2 \ BOOST_ASIO_MOVE_ARG(T1), BOOST_ASIO_MOVE_ARG(T2) # define BOOST_ASIO_VARIADIC_UNNAMED_MOVE_PARAMS_3 \ BOOST_ASIO_MOVE_ARG(T1), BOOST_ASIO_MOVE_ARG(T2), \ BOOST_ASIO_MOVE_ARG(T3) # define BOOST_ASIO_VARIADIC_UNNAMED_MOVE_PARAMS_4 \ BOOST_ASIO_MOVE_ARG(T1), BOOST_ASIO_MOVE_ARG(T2), \ BOOST_ASIO_MOVE_ARG(T3), BOOST_ASIO_MOVE_ARG(T4) # define BOOST_ASIO_VARIADIC_UNNAMED_MOVE_PARAMS_5 \ BOOST_ASIO_MOVE_ARG(T1), BOOST_ASIO_MOVE_ARG(T2), \ BOOST_ASIO_MOVE_ARG(T3), BOOST_ASIO_MOVE_ARG(T4), \ BOOST_ASIO_MOVE_ARG(T5) # define BOOST_ASIO_VARIADIC_UNNAMED_MOVE_PARAMS_6 \ BOOST_ASIO_MOVE_ARG(T1), BOOST_ASIO_MOVE_ARG(T2), \ BOOST_ASIO_MOVE_ARG(T3), BOOST_ASIO_MOVE_ARG(T4), \ BOOST_ASIO_MOVE_ARG(T5), BOOST_ASIO_MOVE_ARG(T6) # define BOOST_ASIO_VARIADIC_UNNAMED_MOVE_PARAMS_7 \ BOOST_ASIO_MOVE_ARG(T1), BOOST_ASIO_MOVE_ARG(T2), \ BOOST_ASIO_MOVE_ARG(T3), BOOST_ASIO_MOVE_ARG(T4), \ BOOST_ASIO_MOVE_ARG(T5), BOOST_ASIO_MOVE_ARG(T6), \ BOOST_ASIO_MOVE_ARG(T7) # define BOOST_ASIO_VARIADIC_UNNAMED_MOVE_PARAMS_8 \ BOOST_ASIO_MOVE_ARG(T1), BOOST_ASIO_MOVE_ARG(T2), \ BOOST_ASIO_MOVE_ARG(T3), BOOST_ASIO_MOVE_ARG(T4), \ BOOST_ASIO_MOVE_ARG(T5), BOOST_ASIO_MOVE_ARG(T6), \ BOOST_ASIO_MOVE_ARG(T7), BOOST_ASIO_MOVE_ARG(T8) # define BOOST_ASIO_VARIADIC_MOVE_ARGS(n) \ BOOST_ASIO_VARIADIC_MOVE_ARGS_##n # define BOOST_ASIO_VARIADIC_MOVE_ARGS_1 \ BOOST_ASIO_MOVE_CAST(T1)(x1) # define BOOST_ASIO_VARIADIC_MOVE_ARGS_2 \ BOOST_ASIO_MOVE_CAST(T1)(x1), BOOST_ASIO_MOVE_CAST(T2)(x2) # define BOOST_ASIO_VARIADIC_MOVE_ARGS_3 \ BOOST_ASIO_MOVE_CAST(T1)(x1), BOOST_ASIO_MOVE_CAST(T2)(x2), \ BOOST_ASIO_MOVE_CAST(T3)(x3) # define BOOST_ASIO_VARIADIC_MOVE_ARGS_4 \ BOOST_ASIO_MOVE_CAST(T1)(x1), BOOST_ASIO_MOVE_CAST(T2)(x2), \ BOOST_ASIO_MOVE_CAST(T3)(x3), BOOST_ASIO_MOVE_CAST(T4)(x4) # define BOOST_ASIO_VARIADIC_MOVE_ARGS_5 \ BOOST_ASIO_MOVE_CAST(T1)(x1), BOOST_ASIO_MOVE_CAST(T2)(x2), \ BOOST_ASIO_MOVE_CAST(T3)(x3), BOOST_ASIO_MOVE_CAST(T4)(x4), \ BOOST_ASIO_MOVE_CAST(T5)(x5) # define BOOST_ASIO_VARIADIC_MOVE_ARGS_6 \ BOOST_ASIO_MOVE_CAST(T1)(x1), BOOST_ASIO_MOVE_CAST(T2)(x2), \ BOOST_ASIO_MOVE_CAST(T3)(x3), BOOST_ASIO_MOVE_CAST(T4)(x4), \ BOOST_ASIO_MOVE_CAST(T5)(x5), BOOST_ASIO_MOVE_CAST(T6)(x6) # define BOOST_ASIO_VARIADIC_MOVE_ARGS_7 \ BOOST_ASIO_MOVE_CAST(T1)(x1), BOOST_ASIO_MOVE_CAST(T2)(x2), \ BOOST_ASIO_MOVE_CAST(T3)(x3), BOOST_ASIO_MOVE_CAST(T4)(x4), \ BOOST_ASIO_MOVE_CAST(T5)(x5), BOOST_ASIO_MOVE_CAST(T6)(x6), \ BOOST_ASIO_MOVE_CAST(T7)(x7) # define BOOST_ASIO_VARIADIC_MOVE_ARGS_8 \ BOOST_ASIO_MOVE_CAST(T1)(x1), BOOST_ASIO_MOVE_CAST(T2)(x2), \ BOOST_ASIO_MOVE_CAST(T3)(x3), BOOST_ASIO_MOVE_CAST(T4)(x4), \ BOOST_ASIO_MOVE_CAST(T5)(x5), BOOST_ASIO_MOVE_CAST(T6)(x6), \ BOOST_ASIO_MOVE_CAST(T7)(x7), BOOST_ASIO_MOVE_CAST(T8)(x8) # define BOOST_ASIO_VARIADIC_DECLVAL(n) \ BOOST_ASIO_VARIADIC_DECLVAL_##n # define BOOST_ASIO_VARIADIC_DECLVAL_1 \ declval<T1>() # define BOOST_ASIO_VARIADIC_DECLVAL_2 \ declval<T1>(), declval<T2>() # define BOOST_ASIO_VARIADIC_DECLVAL_3 \ declval<T1>(), declval<T2>(), declval<T3>() # define BOOST_ASIO_VARIADIC_DECLVAL_4 \ declval<T1>(), declval<T2>(), declval<T3>(), declval<T4>() # define BOOST_ASIO_VARIADIC_DECLVAL_5 \ declval<T1>(), declval<T2>(), declval<T3>(), declval<T4>(), \ declval<T5>() # define BOOST_ASIO_VARIADIC_DECLVAL_6 \ declval<T1>(), declval<T2>(), declval<T3>(), declval<T4>(), \ declval<T5>(), declval<T6>() # define BOOST_ASIO_VARIADIC_DECLVAL_7 \ declval<T1>(), declval<T2>(), declval<T3>(), declval<T4>(), \ declval<T5>(), declval<T6>(), declval<T7>() # define BOOST_ASIO_VARIADIC_DECLVAL_8 \ declval<T1>(), declval<T2>(), declval<T3>(), declval<T4>(), \ declval<T5>(), declval<T6>(), declval<T7>(), declval<T8>() # define BOOST_ASIO_VARIADIC_MOVE_DECLVAL(n) \ BOOST_ASIO_VARIADIC_MOVE_DECLVAL_##n # define BOOST_ASIO_VARIADIC_MOVE_DECLVAL_1 \ declval<BOOST_ASIO_MOVE_ARG(T1)>() # define BOOST_ASIO_VARIADIC_MOVE_DECLVAL_2 \ declval<BOOST_ASIO_MOVE_ARG(T1)>(), declval<BOOST_ASIO_MOVE_ARG(T2)>() # define BOOST_ASIO_VARIADIC_MOVE_DECLVAL_3 \ declval<BOOST_ASIO_MOVE_ARG(T1)>(), declval<BOOST_ASIO_MOVE_ARG(T2)>(), \ declval<BOOST_ASIO_MOVE_ARG(T3)>() # define BOOST_ASIO_VARIADIC_MOVE_DECLVAL_4 \ declval<BOOST_ASIO_MOVE_ARG(T1)>(), declval<BOOST_ASIO_MOVE_ARG(T2)>(), \ declval<BOOST_ASIO_MOVE_ARG(T3)>(), declval<BOOST_ASIO_MOVE_ARG(T4)>() # define BOOST_ASIO_VARIADIC_MOVE_DECLVAL_5 \ declval<BOOST_ASIO_MOVE_ARG(T1)>(), declval<BOOST_ASIO_MOVE_ARG(T2)>(), \ declval<BOOST_ASIO_MOVE_ARG(T3)>(), declval<BOOST_ASIO_MOVE_ARG(T4)>(), \ declval<BOOST_ASIO_MOVE_ARG(T5)>() # define BOOST_ASIO_VARIADIC_MOVE_DECLVAL_6 \ declval<BOOST_ASIO_MOVE_ARG(T1)>(), declval<BOOST_ASIO_MOVE_ARG(T2)>(), \ declval<BOOST_ASIO_MOVE_ARG(T3)>(), declval<BOOST_ASIO_MOVE_ARG(T4)>(), \ declval<BOOST_ASIO_MOVE_ARG(T5)>(), declval<BOOST_ASIO_MOVE_ARG(T6)>() # define BOOST_ASIO_VARIADIC_MOVE_DECLVAL_7 \ declval<BOOST_ASIO_MOVE_ARG(T1)>(), declval<BOOST_ASIO_MOVE_ARG(T2)>(), \ declval<BOOST_ASIO_MOVE_ARG(T3)>(), declval<BOOST_ASIO_MOVE_ARG(T4)>(), \ declval<BOOST_ASIO_MOVE_ARG(T5)>(), declval<BOOST_ASIO_MOVE_ARG(T6)>(), \ declval<BOOST_ASIO_MOVE_ARG(T7)>() # define BOOST_ASIO_VARIADIC_MOVE_DECLVAL_8 \ declval<BOOST_ASIO_MOVE_ARG(T1)>(), declval<BOOST_ASIO_MOVE_ARG(T2)>(), \ declval<BOOST_ASIO_MOVE_ARG(T3)>(), declval<BOOST_ASIO_MOVE_ARG(T4)>(), \ declval<BOOST_ASIO_MOVE_ARG(T5)>(), declval<BOOST_ASIO_MOVE_ARG(T6)>(), \ declval<BOOST_ASIO_MOVE_ARG(T7)>(), declval<BOOST_ASIO_MOVE_ARG(T8)>() # define BOOST_ASIO_VARIADIC_DECAY(n) \ BOOST_ASIO_VARIADIC_DECAY_##n # define BOOST_ASIO_VARIADIC_DECAY_1 \ typename decay<T1>::type # define BOOST_ASIO_VARIADIC_DECAY_2 \ typename decay<T1>::type, typename decay<T2>::type # define BOOST_ASIO_VARIADIC_DECAY_3 \ typename decay<T1>::type, typename decay<T2>::type, \ typename decay<T3>::type # define BOOST_ASIO_VARIADIC_DECAY_4 \ typename decay<T1>::type, typename decay<T2>::type, \ typename decay<T3>::type, typename decay<T4>::type # define BOOST_ASIO_VARIADIC_DECAY_5 \ typename decay<T1>::type, typename decay<T2>::type, \ typename decay<T3>::type, typename decay<T4>::type, \ typename decay<T5>::type # define BOOST_ASIO_VARIADIC_DECAY_6 \ typename decay<T1>::type, typename decay<T2>::type, \ typename decay<T3>::type, typename decay<T4>::type, \ typename decay<T5>::type, typename decay<T6>::type # define BOOST_ASIO_VARIADIC_DECAY_7 \ typename decay<T1>::type, typename decay<T2>::type, \ typename decay<T3>::type, typename decay<T4>::type, \ typename decay<T5>::type, typename decay<T6>::type, \ typename decay<T7>::type # define BOOST_ASIO_VARIADIC_DECAY_8 \ typename decay<T1>::type, typename decay<T2>::type, \ typename decay<T3>::type, typename decay<T4>::type, \ typename decay<T5>::type, typename decay<T6>::type, \ typename decay<T7>::type, typename decay<T8>::type # define BOOST_ASIO_VARIADIC_GENERATE(m) m(1) m(2) m(3) m(4) m(5) m(6) m(7) m(8) # define BOOST_ASIO_VARIADIC_GENERATE_5(m) m(1) m(2) m(3) m(4) m(5) #endif // !defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) #endif // BOOST_ASIO_DETAIL_VARIADIC_TEMPLATES_HPP PK��h!\�h��null_event.hppnu��[��// // detail/null_event.hpp // ~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_NULL_EVENT_HPP #define BOOST_ASIO_DETAIL_NULL_EVENT_HPP #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/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class null_event : private noncopyable { public: // Constructor. null_event() { } // Destructor. ~null_event() { } // Signal the event. (Retained for backward compatibility.) template <typename Lock> void signal(Lock&) { } // Signal all waiters. template <typename Lock> void signal_all(Lock&) { } // Unlock the mutex and signal one waiter. template <typename Lock> void unlock_and_signal_one(Lock&) { } // Unlock the mutex and signal one waiter who may destroy us. template <typename Lock> void unlock_and_signal_one_for_destruction(Lock&) { } // If there's a waiter, unlock the mutex and signal it. template <typename Lock> bool maybe_unlock_and_signal_one(Lock&) { return false; } // Reset the event. template <typename Lock> void clear(Lock&) { } // Wait for the event to become signalled. template <typename Lock> void wait(Lock&) { do_wait(); } // Timed wait for the event to become signalled. template <typename Lock> bool wait_for_usec(Lock&, long usec) { do_wait_for_usec(usec); return true; } private: BOOST_ASIO_DECL static void do_wait(); BOOST_ASIO_DECL static void do_wait_for_usec(long usec); }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/null_event.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // BOOST_ASIO_DETAIL_NULL_EVENT_HPP PK��h!\�`)�u��u�� global.hppnu��[��// // detail/global.hpp // ~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_GLOBAL_HPP #define BOOST_ASIO_DETAIL_GLOBAL_HPP #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_HAS_THREADS) # include <boost/asio/detail/null_global.hpp> #elif defined(BOOST_ASIO_WINDOWS) # include <boost/asio/detail/win_global.hpp> #elif defined(BOOST_ASIO_HAS_PTHREADS) # include <boost/asio/detail/posix_global.hpp> #elif defined(BOOST_ASIO_HAS_STD_CALL_ONCE) # include <boost/asio/detail/std_global.hpp> #else # error Only Windows, POSIX and std::call_once are supported! #endif namespace boost { namespace asio { namespace detail { template <typename T> inline T& global() { #if !defined(BOOST_ASIO_HAS_THREADS) return null_global<T>(); #elif defined(BOOST_ASIO_WINDOWS) return win_global<T>(); #elif defined(BOOST_ASIO_HAS_PTHREADS) return posix_global<T>(); #elif defined(BOOST_ASIO_HAS_STD_CALL_ONCE) return std_global<T>(); #endif } } // namespace detail } // namespace asio } // namespace boost #endif // BOOST_ASIO_DETAIL_GLOBAL_HPP PK��h!\��J1��winrt_async_op.hppnu��[��// // detail/winrt_async_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WINRT_ASYNC_OP_HPP #define BOOST_ASIO_DETAIL_WINRT_ASYNC_OP_HPP #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/detail/operation.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename TResult> class winrt_async_op : public operation { public: // The error code to be passed to the completion handler. boost::system::error_code ec_; // The result of the operation, to be passed to the completion handler. TResult result_; protected: winrt_async_op(func_type complete_func) : operation(complete_func), result_() { } }; template <> class winrt_async_op<void> : public operation { public: // The error code to be passed to the completion handler. boost::system::error_code ec_; protected: winrt_async_op(func_type complete_func) : operation(complete_func) { } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_WINRT_ASYNC_OP_HPP PK��h!\�Ļ �� socket_option.hppnu��[��// // detail/socket_option.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_SOCKET_OPTION_HPP #define BOOST_ASIO_DETAIL_SOCKET_OPTION_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <cstddef> #include <stdexcept> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/throw_exception.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { namespace socket_option { // Helper template for implementing boolean-based options. template <int Level, int Name> class boolean { public: // Default constructor. boolean() : value_(0) { } // Construct with a specific option value. explicit boolean(bool v) : value_(v ? 1 : 0) { } // Set the current value of the boolean. boolean& operator=(bool v) { value_ = v ? 1 : 0; return this; } // Get the current value of the boolean. bool value() const { return !!value_; } // Convert to bool. operator bool() const { return !!value_; } // Test for false. bool operator!() const { return !value_; } // Get the level of the socket option. template <typename Protocol> int level(const Protocol&) const { return Level; } // Get the name of the socket option. template <typename Protocol> int name(const Protocol&) const { return Name; } // Get the address of the boolean data. template <typename Protocol> int data(const Protocol&) { return &value_; } // Get the address of the boolean data. template <typename Protocol> const int* data(const Protocol&) const { return &value_; } // Get the size of the boolean data. template <typename Protocol> std::size_t size(const Protocol&) const { return sizeof(value_); } // Set the size of the boolean data. template <typename Protocol> void resize(const Protocol&, std::size_t s) { // On some platforms (e.g. Windows Vista), the getsockopt function will // return the size of a boolean socket option as one byte, even though a // four byte integer was passed in. switch (s) { case sizeof(char): value_ = reinterpret_cast<char>(&value_) ? 1 : 0; break; case sizeof(value_): break; default: { std::length_error ex("boolean socket option resize"); boost::asio::detail::throw_exception(ex); } } } private: int value_; }; // Helper template for implementing integer options. template <int Level, int Name> class integer { public: // Default constructor. integer() : value_(0) { } // Construct with a specific option value. explicit integer(int v) : value_(v) { } // Set the value of the int option. integer& operator=(int v) { value_ = v; return this; } // Get the current value of the int option. int value() const { return value_; } // Get the level of the socket option. template <typename Protocol> int level(const Protocol&) const { return Level; } // Get the name of the socket option. template <typename Protocol> int name(const Protocol&) const { return Name; } // Get the address of the int data. template <typename Protocol> int data(const Protocol&) { return &value_; } // Get the address of the int data. template <typename Protocol> const int* data(const Protocol&) const { return &value_; } // Get the size of the int data. template <typename Protocol> std::size_t size(const Protocol&) const { return sizeof(value_); } // Set the size of the int data. template <typename Protocol> void resize(const Protocol&, std::size_t s) { if (s != sizeof(value_)) { std::length_error ex("integer socket option resize"); boost::asio::detail::throw_exception(ex); } } private: int value_; }; // Helper template for implementing linger options. template <int Level, int Name> class linger { public: // Default constructor. linger() { value_.l_onoff = 0; value_.l_linger = 0; } // Construct with specific option values. linger(bool e, int t) { enabled(e); timeout BOOST_ASIO_PREVENT_MACRO_SUBSTITUTION(t); } // Set the value for whether linger is enabled. void enabled(bool value) { value_.l_onoff = value ? 1 : 0; } // Get the value for whether linger is enabled. bool enabled() const { return value_.l_onoff != 0; } // Set the value for the linger timeout. void timeout BOOST_ASIO_PREVENT_MACRO_SUBSTITUTION(int value) { #if defined(WIN32) value_.l_linger = static_cast<u_short>(value); #else value_.l_linger = value; #endif } // Get the value for the linger timeout. int timeout BOOST_ASIO_PREVENT_MACRO_SUBSTITUTION() const { return static_cast<int>(value_.l_linger); } // Get the level of the socket option. template <typename Protocol> int level(const Protocol&) const { return Level; } // Get the name of the socket option. template <typename Protocol> int name(const Protocol&) const { return Name; } // Get the address of the linger data. template <typename Protocol> detail::linger_type* data(const Protocol&) { return &value_; } // Get the address of the linger data. template <typename Protocol> const detail::linger_type* data(const Protocol&) const { return &value_; } // Get the size of the linger data. template <typename Protocol> std::size_t size(const Protocol&) const { return sizeof(value_); } // Set the size of the int data. template <typename Protocol> void resize(const Protocol&, std::size_t s) { if (s != sizeof(value_)) { std::length_error ex("linger socket option resize"); boost::asio::detail::throw_exception(ex); } } private: detail::linger_type value_; }; } // namespace socket_option } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_SOCKET_OPTION_HPP PK��h!\─!G��G��win_fd_set_adapter.hppnu��[��// // detail/win_fd_set_adapter.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_FD_SET_ADAPTER_HPP #define BOOST_ASIO_DETAIL_WIN_FD_SET_ADAPTER_HPP #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_WINDOWS) \|\| defined(__CYGWIN__) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/reactor_op_queue.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { // Adapts the FD_SET type to meet the Descriptor_Set concept's requirements. class win_fd_set_adapter : noncopyable { public: enum { default_fd_set_size = 1024 }; win_fd_set_adapter() : capacity_(default_fd_set_size), max_descriptor_(invalid_socket) { fd_set_ = static_cast<win_fd_set>(::operator new( sizeof(win_fd_set) - sizeof(SOCKET) + sizeof(SOCKET) (capacity_))); fd_set_->fd_count = 0; } ~win_fd_set_adapter() { ::operator delete(fd_set_); } void reset() { fd_set_->fd_count = 0; max_descriptor_ = invalid_socket; } bool set(socket_type descriptor) { for (u_int i = 0; i < fd_set_->fd_count; ++i) if (fd_set_->fd_array[i] == descriptor) return true; reserve(fd_set_->fd_count + 1); fd_set_->fd_array[fd_set_->fd_count++] = descriptor; return true; } void set(reactor_op_queue<socket_type>& operations, op_queue<operation>&) { reactor_op_queue<socket_type>::iterator i = operations.begin(); while (i != operations.end()) { reactor_op_queue<socket_type>::iterator op_iter = i++; reserve(fd_set_->fd_count + 1); fd_set_->fd_array[fd_set_->fd_count++] = op_iter->first; } } bool is_set(socket_type descriptor) const { return !!__WSAFDIsSet(descriptor, const_cast<fd_set>(reinterpret_cast<const fd_set>(fd_set_))); } operator fd_set() { return reinterpret_cast<fd_set>(fd_set_); } socket_type max_descriptor() const { return max_descriptor_; } void perform(reactor_op_queue<socket_type>& operations, op_queue<operation>& ops) const { for (u_int i = 0; i < fd_set_->fd_count; ++i) operations.perform_operations(fd_set_->fd_array[i], ops); } private: // This structure is defined to be compatible with the Windows API fd_set // structure, but without being dependent on the value of FD_SETSIZE. We use // the "struct hack" to allow the number of descriptors to be varied at // runtime. struct win_fd_set { u_int fd_count; SOCKET fd_array[1]; }; // Increase the fd_set_ capacity to at least the specified number of elements. void reserve(u_int n) { if (n <= capacity_) return; u_int new_capacity = capacity_ + capacity_ / 2; if (new_capacity < n) new_capacity = n; win_fd_set* new_fd_set = static_cast<win_fd_set>(::operator new( sizeof(win_fd_set) - sizeof(SOCKET) + sizeof(SOCKET) (new_capacity))); new_fd_set->fd_count = fd_set_->fd_count; for (u_int i = 0; i < fd_set_->fd_count; ++i) new_fd_set->fd_array[i] = fd_set_->fd_array[i]; ::operator delete(fd_set_); fd_set_ = new_fd_set; capacity_ = new_capacity; } win_fd_set* fd_set_; u_int capacity_; socket_type max_descriptor_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_WIN_FD_SET_ADAPTER_HPP PK��h!\<{��!��!�� chrono.hppnu��[��// // detail/chrono.hpp // ~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_CHRONO_HPP #define BOOST_ASIO_DETAIL_CHRONO_HPP #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_HAS_STD_CHRONO) # include <chrono> #elif defined(BOOST_ASIO_HAS_BOOST_CHRONO) # include <boost/chrono/system_clocks.hpp> #endif // defined(BOOST_ASIO_HAS_BOOST_CHRONO) namespace boost { namespace asio { namespace chrono { #if defined(BOOST_ASIO_HAS_STD_CHRONO) using std::chrono::duration; using std::chrono::time_point; using std::chrono::duration_cast; using std::chrono::nanoseconds; using std::chrono::microseconds; using std::chrono::milliseconds; using std::chrono::seconds; using std::chrono::minutes; using std::chrono::hours; using std::chrono::time_point_cast; #if defined(BOOST_ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK) typedef std::chrono::monotonic_clock steady_clock; #else // defined(BOOST_ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK) using std::chrono::steady_clock; #endif // defined(BOOST_ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK) using std::chrono::system_clock; using std::chrono::high_resolution_clock; #elif defined(BOOST_ASIO_HAS_BOOST_CHRONO) using boost::chrono::duration; using boost::chrono::time_point; using boost::chrono::duration_cast; using boost::chrono::nanoseconds; using boost::chrono::microseconds; using boost::chrono::milliseconds; using boost::chrono::seconds; using boost::chrono::minutes; using boost::chrono::hours; using boost::chrono::time_point_cast; using boost::chrono::system_clock; using boost::chrono::steady_clock; using boost::chrono::high_resolution_clock; #endif // defined(BOOST_ASIO_HAS_BOOST_CHRONO) } // namespace chrono } // namespace asio } // namespace boost #endif // BOOST_ASIO_DETAIL_CHRONO_HPP PK��h!\��(��(��fd_set_adapter.hppnu��[��// // detail/fd_set_adapter.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_FD_SET_ADAPTER_HPP #define BOOST_ASIO_DETAIL_FD_SET_ADAPTER_HPP #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_WINDOWS_RUNTIME) #include <boost/asio/detail/posix_fd_set_adapter.hpp> #include <boost/asio/detail/win_fd_set_adapter.hpp> namespace boost { namespace asio { namespace detail { #if defined(BOOST_ASIO_WINDOWS) \|\| defined(__CYGWIN__) typedef win_fd_set_adapter fd_set_adapter; #else typedef posix_fd_set_adapter fd_set_adapter; #endif } // namespace detail } // namespace asio } // namespace boost #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_FD_SET_ADAPTER_HPP PK��h!\C�tw�� limits.hppnu��[��// // detail/limits.hpp // ~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2011 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_DETAIL_LIMITS_HPP #define BOOST_ASIO_DETAIL_LIMITS_HPP #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_HAS_BOOST_LIMITS) # include <boost/limits.hpp> #else // defined(BOOST_ASIO_HAS_BOOST_LIMITS) # include <limits> #endif // defined(BOOST_ASIO_HAS_BOOST_LIMITS) #endif // BOOST_ASIO_DETAIL_LIMITS_HPP PK��h!\��z��z�� signal_op.hppnu��[��// // detail/signal_op.hpp // ~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_SIGNAL_OP_HPP #define BOOST_ASIO_DETAIL_SIGNAL_OP_HPP #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/detail/operation.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class signal_op : public operation { public: // The error code to be passed to the completion handler. boost::system::error_code ec_; // The signal number to be passed to the completion handler. int signal_number_; protected: signal_op(func_type func) : operation(func), signal_number_(0) { } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_SIGNAL_OP_HPP PK��h!\+g�.g��g��dev_poll_reactor.hppnu��[��// // detail/dev_poll_reactor.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_DEV_POLL_REACTOR_HPP #define BOOST_ASIO_DETAIL_DEV_POLL_REACTOR_HPP #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_HAS_DEV_POLL) #include <cstddef> #include <vector> #include <sys/devpoll.h> #include <boost/asio/detail/hash_map.hpp> #include <boost/asio/detail/limits.hpp> #include <boost/asio/detail/mutex.hpp> #include <boost/asio/detail/op_queue.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/reactor_op_queue.hpp> #include <boost/asio/detail/select_interrupter.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/timer_queue_base.hpp> #include <boost/asio/detail/timer_queue_set.hpp> #include <boost/asio/detail/wait_op.hpp> #include <boost/asio/execution_context.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class dev_poll_reactor : public execution_context_service_base<dev_poll_reactor> { public: enum op_types { read_op = 0, write_op = 1, connect_op = 1, except_op = 2, max_ops = 3 }; // Per-descriptor data. struct per_descriptor_data { }; // Constructor. BOOST_ASIO_DECL dev_poll_reactor(boost::asio::execution_context& ctx); // Destructor. BOOST_ASIO_DECL ~dev_poll_reactor(); // Destroy all user-defined handler objects owned by the service. BOOST_ASIO_DECL void shutdown(); // Recreate internal descriptors following a fork. BOOST_ASIO_DECL void notify_fork( boost::asio::execution_context::fork_event fork_ev); // Initialise the task. BOOST_ASIO_DECL void init_task(); // Register a socket with the reactor. Returns 0 on success, system error // code on failure. BOOST_ASIO_DECL int register_descriptor(socket_type, per_descriptor_data&); // Register a descriptor with an associated single operation. Returns 0 on // success, system error code on failure. BOOST_ASIO_DECL int register_internal_descriptor( int op_type, socket_type descriptor, per_descriptor_data& descriptor_data, reactor_op* op); // Move descriptor registration from one descriptor_data object to another. BOOST_ASIO_DECL void move_descriptor(socket_type descriptor, per_descriptor_data& target_descriptor_data, per_descriptor_data& source_descriptor_data); // Post a reactor operation for immediate completion. void post_immediate_completion(reactor_op* op, bool is_continuation) { scheduler_.post_immediate_completion(op, is_continuation); } // Start a new operation. The reactor operation will be performed when the // given descriptor is flagged as ready, or an error has occurred. BOOST_ASIO_DECL void start_op(int op_type, socket_type descriptor, per_descriptor_data&, reactor_op* op, bool is_continuation, bool allow_speculative); // Cancel all operations associated with the given descriptor. The // handlers associated with the descriptor will be invoked with the // operation_aborted error. BOOST_ASIO_DECL void cancel_ops(socket_type descriptor, per_descriptor_data&); // Cancel any operations that are running against the descriptor and remove // its registration from the reactor. The reactor resources associated with // the descriptor must be released by calling cleanup_descriptor_data. BOOST_ASIO_DECL void deregister_descriptor(socket_type descriptor, per_descriptor_data&, bool closing); // Remove the descriptor's registration from the reactor. The reactor // resources associated with the descriptor must be released by calling // cleanup_descriptor_data. BOOST_ASIO_DECL void deregister_internal_descriptor( socket_type descriptor, per_descriptor_data&); // Perform any post-deregistration cleanup tasks associated with the // descriptor data. BOOST_ASIO_DECL void cleanup_descriptor_data(per_descriptor_data&); // Add a new timer queue to the reactor. template <typename Time_Traits> void add_timer_queue(timer_queue<Time_Traits>& queue); // Remove a timer queue from the reactor. template <typename Time_Traits> void remove_timer_queue(timer_queue<Time_Traits>& queue); // Schedule a new operation in the given timer queue to expire at the // specified absolute time. template <typename Time_Traits> void schedule_timer(timer_queue<Time_Traits>& queue, const typename Time_Traits::time_type& time, typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op); // Cancel the timer operations associated with the given token. Returns the // number of operations that have been posted or dispatched. template <typename Time_Traits> std::size_t cancel_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& timer, std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)()); // Move the timer operations associated with the given timer. template <typename Time_Traits> void move_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& target, typename timer_queue<Time_Traits>::per_timer_data& source); // Run /dev/poll once until interrupted or events are ready to be dispatched. BOOST_ASIO_DECL void run(long usec, op_queue<operation>& ops); // Interrupt the select loop. BOOST_ASIO_DECL void interrupt(); private: // Create the /dev/poll file descriptor. Throws an exception if the descriptor // cannot be created. BOOST_ASIO_DECL static int do_dev_poll_create(); // Helper function to add a new timer queue. BOOST_ASIO_DECL void do_add_timer_queue(timer_queue_base& queue); // Helper function to remove a timer queue. BOOST_ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue); // Get the timeout value for the /dev/poll DP_POLL operation. The timeout // value is returned as a number of milliseconds. A return value of -1 // indicates that the poll should block indefinitely. BOOST_ASIO_DECL int get_timeout(int msec); // Cancel all operations associated with the given descriptor. The do_cancel // function of the handler objects will be invoked. This function does not // acquire the dev_poll_reactor's mutex. BOOST_ASIO_DECL void cancel_ops_unlocked(socket_type descriptor, const boost::system::error_code& ec); // Add a pending event entry for the given descriptor. BOOST_ASIO_DECL ::pollfd& add_pending_event_change(int descriptor); // The scheduler implementation used to post completions. scheduler& scheduler_; // Mutex to protect access to internal data. boost::asio::detail::mutex mutex_; // The /dev/poll file descriptor. int dev_poll_fd_; // Vector of /dev/poll events waiting to be written to the descriptor. std::vector< ::pollfd> pending_event_changes_; // Hash map to associate a descriptor with a pending event change index. hash_map<int, std::size_t> pending_event_change_index_; // The interrupter is used to break a blocking DP_POLL operation. select_interrupter interrupter_; // The queues of read, write and except operations. reactor_op_queue<socket_type> op_queue_[max_ops]; // The timer queues. timer_queue_set timer_queues_; // Whether the service has been shut down. bool shutdown_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #include <boost/asio/detail/impl/dev_poll_reactor.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/dev_poll_reactor.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_HAS_DEV_POLL) #endif // BOOST_ASIO_DETAIL_DEV_POLL_REACTOR_HPP PK��h!\�)O®��win_iocp_handle_write_op.hppnu��[��// // detail/win_iocp_handle_write_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.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_DETAIL_WIN_IOCP_HANDLE_WRITE_OP_HPP #define BOOST_ASIO_DETAIL_WIN_IOCP_HANDLE_WRITE_OP_HPP #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_HAS_IOCP) #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/operation.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename ConstBufferSequence, typename Handler, typename IoExecutor> class win_iocp_handle_write_op : public operation { public: BOOST_ASIO_DEFINE_HANDLER_PTR(win_iocp_handle_write_op); win_iocp_handle_write_op(const ConstBufferSequence& buffers, Handler& handler, const IoExecutor& io_ex) : operation(&win_iocp_handle_write_op::do_complete), buffers_(buffers), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static void do_complete(void* owner, operation* base, const boost::system::error_code& ec, std::size_t bytes_transferred) { // Take ownership of the operation object. win_iocp_handle_write_op* o(static_cast<win_iocp_handle_write_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) if (owner) { // Check whether buffers are still valid. buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence>::validate(o->buffers_); } #endif // defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, ec, bytes_transferred); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: ConstBufferSequence buffers_; Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_IOCP) #endif // BOOST_ASIO_DETAIL_WIN_IOCP_HANDLE_WRITE_OP_HPP PK��h!\��fenced_block.hppnu��[��// // detail/fenced_block.hpp // ~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_FENCED_BLOCK_HPP #define BOOST_ASIO_DETAIL_FENCED_BLOCK_HPP #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_HAS_THREADS) \ \|\| defined(BOOST_ASIO_DISABLE_FENCED_BLOCK) # include <boost/asio/detail/null_fenced_block.hpp> #elif defined(BOOST_ASIO_HAS_STD_ATOMIC) # include <boost/asio/detail/std_fenced_block.hpp> #elif defined(__MACH__) && defined(__APPLE__) # include <boost/asio/detail/macos_fenced_block.hpp> #elif defined(__sun) # include <boost/asio/detail/solaris_fenced_block.hpp> #elif defined(__GNUC__) && defined(__arm__) \ && !defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4) # include <boost/asio/detail/gcc_arm_fenced_block.hpp> #elif defined(__GNUC__) && (defined(__hppa) \|\| defined(__hppa__)) # include <boost/asio/detail/gcc_hppa_fenced_block.hpp> #elif defined(__GNUC__) && (defined(__i386__) \|\| defined(__x86_64__)) # include <boost/asio/detail/gcc_x86_fenced_block.hpp> #elif defined(__GNUC__) \ && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 1) \|\| (__GNUC__ > 4)) \ && !defined(__INTEL_COMPILER) && !defined(__ICL) \ && !defined(__ICC) && !defined(__ECC) && !defined(__PATHSCALE__) # include <boost/asio/detail/gcc_sync_fenced_block.hpp> #elif defined(BOOST_ASIO_WINDOWS) && !defined(UNDER_CE) # include <boost/asio/detail/win_fenced_block.hpp> #else # include <boost/asio/detail/null_fenced_block.hpp> #endif namespace boost { namespace asio { namespace detail { #if !defined(BOOST_ASIO_HAS_THREADS) \ \|\| defined(BOOST_ASIO_DISABLE_FENCED_BLOCK) typedef null_fenced_block fenced_block; #elif defined(BOOST_ASIO_HAS_STD_ATOMIC) typedef std_fenced_block fenced_block; #elif defined(__MACH__) && defined(__APPLE__) typedef macos_fenced_block fenced_block; #elif defined(__sun) typedef solaris_fenced_block fenced_block; #elif defined(__GNUC__) && defined(__arm__) \ && !defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4) typedef gcc_arm_fenced_block fenced_block; #elif defined(__GNUC__) && (defined(__hppa) \|\| defined(__hppa__)) typedef gcc_hppa_fenced_block fenced_block; #elif defined(__GNUC__) && (defined(__i386__) \|\| defined(__x86_64__)) typedef gcc_x86_fenced_block fenced_block; #elif defined(__GNUC__) \ && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 1) \|\| (__GNUC__ > 4)) \ && !defined(__INTEL_COMPILER) && !defined(__ICL) \ && !defined(__ICC) && !defined(__ECC) && !defined(__PATHSCALE__) typedef gcc_sync_fenced_block fenced_block; #elif defined(BOOST_ASIO_WINDOWS) && !defined(UNDER_CE) typedef win_fenced_block fenced_block; #else typedef null_fenced_block fenced_block; #endif } // namespace detail } // namespace asio } // namespace boost #endif // BOOST_ASIO_DETAIL_FENCED_BLOCK_HPP PK��h!\9��win_tss_ptr.hppnu��[��// // detail/win_tss_ptr.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WIN_TSS_PTR_HPP #define BOOST_ASIO_DETAIL_WIN_TSS_PTR_HPP #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_WINDOWS) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { // Helper function to create thread-specific storage. BOOST_ASIO_DECL DWORD win_tss_ptr_create(); template <typename T> class win_tss_ptr : private noncopyable { public: // Constructor. win_tss_ptr() : tss_key_(win_tss_ptr_create()) { } // Destructor. ~win_tss_ptr() { ::TlsFree(tss_key_); } // Get the value. operator T() const { return static_cast<T>(::TlsGetValue(tss_key_)); } // Set the value. void operator=(T* value) { ::TlsSetValue(tss_key_, value); } private: // Thread-specific storage to allow unlocked access to determine whether a // thread is a member of the pool. DWORD tss_key_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/win_tss_ptr.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_WINDOWS) #endif // BOOST_ASIO_DETAIL_WIN_TSS_PTR_HPP PK��h!\�x�f��f��signal_blocker.hppnu��[��// // detail/signal_blocker.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_SIGNAL_BLOCKER_HPP #define BOOST_ASIO_DETAIL_SIGNAL_BLOCKER_HPP #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_HAS_THREADS) \|\| defined(BOOST_ASIO_WINDOWS) \ \|\| defined(BOOST_ASIO_WINDOWS_RUNTIME) \ \|\| defined(__CYGWIN__) \|\| defined(__SYMBIAN32__) # include <boost/asio/detail/null_signal_blocker.hpp> #elif defined(BOOST_ASIO_HAS_PTHREADS) # include <boost/asio/detail/posix_signal_blocker.hpp> #else # error Only Windows and POSIX are supported! #endif namespace boost { namespace asio { namespace detail { #if !defined(BOOST_ASIO_HAS_THREADS) \|\| defined(BOOST_ASIO_WINDOWS) \ \|\| defined(BOOST_ASIO_WINDOWS_RUNTIME) \ \|\| defined(__CYGWIN__) \|\| defined(__SYMBIAN32__) typedef null_signal_blocker signal_blocker; #elif defined(BOOST_ASIO_HAS_PTHREADS) typedef posix_signal_blocker signal_blocker; #endif } // namespace detail } // namespace asio } // namespace boost #endif // BOOST_ASIO_DETAIL_SIGNAL_BLOCKER_HPP PK��h!\��c2��2��std_static_mutex.hppnu��[��// // detail/std_static_mutex.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_STD_STATIC_MUTEX_HPP #define BOOST_ASIO_DETAIL_STD_STATIC_MUTEX_HPP #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_HAS_STD_MUTEX_AND_CONDVAR) #include <mutex> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/scoped_lock.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class std_event; class std_static_mutex : private noncopyable { public: typedef boost::asio::detail::scoped_lock<std_static_mutex> scoped_lock; // Constructor. std_static_mutex(int) { } // Destructor. ~std_static_mutex() { } // Initialise the mutex. void init() { // Nothing to do. } // Lock the mutex. void lock() { mutex_.lock(); } // Unlock the mutex. void unlock() { mutex_.unlock(); } private: friend class std_event; std::mutex mutex_; }; #define BOOST_ASIO_STD_STATIC_MUTEX_INIT 0 } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_STD_MUTEX_AND_CONDVAR) #endif // BOOST_ASIO_DETAIL_STD_STATIC_MUTEX_HPP PK��h!\Zq�U ��U ��kqueue_reactor.hppnu��[��// // detail/kqueue_reactor.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2005 Stefan Arentz (stefan at soze 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_DETAIL_KQUEUE_REACTOR_HPP #define BOOST_ASIO_DETAIL_KQUEUE_REACTOR_HPP #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_HAS_KQUEUE) #include <cstddef> #include <sys/types.h> #include <sys/event.h> #include <sys/time.h> #include <boost/asio/detail/limits.hpp> #include <boost/asio/detail/mutex.hpp> #include <boost/asio/detail/object_pool.hpp> #include <boost/asio/detail/op_queue.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/select_interrupter.hpp> #include <boost/asio/detail/socket_types.hpp> #include <boost/asio/detail/timer_queue_base.hpp> #include <boost/asio/detail/timer_queue_set.hpp> #include <boost/asio/detail/wait_op.hpp> #include <boost/asio/error.hpp> #include <boost/asio/execution_context.hpp> // Older versions of Mac OS X may not define EV_OOBAND. #if !defined(EV_OOBAND) # define EV_OOBAND EV_FLAG1 #endif // !defined(EV_OOBAND) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class scheduler; class kqueue_reactor : public execution_context_service_base<kqueue_reactor> { private: // The mutex type used by this reactor. typedef conditionally_enabled_mutex mutex; public: enum op_types { read_op = 0, write_op = 1, connect_op = 1, except_op = 2, max_ops = 3 }; // Per-descriptor queues. struct descriptor_state { descriptor_state(bool locking) : mutex_(locking) {} friend class kqueue_reactor; friend class object_pool_access; descriptor_state* next_; descriptor_state* prev_; mutex mutex_; int descriptor_; int num_kevents_; // 1 == read only, 2 == read and write op_queue<reactor_op> op_queue_[max_ops]; bool shutdown_; }; // Per-descriptor data. typedef descriptor_state* per_descriptor_data; // Constructor. BOOST_ASIO_DECL kqueue_reactor(boost::asio::execution_context& ctx); // Destructor. BOOST_ASIO_DECL ~kqueue_reactor(); // Destroy all user-defined handler objects owned by the service. BOOST_ASIO_DECL void shutdown(); // Recreate internal descriptors following a fork. BOOST_ASIO_DECL void notify_fork( boost::asio::execution_context::fork_event fork_ev); // Initialise the task. BOOST_ASIO_DECL void init_task(); // Register a socket with the reactor. Returns 0 on success, system error // code on failure. BOOST_ASIO_DECL int register_descriptor(socket_type descriptor, per_descriptor_data& descriptor_data); // Register a descriptor with an associated single operation. Returns 0 on // success, system error code on failure. BOOST_ASIO_DECL int register_internal_descriptor( int op_type, socket_type descriptor, per_descriptor_data& descriptor_data, reactor_op* op); // Move descriptor registration from one descriptor_data object to another. BOOST_ASIO_DECL void move_descriptor(socket_type descriptor, per_descriptor_data& target_descriptor_data, per_descriptor_data& source_descriptor_data); // Post a reactor operation for immediate completion. void post_immediate_completion(reactor_op* op, bool is_continuation) { scheduler_.post_immediate_completion(op, is_continuation); } // Start a new operation. The reactor operation will be performed when the // given descriptor is flagged as ready, or an error has occurred. BOOST_ASIO_DECL void start_op(int op_type, socket_type descriptor, per_descriptor_data& descriptor_data, reactor_op* op, bool is_continuation, bool allow_speculative); // Cancel all operations associated with the given descriptor. The // handlers associated with the descriptor will be invoked with the // operation_aborted error. BOOST_ASIO_DECL void cancel_ops(socket_type descriptor, per_descriptor_data& descriptor_data); // Cancel any operations that are running against the descriptor and remove // its registration from the reactor. The reactor resources associated with // the descriptor must be released by calling cleanup_descriptor_data. BOOST_ASIO_DECL void deregister_descriptor(socket_type descriptor, per_descriptor_data& descriptor_data, bool closing); // Remove the descriptor's registration from the reactor. The reactor // resources associated with the descriptor must be released by calling // cleanup_descriptor_data. BOOST_ASIO_DECL void deregister_internal_descriptor( socket_type descriptor, per_descriptor_data& descriptor_data); // Perform any post-deregistration cleanup tasks associated with the // descriptor data. BOOST_ASIO_DECL void cleanup_descriptor_data( per_descriptor_data& descriptor_data); // Add a new timer queue to the reactor. template <typename Time_Traits> void add_timer_queue(timer_queue<Time_Traits>& queue); // Remove a timer queue from the reactor. template <typename Time_Traits> void remove_timer_queue(timer_queue<Time_Traits>& queue); // Schedule a new operation in the given timer queue to expire at the // specified absolute time. template <typename Time_Traits> void schedule_timer(timer_queue<Time_Traits>& queue, const typename Time_Traits::time_type& time, typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op); // Cancel the timer operations associated with the given token. Returns the // number of operations that have been posted or dispatched. template <typename Time_Traits> std::size_t cancel_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& timer, std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)()); // Move the timer operations associated with the given timer. template <typename Time_Traits> void move_timer(timer_queue<Time_Traits>& queue, typename timer_queue<Time_Traits>::per_timer_data& target, typename timer_queue<Time_Traits>::per_timer_data& source); // Run the kqueue loop. BOOST_ASIO_DECL void run(long usec, op_queue<operation>& ops); // Interrupt the kqueue loop. BOOST_ASIO_DECL void interrupt(); private: // Create the kqueue file descriptor. Throws an exception if the descriptor // cannot be created. BOOST_ASIO_DECL static int do_kqueue_create(); // Allocate a new descriptor state object. BOOST_ASIO_DECL descriptor_state* allocate_descriptor_state(); // Free an existing descriptor state object. BOOST_ASIO_DECL void free_descriptor_state(descriptor_state* s); // Helper function to add a new timer queue. BOOST_ASIO_DECL void do_add_timer_queue(timer_queue_base& queue); // Helper function to remove a timer queue. BOOST_ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue); // Get the timeout value for the kevent call. BOOST_ASIO_DECL timespec* get_timeout(long usec, timespec& ts); // The scheduler used to post completions. scheduler& scheduler_; // Mutex to protect access to internal data. mutex mutex_; // The kqueue file descriptor. int kqueue_fd_; // The interrupter is used to break a blocking kevent call. select_interrupter interrupter_; // The timer queues. timer_queue_set timer_queues_; // Whether the service has been shut down. bool shutdown_; // Mutex to protect access to the registered descriptors. mutex registered_descriptors_mutex_; // Keep track of all registered descriptors. object_pool<descriptor_state> registered_descriptors_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #include <boost/asio/detail/impl/kqueue_reactor.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/kqueue_reactor.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_HAS_KQUEUE) #endif // BOOST_ASIO_DETAIL_KQUEUE_REACTOR_HPP PK��h!\_�@R��completion_handler.hppnu��[��// // detail/completion_handler.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_COMPLETION_HANDLER_HPP #define BOOST_ASIO_DETAIL_COMPLETION_HANDLER_HPP #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/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/operation.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Handler, typename IoExecutor> class completion_handler : public operation { public: BOOST_ASIO_DEFINE_HANDLER_PTR(completion_handler); completion_handler(Handler& h, const IoExecutor& io_ex) : operation(&completion_handler::do_complete), handler_(BOOST_ASIO_MOVE_CAST(Handler)(h)), work_(handler_, io_ex) { } static void do_complete(void* owner, operation* base, const boost::system::error_code& /ec/, std::size_t /bytes_transferred/) { // Take ownership of the handler object. completion_handler* h(static_cast<completion_handler>(base)); ptr p = { boost::asio::detail::addressof(h->handler_), h, h }; BOOST_ASIO_HANDLER_COMPLETION((h)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( h->work_)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. Handler handler(BOOST_ASIO_MOVE_CAST(Handler)(h->handler_)); p.h = boost::asio::detail::addressof(handler); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN(()); w.complete(handler, handler); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_COMPLETION_HANDLER_HPP PK��h!\�eG�+ ��+ ��pipe_select_interrupter.hppnu��[��// // detail/pipe_select_interrupter.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_PIPE_SELECT_INTERRUPTER_HPP #define BOOST_ASIO_DETAIL_PIPE_SELECT_INTERRUPTER_HPP #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_WINDOWS) #if !defined(BOOST_ASIO_WINDOWS_RUNTIME) #if !defined(__CYGWIN__) #if !defined(__SYMBIAN32__) #if !defined(BOOST_ASIO_HAS_EVENTFD) #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class pipe_select_interrupter { public: // Constructor. BOOST_ASIO_DECL pipe_select_interrupter(); // Destructor. BOOST_ASIO_DECL ~pipe_select_interrupter(); // Recreate the interrupter's descriptors. Used after a fork. BOOST_ASIO_DECL void recreate(); // Interrupt the select call. BOOST_ASIO_DECL void interrupt(); // Reset the select interrupter. Returns true if the reset was successful. BOOST_ASIO_DECL bool reset(); // Get the read descriptor to be passed to select. int read_descriptor() const { return read_descriptor_; } private: // Open the descriptors. Throws on error. BOOST_ASIO_DECL void open_descriptors(); // Close the descriptors. BOOST_ASIO_DECL void close_descriptors(); // The read end of a connection used to interrupt the select call. This file // descriptor is passed to select such that when it is time to stop, a single // byte will be written on the other end of the connection and this // descriptor will become readable. int read_descriptor_; // The write end of a connection used to interrupt the select call. A single // byte may be written to this to wake up the select which is waiting for the // other end to become readable. int write_descriptor_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/pipe_select_interrupter.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // !defined(BOOST_ASIO_HAS_EVENTFD) #endif // !defined(__SYMBIAN32__) #endif // !defined(__CYGWIN__) #endif // !defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // !defined(BOOST_ASIO_WINDOWS) #endif // BOOST_ASIO_DETAIL_PIPE_SELECT_INTERRUPTER_HPP PK��h!\��=� �� recycling_allocator.hppnu��[��// // detail/recycling_allocator.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_RECYCLING_ALLOCATOR_HPP #define BOOST_ASIO_DETAIL_RECYCLING_ALLOCATOR_HPP #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/detail/memory.hpp> #include <boost/asio/detail/thread_context.hpp> #include <boost/asio/detail/thread_info_base.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename T, typename Purpose = thread_info_base::default_tag> class recycling_allocator { public: typedef T value_type; template <typename U> struct rebind { typedef recycling_allocator<U, Purpose> other; }; recycling_allocator() { } template <typename U> recycling_allocator(const recycling_allocator<U, Purpose>&) { } T* allocate(std::size_t n) { typedef thread_context::thread_call_stack call_stack; void* p = thread_info_base::allocate(Purpose(), call_stack::top(), sizeof(T) * n); return static_cast<T>(p); } void deallocate(T p, std::size_t n) { typedef thread_context::thread_call_stack call_stack; thread_info_base::deallocate(Purpose(), call_stack::top(), p, sizeof(T) * n); } }; template <typename Purpose> class recycling_allocator<void, Purpose> { public: typedef void value_type; template <typename U> struct rebind { typedef recycling_allocator<U, Purpose> other; }; recycling_allocator() { } template <typename U> recycling_allocator(const recycling_allocator<U, Purpose>&) { } }; template <typename Allocator, typename Purpose> struct get_recycling_allocator { typedef Allocator type; static type get(const Allocator& a) { return a; } }; template <typename T, typename Purpose> struct get_recycling_allocator<std::allocator<T>, Purpose> { typedef recycling_allocator<T, Purpose> type; static type get(const std::allocator<T>&) { return type(); } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_RECYCLING_ALLOCATOR_HPP PK��h!\g=��reactive_socket_send_op.hppnu��[��// // detail/reactive_socket_send_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_REACTIVE_SOCKET_SEND_OP_HPP #define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SEND_OP_HPP #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/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename ConstBufferSequence> class reactive_socket_send_op_base : public reactor_op { public: reactive_socket_send_op_base(const boost::system::error_code& success_ec, socket_type socket, socket_ops::state_type state, const ConstBufferSequence& buffers, socket_base::message_flags flags, func_type complete_func) : reactor_op(success_ec, &reactive_socket_send_op_base::do_perform, complete_func), socket_(socket), state_(state), buffers_(buffers), flags_(flags) { } static status do_perform(reactor_op* base) { reactive_socket_send_op_base* o( static_cast<reactive_socket_send_op_base>(base)); typedef buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence> bufs_type; status result; if (bufs_type::is_single_buffer) { result = socket_ops::non_blocking_send1(o->socket_, bufs_type::first(o->buffers_).data(), bufs_type::first(o->buffers_).size(), o->flags_, o->ec_, o->bytes_transferred_) ? done : not_done; if (result == done) if ((o->state_ & socket_ops::stream_oriented) != 0) if (o->bytes_transferred_ < bufs_type::first(o->buffers_).size()) result = done_and_exhausted; } else { bufs_type bufs(o->buffers_); result = socket_ops::non_blocking_send(o->socket_, bufs.buffers(), bufs.count(), o->flags_, o->ec_, o->bytes_transferred_) ? done : not_done; if (result == done) if ((o->state_ & socket_ops::stream_oriented) != 0) if (o->bytes_transferred_ < bufs.total_size()) result = done_and_exhausted; } BOOST_ASIO_HANDLER_REACTOR_OPERATION((o, "non_blocking_send", o->ec_, o->bytes_transferred_)); return result; } private: socket_type socket_; socket_ops::state_type state_; ConstBufferSequence buffers_; socket_base::message_flags flags_; }; template <typename ConstBufferSequence, typename Handler, typename IoExecutor> class reactive_socket_send_op : public reactive_socket_send_op_base<ConstBufferSequence> { public: BOOST_ASIO_DEFINE_HANDLER_PTR(reactive_socket_send_op); reactive_socket_send_op(const boost::system::error_code& success_ec, socket_type socket, socket_ops::state_type state, const ConstBufferSequence& buffers, socket_base::message_flags flags, Handler& handler, const IoExecutor& io_ex) : reactive_socket_send_op_base<ConstBufferSequence>(success_ec, socket, state, buffers, flags, &reactive_socket_send_op::do_complete), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static void do_complete(void* owner, operation* base, const boost::system::error_code& /ec/, std::size_t /bytes_transferred/) { // Take ownership of the handler object. reactive_socket_send_op* o(static_cast<reactive_socket_send_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, o->ec_, o->bytes_transferred_); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SEND_OP_HPP PK��h!\׉�M��null_thread.hppnu��[��// // detail/null_thread.hpp // ~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_NULL_THREAD_HPP #define BOOST_ASIO_DETAIL_NULL_THREAD_HPP #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_HAS_THREADS) #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/throw_error.hpp> #include <boost/asio/error.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class null_thread : private noncopyable { public: // Constructor. template <typename Function> null_thread(Function, unsigned int = 0) { boost::asio::detail::throw_error( boost::asio::error::operation_not_supported, "thread"); } // Destructor. ~null_thread() { } // Wait for the thread to exit. void join() { } // Get number of CPUs. static std::size_t hardware_concurrency() { return 1; } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // !defined(BOOST_ASIO_HAS_THREADS) #endif // BOOST_ASIO_DETAIL_NULL_THREAD_HPP PK��h!\>{o��o��thread_context.hppnu��[��// // detail/thread_context.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_THREAD_CONTEXT_HPP #define BOOST_ASIO_DETAIL_THREAD_CONTEXT_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <climits> #include <cstddef> #include <boost/asio/detail/call_stack.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class thread_info_base; // Base class for things that manage threads (scheduler, win_iocp_io_context). class thread_context { public: // Per-thread call stack to track the state of each thread in the context. typedef call_stack<thread_context, thread_info_base> thread_call_stack; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_THREAD_CONTEXT_HPP PK��h!\o��throw_exception.hppnu��[��// // detail/throw_exception.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_THROW_EXCEPTION_HPP #define BOOST_ASIO_DETAIL_THROW_EXCEPTION_HPP #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_HAS_BOOST_THROW_EXCEPTION) # include <boost/throw_exception.hpp> #endif // defined(BOOST_ASIO_BOOST_THROW_EXCEPTION) namespace boost { namespace asio { namespace detail { #if defined(BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION) using boost::throw_exception; #else // defined(BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION) // Declare the throw_exception function for all targets. template <typename Exception> void throw_exception(const Exception& e); // Only define the throw_exception function when exceptions are enabled. // Otherwise, it is up to the application to provide a definition of this // function. # if !defined(BOOST_ASIO_NO_EXCEPTIONS) template <typename Exception> void throw_exception(const Exception& e) { throw e; } # endif // !defined(BOOST_ASIO_NO_EXCEPTIONS) #endif // defined(BOOST_ASIO_HAS_BOOST_THROW_EXCEPTION) } // namespace detail } // namespace asio } // namespace boost #endif // BOOST_ASIO_DETAIL_THROW_EXCEPTION_HPP PK��h!\��-��-�� win_iocp_serial_port_service.hppnu��[��// // detail/win_iocp_serial_port_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com) // Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.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_DETAIL_WIN_IOCP_SERIAL_PORT_SERVICE_HPP #define BOOST_ASIO_DETAIL_WIN_IOCP_SERIAL_PORT_SERVICE_HPP #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_HAS_IOCP) && defined(BOOST_ASIO_HAS_SERIAL_PORT) #include <string> #include <boost/asio/error.hpp> #include <boost/asio/execution_context.hpp> #include <boost/asio/detail/win_iocp_handle_service.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { // Extend win_iocp_handle_service to provide serial port support. class win_iocp_serial_port_service : public execution_context_service_base<win_iocp_serial_port_service> { public: // The native type of a serial port. typedef win_iocp_handle_service::native_handle_type native_handle_type; // The implementation type of the serial port. typedef win_iocp_handle_service::implementation_type implementation_type; // Constructor. BOOST_ASIO_DECL win_iocp_serial_port_service(execution_context& context); // Destroy all user-defined handler objects owned by the service. BOOST_ASIO_DECL void shutdown(); // Construct a new serial port implementation. void construct(implementation_type& impl) { handle_service_.construct(impl); } // Move-construct a new serial port implementation. void move_construct(implementation_type& impl, implementation_type& other_impl) { handle_service_.move_construct(impl, other_impl); } // Move-assign from another serial port implementation. void move_assign(implementation_type& impl, win_iocp_serial_port_service& other_service, implementation_type& other_impl) { handle_service_.move_assign(impl, other_service.handle_service_, other_impl); } // Destroy a serial port implementation. void destroy(implementation_type& impl) { handle_service_.destroy(impl); } // Open the serial port using the specified device name. BOOST_ASIO_DECL boost::system::error_code open(implementation_type& impl, const std::string& device, boost::system::error_code& ec); // Assign a native handle to a serial port implementation. boost::system::error_code assign(implementation_type& impl, const native_handle_type& handle, boost::system::error_code& ec) { return handle_service_.assign(impl, handle, ec); } // Determine whether the serial port is open. bool is_open(const implementation_type& impl) const { return handle_service_.is_open(impl); } // Destroy a serial port implementation. boost::system::error_code close(implementation_type& impl, boost::system::error_code& ec) { return handle_service_.close(impl, ec); } // Get the native serial port representation. native_handle_type native_handle(implementation_type& impl) { return handle_service_.native_handle(impl); } // Cancel all operations associated with the handle. boost::system::error_code cancel(implementation_type& impl, boost::system::error_code& ec) { return handle_service_.cancel(impl, ec); } // Set an option on the serial port. template <typename SettableSerialPortOption> boost::system::error_code set_option(implementation_type& impl, const SettableSerialPortOption& option, boost::system::error_code& ec) { return do_set_option(impl, &win_iocp_serial_port_service::store_option<SettableSerialPortOption>, &option, ec); } // Get an option from the serial port. template <typename GettableSerialPortOption> boost::system::error_code get_option(const implementation_type& impl, GettableSerialPortOption& option, boost::system::error_code& ec) const { return do_get_option(impl, &win_iocp_serial_port_service::load_option<GettableSerialPortOption>, &option, ec); } // Send a break sequence to the serial port. boost::system::error_code send_break(implementation_type&, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return ec; } // Write the given data. Returns the number of bytes sent. template <typename ConstBufferSequence> size_t write_some(implementation_type& impl, const ConstBufferSequence& buffers, boost::system::error_code& ec) { return handle_service_.write_some(impl, buffers, ec); } // Start an asynchronous write. The data being written must be valid for the // lifetime of the asynchronous operation. template <typename ConstBufferSequence, typename Handler, typename IoExecutor> void async_write_some(implementation_type& impl, const ConstBufferSequence& buffers, Handler& handler, const IoExecutor& io_ex) { handle_service_.async_write_some(impl, buffers, handler, io_ex); } // Read some data. Returns the number of bytes received. template <typename MutableBufferSequence> size_t read_some(implementation_type& impl, const MutableBufferSequence& buffers, boost::system::error_code& ec) { return handle_service_.read_some(impl, buffers, ec); } // Start an asynchronous read. The buffer for the data being received must be // valid for the lifetime of the asynchronous operation. template <typename MutableBufferSequence, typename Handler, typename IoExecutor> void async_read_some(implementation_type& impl, const MutableBufferSequence& buffers, Handler& handler, const IoExecutor& io_ex) { handle_service_.async_read_some(impl, buffers, handler, io_ex); } private: // Function pointer type for storing a serial port option. typedef boost::system::error_code (store_function_type)( const void, ::DCB&, boost::system::error_code&); // Helper function template to store a serial port option. template <typename SettableSerialPortOption> static boost::system::error_code store_option(const void* option, ::DCB& storage, boost::system::error_code& ec) { static_cast<const SettableSerialPortOption>(option)->store(storage, ec); return ec; } // Helper function to set a serial port option. BOOST_ASIO_DECL boost::system::error_code do_set_option( implementation_type& impl, store_function_type store, const void option, boost::system::error_code& ec); // Function pointer type for loading a serial port option. typedef boost::system::error_code (load_function_type)( void, const ::DCB&, boost::system::error_code&); // Helper function template to load a serial port option. template <typename GettableSerialPortOption> static boost::system::error_code load_option(void* option, const ::DCB& storage, boost::system::error_code& ec) { static_cast<GettableSerialPortOption>(option)->load(storage, ec); return ec; } // Helper function to get a serial port option. BOOST_ASIO_DECL boost::system::error_code do_get_option( const implementation_type& impl, load_function_type load, void option, boost::system::error_code& ec) const; // The implementation used for initiating asynchronous operations. win_iocp_handle_service handle_service_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #if defined(BOOST_ASIO_HEADER_ONLY) # include <boost/asio/detail/impl/win_iocp_serial_port_service.ipp> #endif // defined(BOOST_ASIO_HEADER_ONLY) #endif // defined(BOOST_ASIO_HAS_IOCP) && defined(BOOST_ASIO_HAS_SERIAL_PORT) #endif // BOOST_ASIO_DETAIL_WIN_IOCP_SERIAL_PORT_SERVICE_HPP PK��h!\�]eۇ)��)��consuming_buffers.hppnu��[��// // detail/consuming_buffers.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_CONSUMING_BUFFERS_HPP #define BOOST_ASIO_DETAIL_CONSUMING_BUFFERS_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <cstddef> #include <boost/asio/buffer.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/limits.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { // Helper template to determine the maximum number of prepared buffers. template <typename Buffers> struct prepared_buffers_max { enum { value = buffer_sequence_adapter_base::max_buffers }; }; template <typename Elem, std::size_t N> struct prepared_buffers_max<boost::array<Elem, N> > { enum { value = N }; }; #if defined(BOOST_ASIO_HAS_STD_ARRAY) template <typename Elem, std::size_t N> struct prepared_buffers_max<std::array<Elem, N> > { enum { value = N }; }; #endif // defined(BOOST_ASIO_HAS_STD_ARRAY) // A buffer sequence used to represent a subsequence of the buffers. template <typename Buffer, std::size_t MaxBuffers> struct prepared_buffers { typedef Buffer value_type; typedef const Buffer* const_iterator; enum { max_buffers = MaxBuffers < 16 ? MaxBuffers : 16 }; prepared_buffers() : count(0) {} const_iterator begin() const { return elems; } const_iterator end() const { return elems + count; } Buffer elems[max_buffers]; std::size_t count; }; // A proxy for a sub-range in a list of buffers. template <typename Buffer, typename Buffers, typename Buffer_Iterator> class consuming_buffers { public: typedef prepared_buffers<Buffer, prepared_buffers_max<Buffers>::value> prepared_buffers_type; // Construct to represent the entire list of buffers. explicit consuming_buffers(const Buffers& buffers) : buffers_(buffers), total_consumed_(0), next_elem_(0), next_elem_offset_(0) { using boost::asio::buffer_size; total_size_ = buffer_size(buffers); } // Determine if we are at the end of the buffers. bool empty() const { return total_consumed_ >= total_size_; } // Get the buffer for a single transfer, with a size. prepared_buffers_type prepare(std::size_t max_size) { prepared_buffers_type result; Buffer_Iterator next = boost::asio::buffer_sequence_begin(buffers_); Buffer_Iterator end = boost::asio::buffer_sequence_end(buffers_); std::advance(next, next_elem_); std::size_t elem_offset = next_elem_offset_; while (next != end && max_size > 0 && (result.count) < result.max_buffers) { Buffer next_buf = Buffer(next) + elem_offset; result.elems[result.count] = boost::asio::buffer(next_buf, max_size); max_size -= result.elems[result.count].size(); elem_offset = 0; if (result.elems[result.count].size() > 0) ++result.count; ++next; } return result; } // Consume the specified number of bytes from the buffers. void consume(std::size_t size) { total_consumed_ += size; Buffer_Iterator next = boost::asio::buffer_sequence_begin(buffers_); Buffer_Iterator end = boost::asio::buffer_sequence_end(buffers_); std::advance(next, next_elem_); while (next != end && size > 0) { Buffer next_buf = Buffer(next) + next_elem_offset_; if (size < next_buf.size()) { next_elem_offset_ += size; size = 0; } else { size -= next_buf.size(); next_elem_offset_ = 0; ++next_elem_; ++next; } } } // Get the total number of bytes consumed from the buffers. std::size_t total_consumed() const { return total_consumed_; } private: Buffers buffers_; std::size_t total_size_; std::size_t total_consumed_; std::size_t next_elem_; std::size_t next_elem_offset_; }; // Base class of all consuming_buffers specialisations for single buffers. template <typename Buffer> class consuming_single_buffer { public: // Construct to represent the entire list of buffers. template <typename Buffer1> explicit consuming_single_buffer(const Buffer1& buffer) : buffer_(buffer), total_consumed_(0) { } // Determine if we are at the end of the buffers. bool empty() const { return total_consumed_ >= buffer_.size(); } // Get the buffer for a single transfer, with a size. Buffer prepare(std::size_t max_size) { return boost::asio::buffer(buffer_ + total_consumed_, max_size); } // Consume the specified number of bytes from the buffers. void consume(std::size_t size) { total_consumed_ += size; } // Get the total number of bytes consumed from the buffers. std::size_t total_consumed() const { return total_consumed_; } private: Buffer buffer_; std::size_t total_consumed_; }; template <> class consuming_buffers<mutable_buffer, mutable_buffer, const mutable_buffer> : public consuming_single_buffer<BOOST_ASIO_MUTABLE_BUFFER> { public: explicit consuming_buffers(const mutable_buffer& buffer) : consuming_single_buffer<BOOST_ASIO_MUTABLE_BUFFER>(buffer) { } }; template <> class consuming_buffers<const_buffer, mutable_buffer, const mutable_buffer> : public consuming_single_buffer<BOOST_ASIO_CONST_BUFFER> { public: explicit consuming_buffers(const mutable_buffer& buffer) : consuming_single_buffer<BOOST_ASIO_CONST_BUFFER>(buffer) { } }; template <> class consuming_buffers<const_buffer, const_buffer, const const_buffer> : public consuming_single_buffer<BOOST_ASIO_CONST_BUFFER> { public: explicit consuming_buffers(const const_buffer& buffer) : consuming_single_buffer<BOOST_ASIO_CONST_BUFFER>(buffer) { } }; #if !defined(BOOST_ASIO_NO_DEPRECATED) template <> class consuming_buffers<mutable_buffer, mutable_buffers_1, const mutable_buffer> : public consuming_single_buffer<BOOST_ASIO_MUTABLE_BUFFER> { public: explicit consuming_buffers(const mutable_buffers_1& buffer) : consuming_single_buffer<BOOST_ASIO_MUTABLE_BUFFER>(buffer) { } }; template <> class consuming_buffers<const_buffer, mutable_buffers_1, const mutable_buffer> : public consuming_single_buffer<BOOST_ASIO_CONST_BUFFER> { public: explicit consuming_buffers(const mutable_buffers_1& buffer) : consuming_single_buffer<BOOST_ASIO_CONST_BUFFER>(buffer) { } }; template <> class consuming_buffers<const_buffer, const_buffers_1, const const_buffer> : public consuming_single_buffer<BOOST_ASIO_CONST_BUFFER> { public: explicit consuming_buffers(const const_buffers_1& buffer) : consuming_single_buffer<BOOST_ASIO_CONST_BUFFER>(buffer) { } }; #endif // !defined(BOOST_ASIO_NO_DEPRECATED) template <typename Buffer, typename Elem> class consuming_buffers<Buffer, boost::array<Elem, 2>, typename boost::array<Elem, 2>::const_iterator> { public: // Construct to represent the entire list of buffers. explicit consuming_buffers(const boost::array<Elem, 2>& buffers) : buffers_(buffers), total_consumed_(0) { } // Determine if we are at the end of the buffers. bool empty() const { return total_consumed_ >= Buffer(buffers_[0]).size() + Buffer(buffers_[1]).size(); } // Get the buffer for a single transfer, with a size. boost::array<Buffer, 2> prepare(std::size_t max_size) { boost::array<Buffer, 2> result = {{ Buffer(buffers_[0]), Buffer(buffers_[1]) }}; std::size_t buffer0_size = result[0].size(); result[0] = boost::asio::buffer(result[0] + total_consumed_, max_size); result[1] = boost::asio::buffer( result[1] + (total_consumed_ < buffer0_size ? 0 : total_consumed_ - buffer0_size), max_size - result[0].size()); return result; } // Consume the specified number of bytes from the buffers. void consume(std::size_t size) { total_consumed_ += size; } // Get the total number of bytes consumed from the buffers. std::size_t total_consumed() const { return total_consumed_; } private: boost::array<Elem, 2> buffers_; std::size_t total_consumed_; }; #if defined(BOOST_ASIO_HAS_STD_ARRAY) template <typename Buffer, typename Elem> class consuming_buffers<Buffer, std::array<Elem, 2>, typename std::array<Elem, 2>::const_iterator> { public: // Construct to represent the entire list of buffers. explicit consuming_buffers(const std::array<Elem, 2>& buffers) : buffers_(buffers), total_consumed_(0) { } // Determine if we are at the end of the buffers. bool empty() const { return total_consumed_ >= Buffer(buffers_[0]).size() + Buffer(buffers_[1]).size(); } // Get the buffer for a single transfer, with a size. std::array<Buffer, 2> prepare(std::size_t max_size) { std::array<Buffer, 2> result = {{ Buffer(buffers_[0]), Buffer(buffers_[1]) }}; std::size_t buffer0_size = result[0].size(); result[0] = boost::asio::buffer(result[0] + total_consumed_, max_size); result[1] = boost::asio::buffer( result[1] + (total_consumed_ < buffer0_size ? 0 : total_consumed_ - buffer0_size), max_size - result[0].size()); return result; } // Consume the specified number of bytes from the buffers. void consume(std::size_t size) { total_consumed_ += size; } // Get the total number of bytes consumed from the buffers. std::size_t total_consumed() const { return total_consumed_; } private: std::array<Elem, 2> buffers_; std::size_t total_consumed_; }; #endif // defined(BOOST_ASIO_HAS_STD_ARRAY) // Specialisation for null_buffers to ensure that the null_buffers type is // always passed through to the underlying read or write operation. template <typename Buffer> class consuming_buffers<Buffer, null_buffers, const mutable_buffer> : public boost::asio::null_buffers { public: consuming_buffers(const null_buffers&) { // No-op. } bool empty() { return false; } null_buffers prepare(std::size_t) { return null_buffers(); } void consume(std::size_t) { // No-op. } std::size_t total_consumed() const { return 0; } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_CONSUMING_BUFFERS_HPP PK��h!\9�� operation.hppnu��[��// // detail/operation.hpp // ~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_OPERATION_HPP #define BOOST_ASIO_DETAIL_OPERATION_HPP #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_HAS_IOCP) # include <boost/asio/detail/win_iocp_operation.hpp> #else # include <boost/asio/detail/scheduler_operation.hpp> #endif namespace boost { namespace asio { namespace detail { #if defined(BOOST_ASIO_HAS_IOCP) typedef win_iocp_operation operation; #else typedef scheduler_operation operation; #endif } // namespace detail } // namespace asio } // namespace boost #endif // BOOST_ASIO_DETAIL_OPERATION_HPP PK��h!\��K��winrt_ssocket_service.hppnu��[��// // detail/winrt_ssocket_service.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_WINRT_SSOCKET_SERVICE_HPP #define BOOST_ASIO_DETAIL_WINRT_SSOCKET_SERVICE_HPP #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_WINDOWS_RUNTIME) #include <boost/asio/error.hpp> #include <boost/asio/execution_context.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/winrt_socket_connect_op.hpp> #include <boost/asio/detail/winrt_ssocket_service_base.hpp> #include <boost/asio/detail/winrt_utils.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Protocol> class winrt_ssocket_service : public execution_context_service_base<winrt_ssocket_service<Protocol> >, public winrt_ssocket_service_base { public: // The protocol type. typedef Protocol protocol_type; // The endpoint type. typedef typename Protocol::endpoint endpoint_type; // The native type of a socket. typedef Windows::Networking::Sockets::StreamSocket^ native_handle_type; // The implementation type of the socket. struct implementation_type : base_implementation_type { // Default constructor. implementation_type() : base_implementation_type(), protocol_(endpoint_type().protocol()) { } // The protocol associated with the socket. protocol_type protocol_; }; // Constructor. winrt_ssocket_service(execution_context& context) : execution_context_service_base<winrt_ssocket_service<Protocol> >(context), winrt_ssocket_service_base(context) { } // Destroy all user-defined handler objects owned by the service. void shutdown() { this->base_shutdown(); } // Move-construct a new socket implementation. void move_construct(implementation_type& impl, implementation_type& other_impl) BOOST_ASIO_NOEXCEPT { this->base_move_construct(impl, other_impl); impl.protocol_ = other_impl.protocol_; other_impl.protocol_ = endpoint_type().protocol(); } // Move-assign from another socket implementation. void move_assign(implementation_type& impl, winrt_ssocket_service& other_service, implementation_type& other_impl) { this->base_move_assign(impl, other_service, other_impl); impl.protocol_ = other_impl.protocol_; other_impl.protocol_ = endpoint_type().protocol(); } // Move-construct a new socket implementation from another protocol type. template <typename Protocol1> void converting_move_construct(implementation_type& impl, winrt_ssocket_service<Protocol1>&, typename winrt_ssocket_service< Protocol1>::implementation_type& other_impl) { this->base_move_construct(impl, other_impl); impl.protocol_ = protocol_type(other_impl.protocol_); other_impl.protocol_ = typename Protocol1::endpoint().protocol(); } // Open a new socket implementation. boost::system::error_code open(implementation_type& impl, const protocol_type& protocol, boost::system::error_code& ec) { if (is_open(impl)) { ec = boost::asio::error::already_open; return ec; } try { impl.socket_ = ref new Windows::Networking::Sockets::StreamSocket; impl.protocol_ = protocol; ec = boost::system::error_code(); } catch (Platform::Exception^ e) { ec = boost::system::error_code(e->HResult, boost::system::system_category()); } return ec; } // Assign a native socket to a socket implementation. boost::system::error_code assign(implementation_type& impl, const protocol_type& protocol, const native_handle_type& native_socket, boost::system::error_code& ec) { if (is_open(impl)) { ec = boost::asio::error::already_open; return ec; } impl.socket_ = native_socket; impl.protocol_ = protocol; ec = boost::system::error_code(); return ec; } // Bind the socket to the specified local endpoint. boost::system::error_code bind(implementation_type&, const endpoint_type&, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return ec; } // Get the local endpoint. endpoint_type local_endpoint(const implementation_type& impl, boost::system::error_code& ec) const { endpoint_type endpoint; endpoint.resize(do_get_endpoint(impl, true, endpoint.data(), endpoint.size(), ec)); return endpoint; } // Get the remote endpoint. endpoint_type remote_endpoint(const implementation_type& impl, boost::system::error_code& ec) const { endpoint_type endpoint; endpoint.resize(do_get_endpoint(impl, false, endpoint.data(), endpoint.size(), ec)); return endpoint; } // Disable sends or receives on the socket. boost::system::error_code shutdown(implementation_type&, socket_base::shutdown_type, boost::system::error_code& ec) { ec = boost::asio::error::operation_not_supported; return ec; } // Set a socket option. template <typename Option> boost::system::error_code set_option(implementation_type& impl, const Option& option, boost::system::error_code& ec) { return do_set_option(impl, option.level(impl.protocol_), option.name(impl.protocol_), option.data(impl.protocol_), option.size(impl.protocol_), ec); } // Get a socket option. template <typename Option> boost::system::error_code get_option(const implementation_type& impl, Option& option, boost::system::error_code& ec) const { std::size_t size = option.size(impl.protocol_); do_get_option(impl, option.level(impl.protocol_), option.name(impl.protocol_), option.data(impl.protocol_), &size, ec); if (!ec) option.resize(impl.protocol_, size); return ec; } // Connect the socket to the specified endpoint. boost::system::error_code connect(implementation_type& impl, const endpoint_type& peer_endpoint, boost::system::error_code& ec) { return do_connect(impl, peer_endpoint.data(), ec); } // Start an asynchronous connect. template <typename Handler, typename IoExecutor> void async_connect(implementation_type& impl, const endpoint_type& peer_endpoint, Handler& handler, const IoExecutor& io_ex) { bool is_continuation = boost_asio_handler_cont_helpers::is_continuation(handler); // Allocate and construct an operation to wrap the handler. typedef winrt_socket_connect_op<Handler, IoExecutor> op; typename op::ptr p = { boost::asio::detail::addressof(handler), op::ptr::allocate(handler), 0 }; p.p = new (p.v) op(handler, io_ex); BOOST_ASIO_HANDLER_CREATION((scheduler_.context(), p.p, "socket", &impl, 0, "async_connect")); start_connect_op(impl, peer_endpoint.data(), p.p, is_continuation); p.v = p.p = 0; } }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_WINDOWS_RUNTIME) #endif // BOOST_ASIO_DETAIL_WINRT_SSOCKET_SERVICE_HPP PK��h!\��,��std_thread.hppnu��[��// // detail/std_thread.hpp // ~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_STD_THREAD_HPP #define BOOST_ASIO_DETAIL_STD_THREAD_HPP #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_HAS_STD_THREAD) #include <thread> #include <boost/asio/detail/noncopyable.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { class std_thread : private noncopyable { public: // Constructor. template <typename Function> std_thread(Function f, unsigned int = 0) : thread_(f) { } // Destructor. ~std_thread() { join(); } // Wait for the thread to exit. void join() { if (thread_.joinable()) thread_.join(); } // Get number of CPUs. static std::size_t hardware_concurrency() { return std::thread::hardware_concurrency(); } private: std::thread thread_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // defined(BOOST_ASIO_HAS_STD_THREAD) #endif // BOOST_ASIO_DETAIL_STD_THREAD_HPP PK��h!\�-��reactive_socket_sendto_op.hppnu��[��// // detail/reactive_socket_sendto_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_REACTIVE_SOCKET_SENDTO_OP_HPP #define BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SENDTO_OP_HPP #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/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_alloc_helpers.hpp> #include <boost/asio/detail/handler_invoke_helpers.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/socket_ops.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename ConstBufferSequence, typename Endpoint> class reactive_socket_sendto_op_base : public reactor_op { public: reactive_socket_sendto_op_base(const boost::system::error_code& success_ec, socket_type socket, const ConstBufferSequence& buffers, const Endpoint& endpoint, socket_base::message_flags flags, func_type complete_func) : reactor_op(success_ec, &reactive_socket_sendto_op_base::do_perform, complete_func), socket_(socket), buffers_(buffers), destination_(endpoint), flags_(flags) { } static status do_perform(reactor_op* base) { reactive_socket_sendto_op_base* o( static_cast<reactive_socket_sendto_op_base>(base)); typedef buffer_sequence_adapter<boost::asio::const_buffer, ConstBufferSequence> bufs_type; status result; if (bufs_type::is_single_buffer) { result = socket_ops::non_blocking_sendto1(o->socket_, bufs_type::first(o->buffers_).data(), bufs_type::first(o->buffers_).size(), o->flags_, o->destination_.data(), o->destination_.size(), o->ec_, o->bytes_transferred_) ? done : not_done; } else { bufs_type bufs(o->buffers_); result = socket_ops::non_blocking_sendto(o->socket_, bufs.buffers(), bufs.count(), o->flags_, o->destination_.data(), o->destination_.size(), o->ec_, o->bytes_transferred_) ? done : not_done; } BOOST_ASIO_HANDLER_REACTOR_OPERATION((o, "non_blocking_sendto", o->ec_, o->bytes_transferred_)); return result; } private: socket_type socket_; ConstBufferSequence buffers_; Endpoint destination_; socket_base::message_flags flags_; }; template <typename ConstBufferSequence, typename Endpoint, typename Handler, typename IoExecutor> class reactive_socket_sendto_op : public reactive_socket_sendto_op_base<ConstBufferSequence, Endpoint> { public: BOOST_ASIO_DEFINE_HANDLER_PTR(reactive_socket_sendto_op); reactive_socket_sendto_op(const boost::system::error_code& success_ec, socket_type socket, const ConstBufferSequence& buffers, const Endpoint& endpoint, socket_base::message_flags flags, Handler& handler, const IoExecutor& io_ex) : reactive_socket_sendto_op_base<ConstBufferSequence, Endpoint>( success_ec, socket, buffers, endpoint, flags, &reactive_socket_sendto_op::do_complete), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static void do_complete(void* owner, operation* base, const boost::system::error_code& /ec/, std::size_t /bytes_transferred/) { // Take ownership of the handler object. reactive_socket_sendto_op* o(static_cast<reactive_socket_sendto_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, o->ec_, o->bytes_transferred_); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_DETAIL_REACTIVE_SOCKET_SENDTO_OP_HPP PK��h!\��descriptor_read_op.hppnu��[��// // detail/descriptor_read_op.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_DESCRIPTOR_READ_OP_HPP #define BOOST_ASIO_DETAIL_DESCRIPTOR_READ_OP_HPP #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_WINDOWS) && !defined(__CYGWIN__) #include <boost/asio/detail/bind_handler.hpp> #include <boost/asio/detail/buffer_sequence_adapter.hpp> #include <boost/asio/detail/descriptor_ops.hpp> #include <boost/asio/detail/fenced_block.hpp> #include <boost/asio/detail/handler_work.hpp> #include <boost/asio/detail/memory.hpp> #include <boost/asio/detail/reactor_op.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename MutableBufferSequence> class descriptor_read_op_base : public reactor_op { public: descriptor_read_op_base(const boost::system::error_code& success_ec, int descriptor, const MutableBufferSequence& buffers, func_type complete_func) : reactor_op(success_ec, &descriptor_read_op_base::do_perform, complete_func), descriptor_(descriptor), buffers_(buffers) { } static status do_perform(reactor_op* base) { descriptor_read_op_base* o(static_cast<descriptor_read_op_base>(base)); typedef buffer_sequence_adapter<boost::asio::mutable_buffer, MutableBufferSequence> bufs_type; status result; if (bufs_type::is_single_buffer) { result = descriptor_ops::non_blocking_read1(o->descriptor_, bufs_type::first(o->buffers_).data(), bufs_type::first(o->buffers_).size(), o->ec_, o->bytes_transferred_) ? done : not_done; } else { bufs_type bufs(o->buffers_); result = descriptor_ops::non_blocking_read(o->descriptor_, bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_) ? done : not_done; } BOOST_ASIO_HANDLER_REACTOR_OPERATION((o, "non_blocking_read", o->ec_, o->bytes_transferred_)); return result; } private: int descriptor_; MutableBufferSequence buffers_; }; template <typename MutableBufferSequence, typename Handler, typename IoExecutor> class descriptor_read_op : public descriptor_read_op_base<MutableBufferSequence> { public: BOOST_ASIO_DEFINE_HANDLER_PTR(descriptor_read_op); descriptor_read_op(const boost::system::error_code& success_ec, int descriptor, const MutableBufferSequence& buffers, Handler& handler, const IoExecutor& io_ex) : descriptor_read_op_base<MutableBufferSequence>(success_ec, descriptor, buffers, &descriptor_read_op::do_complete), handler_(BOOST_ASIO_MOVE_CAST(Handler)(handler)), work_(handler_, io_ex) { } static void do_complete(void* owner, operation* base, const boost::system::error_code& /ec/, std::size_t /bytes_transferred/) { // Take ownership of the handler object. descriptor_read_op* o(static_cast<descriptor_read_op>(base)); ptr p = { boost::asio::detail::addressof(o->handler_), o, o }; BOOST_ASIO_HANDLER_COMPLETION((o)); // Take ownership of the operation's outstanding work. handler_work<Handler, IoExecutor> w( BOOST_ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)( o->work_)); // Make a copy of the handler so that the memory can be deallocated before // the upcall is made. Even if we're not about to make an upcall, a // sub-object of the handler may be the true owner of the memory associated // with the handler. Consequently, a local copy of the handler is required // to ensure that any owning sub-object remains valid until after we have // deallocated the memory here. detail::binder2<Handler, boost::system::error_code, std::size_t> handler(o->handler_, o->ec_, o->bytes_transferred_); p.h = boost::asio::detail::addressof(handler.handler_); p.reset(); // Make the upcall if required. if (owner) { fenced_block b(fenced_block::half); BOOST_ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_)); w.complete(handler, handler.handler_); BOOST_ASIO_HANDLER_INVOCATION_END; } } private: Handler handler_; handler_work<Handler, IoExecutor> work_; }; } // namespace detail } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // !defined(BOOST_ASIO_WINDOWS) && !defined(__CYGWIN__) #endif // BOOST_ASIO_DETAIL_DESCRIPTOR_READ_OP_HPP PK��h!\G�D7��7�� memory.hppnu��[��// // detail/memory.hpp // ~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_MEMORY_HPP #define BOOST_ASIO_DETAIL_MEMORY_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <memory> #if !defined(BOOST_ASIO_HAS_STD_SHARED_PTR) # include <boost/make_shared.hpp> # include <boost/shared_ptr.hpp> # include <boost/weak_ptr.hpp> #endif // !defined(BOOST_ASIO_HAS_STD_SHARED_PTR) #if !defined(BOOST_ASIO_HAS_STD_ADDRESSOF) # include <boost/utility/addressof.hpp> #endif // !defined(BOOST_ASIO_HAS_STD_ADDRESSOF) namespace boost { namespace asio { namespace detail { #if defined(BOOST_ASIO_HAS_STD_SHARED_PTR) using std::make_shared; using std::shared_ptr; using std::weak_ptr; #else // defined(BOOST_ASIO_HAS_STD_SHARED_PTR) using boost::make_shared; using boost::shared_ptr; using boost::weak_ptr; #endif // defined(BOOST_ASIO_HAS_STD_SHARED_PTR) #if defined(BOOST_ASIO_HAS_STD_ADDRESSOF) using std::addressof; #else // defined(BOOST_ASIO_HAS_STD_ADDRESSOF) using boost::addressof; #endif // defined(BOOST_ASIO_HAS_STD_ADDRESSOF) } // namespace detail #if defined(BOOST_ASIO_HAS_CXX11_ALLOCATORS) using std::allocator_arg_t; # define BOOST_ASIO_USES_ALLOCATOR(t) \ namespace std { \ template <typename Allocator> \ struct uses_allocator<t, Allocator> : true_type {}; \ } \ // # define BOOST_ASIO_REBIND_ALLOC(alloc, t) \ typename std::allocator_traits<alloc>::template rebind_alloc<t> // #else // defined(BOOST_ASIO_HAS_CXX11_ALLOCATORS) struct allocator_arg_t {}; # define BOOST_ASIO_USES_ALLOCATOR(t) # define BOOST_ASIO_REBIND_ALLOC(alloc, t) \ typename alloc::template rebind<t>::other /**/ #endif // defined(BOOST_ASIO_HAS_CXX11_ALLOCATORS) } // namespace asio } // namespace boost #endif // BOOST_ASIO_DETAIL_MEMORY_HPP PK��h!\�)� ��reactor.hppnu��[��// // detail/reactor.hpp // ~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_REACTOR_HPP #define BOOST_ASIO_DETAIL_REACTOR_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/reactor_fwd.hpp> #if defined(BOOST_ASIO_HAS_EPOLL) # include <boost/asio/detail/epoll_reactor.hpp> #elif defined(BOOST_ASIO_HAS_KQUEUE) # include <boost/asio/detail/kqueue_reactor.hpp> #elif defined(BOOST_ASIO_HAS_DEV_POLL) # include <boost/asio/detail/dev_poll_reactor.hpp> #elif defined(BOOST_ASIO_HAS_IOCP) \|\| defined(BOOST_ASIO_WINDOWS_RUNTIME) # include <boost/asio/detail/null_reactor.hpp> #else # include <boost/asio/detail/select_reactor.hpp> #endif #endif // BOOST_ASIO_DETAIL_REACTOR_HPP PK��h!\F�ҁ��gcc_sync_fenced_block.hppnu��[��// // detail/gcc_sync_fenced_block.hpp // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // // Copyright (c) 2003-2020 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_DETAIL_GCC_SYNC_FENCED_BLOCK_HPP #define BOOST_ASIO_DETAIL_GCC_SYNC_FENCED_BLOCK_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #if defined(__GNUC__) \ && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 1) \|\| (__GNUC__ > 4)) \ && !defined(__INTEL_COMPIL

| ver. 1.6 | Github | . | PHP 8.2.30 | ??????????? ?????????: 0.46 | proxy | phpinfo | ???????????