| // |
| // ip/basic_resolver.hpp |
| // ~~~~~~~~~~~~~~~~~~~~~ |
| // |
| // Copyright (c) 2003-2021 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_IP_BASIC_RESOLVER_HPP |
| #define BOOST_ASIO_IP_BASIC_RESOLVER_HPP |
| |
| #if defined(_MSC_VER) && (_MSC_VER >= 1200) |
| # pragma once |
| #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) |
| |
| #include <boost/asio/detail/config.hpp> |
| #include <string> |
| #include <boost/asio/any_io_executor.hpp> |
| #include <boost/asio/async_result.hpp> |
| #include <boost/asio/detail/handler_type_requirements.hpp> |
| #include <boost/asio/detail/io_object_impl.hpp> |
| #include <boost/asio/detail/non_const_lvalue.hpp> |
| #include <boost/asio/detail/string_view.hpp> |
| #include <boost/asio/detail/throw_error.hpp> |
| #include <boost/asio/error.hpp> |
| #include <boost/asio/execution_context.hpp> |
| #include <boost/asio/ip/basic_resolver_iterator.hpp> |
| #include <boost/asio/ip/basic_resolver_query.hpp> |
| #include <boost/asio/ip/basic_resolver_results.hpp> |
| #include <boost/asio/ip/resolver_base.hpp> |
| #if defined(BOOST_ASIO_WINDOWS_RUNTIME) |
| # include <boost/asio/detail/winrt_resolver_service.hpp> |
| #else |
| # include <boost/asio/detail/resolver_service.hpp> |
| #endif |
| |
| #if defined(BOOST_ASIO_HAS_MOVE) |
| # include <utility> |
| #endif // defined(BOOST_ASIO_HAS_MOVE) |
| |
| #include <boost/asio/detail/push_options.hpp> |
| |
| namespace boost { |
| namespace asio { |
| namespace ip { |
| |
| #if !defined(BOOST_ASIO_IP_BASIC_RESOLVER_FWD_DECL) |
| #define BOOST_ASIO_IP_BASIC_RESOLVER_FWD_DECL |
| |
| // Forward declaration with defaulted arguments. |
| template <typename InternetProtocol, typename Executor = any_io_executor> |
| class basic_resolver; |
| |
| #endif // !defined(BOOST_ASIO_IP_BASIC_RESOLVER_FWD_DECL) |
| |
| /// Provides endpoint resolution functionality. |
| /** |
| * The basic_resolver class template provides the ability to resolve a query |
| * to a list of endpoints. |
| * |
| * @par Thread Safety |
| * @e Distinct @e objects: Safe.@n |
| * @e Shared @e objects: Unsafe. |
| */ |
| template <typename InternetProtocol, typename Executor> |
| class basic_resolver |
| : public resolver_base |
| { |
| public: |
| /// The type of the executor associated with the object. |
| typedef Executor executor_type; |
| |
| /// Rebinds the resolver type to another executor. |
| template <typename Executor1> |
| struct rebind_executor |
| { |
| /// The resolver type when rebound to the specified executor. |
| typedef basic_resolver<InternetProtocol, Executor1> other; |
| }; |
| |
| /// The protocol type. |
| typedef InternetProtocol protocol_type; |
| |
| /// The endpoint type. |
| typedef typename InternetProtocol::endpoint endpoint_type; |
| |
| #if !defined(BOOST_ASIO_NO_DEPRECATED) |
| /// (Deprecated.) The query type. |
| typedef basic_resolver_query<InternetProtocol> query; |
| |
| /// (Deprecated.) The iterator type. |
| typedef basic_resolver_iterator<InternetProtocol> iterator; |
| #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
| |
| /// The results type. |
| typedef basic_resolver_results<InternetProtocol> results_type; |
| |
| /// Construct with executor. |
| /** |
| * This constructor creates a basic_resolver. |
| * |
| * @param ex The I/O executor that the resolver will use, by default, to |
| * dispatch handlers for any asynchronous operations performed on the |
| * resolver. |
| */ |
| explicit basic_resolver(const executor_type& ex) |
| : impl_(0, ex) |
| { |
| } |
| |
| /// Construct with execution context. |
| /** |
| * This constructor creates a basic_resolver. |
| * |
| * @param context An execution context which provides the I/O executor that |
| * the resolver will use, by default, to dispatch handlers for any |
| * asynchronous operations performed on the resolver. |
| */ |
| template <typename ExecutionContext> |
| explicit basic_resolver(ExecutionContext& context, |
| typename constraint< |
| is_convertible<ExecutionContext&, execution_context&>::value |
| >::type = 0) |
| : impl_(0, 0, context) |
| { |
| } |
| |
| #if defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) |
| /// Move-construct a basic_resolver from another. |
| /** |
| * This constructor moves a resolver from one object to another. |
| * |
| * @param other The other basic_resolver object from which the move will |
| * occur. |
| * |
| * @note Following the move, the moved-from object is in the same state as if |
| * constructed using the @c basic_resolver(const executor_type&) constructor. |
| */ |
| basic_resolver(basic_resolver&& other) |
| : impl_(std::move(other.impl_)) |
| { |
| } |
| |
| // All resolvers have access to each other's implementations. |
| template <typename InternetProtocol1, typename Executor1> |
| friend class basic_resolver; |
| |
| /// Move-construct a basic_resolver from another. |
| /** |
| * This constructor moves a resolver from one object to another. |
| * |
| * @param other The other basic_resolver object from which the move will |
| * occur. |
| * |
| * @note Following the move, the moved-from object is in the same state as if |
| * constructed using the @c basic_resolver(const executor_type&) constructor. |
| */ |
| template <typename Executor1> |
| basic_resolver(basic_resolver<InternetProtocol, Executor1>&& other, |
| typename constraint< |
| is_convertible<Executor1, Executor>::value |
| >::type = 0) |
| : impl_(std::move(other.impl_)) |
| { |
| } |
| |
| /// Move-assign a basic_resolver from another. |
| /** |
| * This assignment operator moves a resolver from one object to another. |
| * Cancels any outstanding asynchronous operations associated with the target |
| * object. |
| * |
| * @param other The other basic_resolver object from which the move will |
| * occur. |
| * |
| * @note Following the move, the moved-from object is in the same state as if |
| * constructed using the @c basic_resolver(const executor_type&) constructor. |
| */ |
| basic_resolver& operator=(basic_resolver&& other) |
| { |
| impl_ = std::move(other.impl_); |
| return *this; |
| } |
| |
| /// Move-assign a basic_resolver from another. |
| /** |
| * This assignment operator moves a resolver from one object to another. |
| * Cancels any outstanding asynchronous operations associated with the target |
| * object. |
| * |
| * @param other The other basic_resolver object from which the move will |
| * occur. |
| * |
| * @note Following the move, the moved-from object is in the same state as if |
| * constructed using the @c basic_resolver(const executor_type&) constructor. |
| */ |
| template <typename Executor1> |
| typename constraint< |
| is_convertible<Executor1, Executor>::value, |
| basic_resolver& |
| >::type operator=(basic_resolver<InternetProtocol, Executor1>&& other) |
| { |
| basic_resolver tmp(std::move(other)); |
| impl_ = std::move(tmp.impl_); |
| return *this; |
| } |
| #endif // defined(BOOST_ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION) |
| |
| /// Destroys the resolver. |
| /** |
| * This function destroys the resolver, cancelling any outstanding |
| * asynchronous wait operations associated with the resolver as if by calling |
| * @c cancel. |
| */ |
| ~basic_resolver() |
| { |
| } |
| |
| /// Get the executor associated with the object. |
| executor_type get_executor() BOOST_ASIO_NOEXCEPT |
| { |
| return impl_.get_executor(); |
| } |
| |
| /// Cancel any asynchronous operations that are waiting on the resolver. |
| /** |
| * This function forces the completion of any pending asynchronous |
| * operations on the host resolver. The handler for each cancelled operation |
| * will be invoked with the boost::asio::error::operation_aborted error code. |
| */ |
| void cancel() |
| { |
| return impl_.get_service().cancel(impl_.get_implementation()); |
| } |
| |
| #if !defined(BOOST_ASIO_NO_DEPRECATED) |
| /// (Deprecated: Use overload with separate host and service parameters.) |
| /// Perform forward resolution of a query to a list of entries. |
| /** |
| * This function is used to resolve a query into a list of endpoint entries. |
| * |
| * @param q A query object that determines what endpoints will be returned. |
| * |
| * @returns A range object representing the list of endpoint entries. A |
| * successful call to this function is guaranteed to return a non-empty |
| * range. |
| * |
| * @throws boost::system::system_error Thrown on failure. |
| */ |
| results_type resolve(const query& q) |
| { |
| boost::system::error_code ec; |
| results_type r = impl_.get_service().resolve( |
| impl_.get_implementation(), q, ec); |
| boost::asio::detail::throw_error(ec, "resolve"); |
| return r; |
| } |
| |
| /// (Deprecated: Use overload with separate host and service parameters.) |
| /// Perform forward resolution of a query to a list of entries. |
| /** |
| * This function is used to resolve a query into a list of endpoint entries. |
| * |
| * @param q A query object that determines what endpoints will be returned. |
| * |
| * @param ec Set to indicate what error occurred, if any. |
| * |
| * @returns A range object representing the list of endpoint entries. An |
| * empty range is returned if an error occurs. A successful call to this |
| * function is guaranteed to return a non-empty range. |
| */ |
| results_type resolve(const query& q, boost::system::error_code& ec) |
| { |
| return impl_.get_service().resolve(impl_.get_implementation(), q, ec); |
| } |
| #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
| |
| /// Perform forward resolution of a query to a list of entries. |
| /** |
| * This function is used to resolve host and service names into a list of |
| * endpoint entries. |
| * |
| * @param host A string identifying a location. May be a descriptive name or |
| * a numeric address string. If an empty string and the passive flag has been |
| * specified, the resolved endpoints are suitable for local service binding. |
| * If an empty string and passive is not specified, the resolved endpoints |
| * will use the loopback address. |
| * |
| * @param service A string identifying the requested service. This may be a |
| * descriptive name or a numeric string corresponding to a port number. May |
| * be an empty string, in which case all resolved endpoints will have a port |
| * number of 0. |
| * |
| * @returns A range object representing the list of endpoint entries. A |
| * successful call to this function is guaranteed to return a non-empty |
| * range. |
| * |
| * @throws boost::system::system_error Thrown on failure. |
| * |
| * @note On POSIX systems, host names may be locally defined in the file |
| * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name |
| * resolution is performed using DNS. Operating systems may use additional |
| * locations when resolving host names (such as NETBIOS names on Windows). |
| * |
| * On POSIX systems, service names are typically defined in the file |
| * <tt>/etc/services</tt>. On Windows, service names may be found in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems |
| * may use additional locations when resolving service names. |
| */ |
| results_type resolve(BOOST_ASIO_STRING_VIEW_PARAM host, |
| BOOST_ASIO_STRING_VIEW_PARAM service) |
| { |
| return resolve(host, service, resolver_base::flags()); |
| } |
| |
| /// Perform forward resolution of a query to a list of entries. |
| /** |
| * This function is used to resolve host and service names into a list of |
| * endpoint entries. |
| * |
| * @param host A string identifying a location. May be a descriptive name or |
| * a numeric address string. If an empty string and the passive flag has been |
| * specified, the resolved endpoints are suitable for local service binding. |
| * If an empty string and passive is not specified, the resolved endpoints |
| * will use the loopback address. |
| * |
| * @param service A string identifying the requested service. This may be a |
| * descriptive name or a numeric string corresponding to a port number. May |
| * be an empty string, in which case all resolved endpoints will have a port |
| * number of 0. |
| * |
| * @param ec Set to indicate what error occurred, if any. |
| * |
| * @returns A range object representing the list of endpoint entries. An |
| * empty range is returned if an error occurs. A successful call to this |
| * function is guaranteed to return a non-empty range. |
| * |
| * @note On POSIX systems, host names may be locally defined in the file |
| * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name |
| * resolution is performed using DNS. Operating systems may use additional |
| * locations when resolving host names (such as NETBIOS names on Windows). |
| * |
| * On POSIX systems, service names are typically defined in the file |
| * <tt>/etc/services</tt>. On Windows, service names may be found in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems |
| * may use additional locations when resolving service names. |
| */ |
| results_type resolve(BOOST_ASIO_STRING_VIEW_PARAM host, |
| BOOST_ASIO_STRING_VIEW_PARAM service, boost::system::error_code& ec) |
| { |
| return resolve(host, service, resolver_base::flags(), ec); |
| } |
| |
| /// Perform forward resolution of a query to a list of entries. |
| /** |
| * This function is used to resolve host and service names into a list of |
| * endpoint entries. |
| * |
| * @param host A string identifying a location. May be a descriptive name or |
| * a numeric address string. If an empty string and the passive flag has been |
| * specified, the resolved endpoints are suitable for local service binding. |
| * If an empty string and passive is not specified, the resolved endpoints |
| * will use the loopback address. |
| * |
| * @param service A string identifying the requested service. This may be a |
| * descriptive name or a numeric string corresponding to a port number. May |
| * be an empty string, in which case all resolved endpoints will have a port |
| * number of 0. |
| * |
| * @param resolve_flags A set of flags that determine how name resolution |
| * should be performed. The default flags are suitable for communication with |
| * remote hosts. See the @ref resolver_base documentation for the set of |
| * available flags. |
| * |
| * @returns A range object representing the list of endpoint entries. A |
| * successful call to this function is guaranteed to return a non-empty |
| * range. |
| * |
| * @throws boost::system::system_error Thrown on failure. |
| * |
| * @note On POSIX systems, host names may be locally defined in the file |
| * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name |
| * resolution is performed using DNS. Operating systems may use additional |
| * locations when resolving host names (such as NETBIOS names on Windows). |
| * |
| * On POSIX systems, service names are typically defined in the file |
| * <tt>/etc/services</tt>. On Windows, service names may be found in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems |
| * may use additional locations when resolving service names. |
| */ |
| results_type resolve(BOOST_ASIO_STRING_VIEW_PARAM host, |
| BOOST_ASIO_STRING_VIEW_PARAM service, resolver_base::flags resolve_flags) |
| { |
| boost::system::error_code ec; |
| basic_resolver_query<protocol_type> q(static_cast<std::string>(host), |
| static_cast<std::string>(service), resolve_flags); |
| results_type r = impl_.get_service().resolve( |
| impl_.get_implementation(), q, ec); |
| boost::asio::detail::throw_error(ec, "resolve"); |
| return r; |
| } |
| |
| /// Perform forward resolution of a query to a list of entries. |
| /** |
| * This function is used to resolve host and service names into a list of |
| * endpoint entries. |
| * |
| * @param host A string identifying a location. May be a descriptive name or |
| * a numeric address string. If an empty string and the passive flag has been |
| * specified, the resolved endpoints are suitable for local service binding. |
| * If an empty string and passive is not specified, the resolved endpoints |
| * will use the loopback address. |
| * |
| * @param service A string identifying the requested service. This may be a |
| * descriptive name or a numeric string corresponding to a port number. May |
| * be an empty string, in which case all resolved endpoints will have a port |
| * number of 0. |
| * |
| * @param resolve_flags A set of flags that determine how name resolution |
| * should be performed. The default flags are suitable for communication with |
| * remote hosts. See the @ref resolver_base documentation for the set of |
| * available flags. |
| * |
| * @param ec Set to indicate what error occurred, if any. |
| * |
| * @returns A range object representing the list of endpoint entries. An |
| * empty range is returned if an error occurs. A successful call to this |
| * function is guaranteed to return a non-empty range. |
| * |
| * @note On POSIX systems, host names may be locally defined in the file |
| * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name |
| * resolution is performed using DNS. Operating systems may use additional |
| * locations when resolving host names (such as NETBIOS names on Windows). |
| * |
| * On POSIX systems, service names are typically defined in the file |
| * <tt>/etc/services</tt>. On Windows, service names may be found in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems |
| * may use additional locations when resolving service names. |
| */ |
| results_type resolve(BOOST_ASIO_STRING_VIEW_PARAM host, |
| BOOST_ASIO_STRING_VIEW_PARAM service, resolver_base::flags resolve_flags, |
| boost::system::error_code& ec) |
| { |
| basic_resolver_query<protocol_type> q(static_cast<std::string>(host), |
| static_cast<std::string>(service), resolve_flags); |
| return impl_.get_service().resolve(impl_.get_implementation(), q, ec); |
| } |
| |
| /// Perform forward resolution of a query to a list of entries. |
| /** |
| * This function is used to resolve host and service names into a list of |
| * endpoint entries. |
| * |
| * @param protocol A protocol object, normally representing either the IPv4 or |
| * IPv6 version of an internet protocol. |
| * |
| * @param host A string identifying a location. May be a descriptive name or |
| * a numeric address string. If an empty string and the passive flag has been |
| * specified, the resolved endpoints are suitable for local service binding. |
| * If an empty string and passive is not specified, the resolved endpoints |
| * will use the loopback address. |
| * |
| * @param service A string identifying the requested service. This may be a |
| * descriptive name or a numeric string corresponding to a port number. May |
| * be an empty string, in which case all resolved endpoints will have a port |
| * number of 0. |
| * |
| * @returns A range object representing the list of endpoint entries. A |
| * successful call to this function is guaranteed to return a non-empty |
| * range. |
| * |
| * @throws boost::system::system_error Thrown on failure. |
| * |
| * @note On POSIX systems, host names may be locally defined in the file |
| * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name |
| * resolution is performed using DNS. Operating systems may use additional |
| * locations when resolving host names (such as NETBIOS names on Windows). |
| * |
| * On POSIX systems, service names are typically defined in the file |
| * <tt>/etc/services</tt>. On Windows, service names may be found in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems |
| * may use additional locations when resolving service names. |
| */ |
| results_type resolve(const protocol_type& protocol, |
| BOOST_ASIO_STRING_VIEW_PARAM host, BOOST_ASIO_STRING_VIEW_PARAM service) |
| { |
| return resolve(protocol, host, service, resolver_base::flags()); |
| } |
| |
| /// Perform forward resolution of a query to a list of entries. |
| /** |
| * This function is used to resolve host and service names into a list of |
| * endpoint entries. |
| * |
| * @param protocol A protocol object, normally representing either the IPv4 or |
| * IPv6 version of an internet protocol. |
| * |
| * @param host A string identifying a location. May be a descriptive name or |
| * a numeric address string. If an empty string and the passive flag has been |
| * specified, the resolved endpoints are suitable for local service binding. |
| * If an empty string and passive is not specified, the resolved endpoints |
| * will use the loopback address. |
| * |
| * @param service A string identifying the requested service. This may be a |
| * descriptive name or a numeric string corresponding to a port number. May |
| * be an empty string, in which case all resolved endpoints will have a port |
| * number of 0. |
| * |
| * @param ec Set to indicate what error occurred, if any. |
| * |
| * @returns A range object representing the list of endpoint entries. An |
| * empty range is returned if an error occurs. A successful call to this |
| * function is guaranteed to return a non-empty range. |
| * |
| * @note On POSIX systems, host names may be locally defined in the file |
| * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name |
| * resolution is performed using DNS. Operating systems may use additional |
| * locations when resolving host names (such as NETBIOS names on Windows). |
| * |
| * On POSIX systems, service names are typically defined in the file |
| * <tt>/etc/services</tt>. On Windows, service names may be found in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems |
| * may use additional locations when resolving service names. |
| */ |
| results_type resolve(const protocol_type& protocol, |
| BOOST_ASIO_STRING_VIEW_PARAM host, BOOST_ASIO_STRING_VIEW_PARAM service, |
| boost::system::error_code& ec) |
| { |
| return resolve(protocol, host, service, resolver_base::flags(), ec); |
| } |
| |
| /// Perform forward resolution of a query to a list of entries. |
| /** |
| * This function is used to resolve host and service names into a list of |
| * endpoint entries. |
| * |
| * @param protocol A protocol object, normally representing either the IPv4 or |
| * IPv6 version of an internet protocol. |
| * |
| * @param host A string identifying a location. May be a descriptive name or |
| * a numeric address string. If an empty string and the passive flag has been |
| * specified, the resolved endpoints are suitable for local service binding. |
| * If an empty string and passive is not specified, the resolved endpoints |
| * will use the loopback address. |
| * |
| * @param service A string identifying the requested service. This may be a |
| * descriptive name or a numeric string corresponding to a port number. May |
| * be an empty string, in which case all resolved endpoints will have a port |
| * number of 0. |
| * |
| * @param resolve_flags A set of flags that determine how name resolution |
| * should be performed. The default flags are suitable for communication with |
| * remote hosts. See the @ref resolver_base documentation for the set of |
| * available flags. |
| * |
| * @returns A range object representing the list of endpoint entries. A |
| * successful call to this function is guaranteed to return a non-empty |
| * range. |
| * |
| * @throws boost::system::system_error Thrown on failure. |
| * |
| * @note On POSIX systems, host names may be locally defined in the file |
| * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name |
| * resolution is performed using DNS. Operating systems may use additional |
| * locations when resolving host names (such as NETBIOS names on Windows). |
| * |
| * On POSIX systems, service names are typically defined in the file |
| * <tt>/etc/services</tt>. On Windows, service names may be found in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems |
| * may use additional locations when resolving service names. |
| */ |
| results_type resolve(const protocol_type& protocol, |
| BOOST_ASIO_STRING_VIEW_PARAM host, BOOST_ASIO_STRING_VIEW_PARAM service, |
| resolver_base::flags resolve_flags) |
| { |
| boost::system::error_code ec; |
| basic_resolver_query<protocol_type> q( |
| protocol, static_cast<std::string>(host), |
| static_cast<std::string>(service), resolve_flags); |
| results_type r = impl_.get_service().resolve( |
| impl_.get_implementation(), q, ec); |
| boost::asio::detail::throw_error(ec, "resolve"); |
| return r; |
| } |
| |
| /// Perform forward resolution of a query to a list of entries. |
| /** |
| * This function is used to resolve host and service names into a list of |
| * endpoint entries. |
| * |
| * @param protocol A protocol object, normally representing either the IPv4 or |
| * IPv6 version of an internet protocol. |
| * |
| * @param host A string identifying a location. May be a descriptive name or |
| * a numeric address string. If an empty string and the passive flag has been |
| * specified, the resolved endpoints are suitable for local service binding. |
| * If an empty string and passive is not specified, the resolved endpoints |
| * will use the loopback address. |
| * |
| * @param service A string identifying the requested service. This may be a |
| * descriptive name or a numeric string corresponding to a port number. May |
| * be an empty string, in which case all resolved endpoints will have a port |
| * number of 0. |
| * |
| * @param resolve_flags A set of flags that determine how name resolution |
| * should be performed. The default flags are suitable for communication with |
| * remote hosts. See the @ref resolver_base documentation for the set of |
| * available flags. |
| * |
| * @param ec Set to indicate what error occurred, if any. |
| * |
| * @returns A range object representing the list of endpoint entries. An |
| * empty range is returned if an error occurs. A successful call to this |
| * function is guaranteed to return a non-empty range. |
| * |
| * @note On POSIX systems, host names may be locally defined in the file |
| * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name |
| * resolution is performed using DNS. Operating systems may use additional |
| * locations when resolving host names (such as NETBIOS names on Windows). |
| * |
| * On POSIX systems, service names are typically defined in the file |
| * <tt>/etc/services</tt>. On Windows, service names may be found in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems |
| * may use additional locations when resolving service names. |
| */ |
| results_type resolve(const protocol_type& protocol, |
| BOOST_ASIO_STRING_VIEW_PARAM host, BOOST_ASIO_STRING_VIEW_PARAM service, |
| resolver_base::flags resolve_flags, boost::system::error_code& ec) |
| { |
| basic_resolver_query<protocol_type> q( |
| protocol, static_cast<std::string>(host), |
| static_cast<std::string>(service), resolve_flags); |
| return impl_.get_service().resolve(impl_.get_implementation(), q, ec); |
| } |
| |
| #if !defined(BOOST_ASIO_NO_DEPRECATED) |
| /// (Deprecated: Use overload with separate host and service parameters.) |
| /// Asynchronously perform forward resolution of a query to a list of entries. |
| /** |
| * This function is used to asynchronously resolve a query into a list of |
| * endpoint entries. |
| * |
| * @param q A query object that determines what endpoints will be returned. |
| * |
| * @param handler The handler to be called when the resolve operation |
| * completes. Copies will be made of the handler as required. The function |
| * signature of the handler must be: |
| * @code void handler( |
| * const boost::system::error_code& error, // Result of operation. |
| * resolver::results_type results // Resolved endpoints as a range. |
| * ); @endcode |
| * Regardless of whether the asynchronous operation completes immediately or |
| * not, the handler will not be invoked from within this function. On |
| * immediate completion, invocation of the handler will be performed in a |
| * manner equivalent to using boost::asio::post(). |
| * |
| * A successful resolve operation is guaranteed to pass a non-empty range to |
| * the handler. |
| */ |
| template < |
| BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code, |
| results_type)) ResolveHandler |
| BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)> |
| BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler, |
| void (boost::system::error_code, results_type)) |
| async_resolve(const query& q, |
| BOOST_ASIO_MOVE_ARG(ResolveHandler) handler |
| BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type)) |
| { |
| return boost::asio::async_initiate<ResolveHandler, |
| void (boost::system::error_code, results_type)>( |
| initiate_async_resolve(this), handler, q); |
| } |
| #endif // !defined(BOOST_ASIO_NO_DEPRECATED) |
| |
| /// Asynchronously perform forward resolution of a query to a list of entries. |
| /** |
| * This function is used to resolve host and service names into a list of |
| * endpoint entries. |
| * |
| * @param host A string identifying a location. May be a descriptive name or |
| * a numeric address string. If an empty string and the passive flag has been |
| * specified, the resolved endpoints are suitable for local service binding. |
| * If an empty string and passive is not specified, the resolved endpoints |
| * will use the loopback address. |
| * |
| * @param service A string identifying the requested service. This may be a |
| * descriptive name or a numeric string corresponding to a port number. May |
| * be an empty string, in which case all resolved endpoints will have a port |
| * number of 0. |
| * |
| * @param handler The handler to be called when the resolve operation |
| * completes. Copies will be made of the handler as required. The function |
| * signature of the handler must be: |
| * @code void handler( |
| * const boost::system::error_code& error, // Result of operation. |
| * resolver::results_type results // Resolved endpoints as a range. |
| * ); @endcode |
| * Regardless of whether the asynchronous operation completes immediately or |
| * not, the handler will not be invoked from within this function. On |
| * immediate completion, invocation of the handler will be performed in a |
| * manner equivalent to using boost::asio::post(). |
| * |
| * A successful resolve operation is guaranteed to pass a non-empty range to |
| * the handler. |
| * |
| * @note On POSIX systems, host names may be locally defined in the file |
| * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name |
| * resolution is performed using DNS. Operating systems may use additional |
| * locations when resolving host names (such as NETBIOS names on Windows). |
| * |
| * On POSIX systems, service names are typically defined in the file |
| * <tt>/etc/services</tt>. On Windows, service names may be found in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems |
| * may use additional locations when resolving service names. |
| */ |
| template < |
| BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code, |
| results_type)) ResolveHandler |
| BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)> |
| BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler, |
| void (boost::system::error_code, results_type)) |
| async_resolve(BOOST_ASIO_STRING_VIEW_PARAM host, |
| BOOST_ASIO_STRING_VIEW_PARAM service, |
| BOOST_ASIO_MOVE_ARG(ResolveHandler) handler |
| BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type)) |
| { |
| return async_resolve(host, service, resolver_base::flags(), |
| BOOST_ASIO_MOVE_CAST(ResolveHandler)(handler)); |
| } |
| |
| /// Asynchronously perform forward resolution of a query to a list of entries. |
| /** |
| * This function is used to resolve host and service names into a list of |
| * endpoint entries. |
| * |
| * @param host A string identifying a location. May be a descriptive name or |
| * a numeric address string. If an empty string and the passive flag has been |
| * specified, the resolved endpoints are suitable for local service binding. |
| * If an empty string and passive is not specified, the resolved endpoints |
| * will use the loopback address. |
| * |
| * @param service A string identifying the requested service. This may be a |
| * descriptive name or a numeric string corresponding to a port number. May |
| * be an empty string, in which case all resolved endpoints will have a port |
| * number of 0. |
| * |
| * @param resolve_flags A set of flags that determine how name resolution |
| * should be performed. The default flags are suitable for communication with |
| * remote hosts. See the @ref resolver_base documentation for the set of |
| * available flags. |
| * |
| * @param handler The handler to be called when the resolve operation |
| * completes. Copies will be made of the handler as required. The function |
| * signature of the handler must be: |
| * @code void handler( |
| * const boost::system::error_code& error, // Result of operation. |
| * resolver::results_type results // Resolved endpoints as a range. |
| * ); @endcode |
| * Regardless of whether the asynchronous operation completes immediately or |
| * not, the handler will not be invoked from within this function. On |
| * immediate completion, invocation of the handler will be performed in a |
| * manner equivalent to using boost::asio::post(). |
| * |
| * A successful resolve operation is guaranteed to pass a non-empty range to |
| * the handler. |
| * |
| * @note On POSIX systems, host names may be locally defined in the file |
| * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name |
| * resolution is performed using DNS. Operating systems may use additional |
| * locations when resolving host names (such as NETBIOS names on Windows). |
| * |
| * On POSIX systems, service names are typically defined in the file |
| * <tt>/etc/services</tt>. On Windows, service names may be found in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems |
| * may use additional locations when resolving service names. |
| */ |
| template < |
| BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code, |
| results_type)) ResolveHandler |
| BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)> |
| BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler, |
| void (boost::system::error_code, results_type)) |
| async_resolve(BOOST_ASIO_STRING_VIEW_PARAM host, |
| BOOST_ASIO_STRING_VIEW_PARAM service, |
| resolver_base::flags resolve_flags, |
| BOOST_ASIO_MOVE_ARG(ResolveHandler) handler |
| BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type)) |
| { |
| basic_resolver_query<protocol_type> q(static_cast<std::string>(host), |
| static_cast<std::string>(service), resolve_flags); |
| |
| return boost::asio::async_initiate<ResolveHandler, |
| void (boost::system::error_code, results_type)>( |
| initiate_async_resolve(this), handler, q); |
| } |
| |
| /// Asynchronously perform forward resolution of a query to a list of entries. |
| /** |
| * This function is used to resolve host and service names into a list of |
| * endpoint entries. |
| * |
| * @param protocol A protocol object, normally representing either the IPv4 or |
| * IPv6 version of an internet protocol. |
| * |
| * @param host A string identifying a location. May be a descriptive name or |
| * a numeric address string. If an empty string and the passive flag has been |
| * specified, the resolved endpoints are suitable for local service binding. |
| * If an empty string and passive is not specified, the resolved endpoints |
| * will use the loopback address. |
| * |
| * @param service A string identifying the requested service. This may be a |
| * descriptive name or a numeric string corresponding to a port number. May |
| * be an empty string, in which case all resolved endpoints will have a port |
| * number of 0. |
| * |
| * @param handler The handler to be called when the resolve operation |
| * completes. Copies will be made of the handler as required. The function |
| * signature of the handler must be: |
| * @code void handler( |
| * const boost::system::error_code& error, // Result of operation. |
| * resolver::results_type results // Resolved endpoints as a range. |
| * ); @endcode |
| * Regardless of whether the asynchronous operation completes immediately or |
| * not, the handler will not be invoked from within this function. On |
| * immediate completion, invocation of the handler will be performed in a |
| * manner equivalent to using boost::asio::post(). |
| * |
| * A successful resolve operation is guaranteed to pass a non-empty range to |
| * the handler. |
| * |
| * @note On POSIX systems, host names may be locally defined in the file |
| * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name |
| * resolution is performed using DNS. Operating systems may use additional |
| * locations when resolving host names (such as NETBIOS names on Windows). |
| * |
| * On POSIX systems, service names are typically defined in the file |
| * <tt>/etc/services</tt>. On Windows, service names may be found in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems |
| * may use additional locations when resolving service names. |
| */ |
| template < |
| BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code, |
| results_type)) ResolveHandler |
| BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)> |
| BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler, |
| void (boost::system::error_code, results_type)) |
| async_resolve(const protocol_type& protocol, |
| BOOST_ASIO_STRING_VIEW_PARAM host, BOOST_ASIO_STRING_VIEW_PARAM service, |
| BOOST_ASIO_MOVE_ARG(ResolveHandler) handler |
| BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type)) |
| { |
| return async_resolve(protocol, host, service, resolver_base::flags(), |
| BOOST_ASIO_MOVE_CAST(ResolveHandler)(handler)); |
| } |
| |
| /// Asynchronously perform forward resolution of a query to a list of entries. |
| /** |
| * This function is used to resolve host and service names into a list of |
| * endpoint entries. |
| * |
| * @param protocol A protocol object, normally representing either the IPv4 or |
| * IPv6 version of an internet protocol. |
| * |
| * @param host A string identifying a location. May be a descriptive name or |
| * a numeric address string. If an empty string and the passive flag has been |
| * specified, the resolved endpoints are suitable for local service binding. |
| * If an empty string and passive is not specified, the resolved endpoints |
| * will use the loopback address. |
| * |
| * @param service A string identifying the requested service. This may be a |
| * descriptive name or a numeric string corresponding to a port number. May |
| * be an empty string, in which case all resolved endpoints will have a port |
| * number of 0. |
| * |
| * @param resolve_flags A set of flags that determine how name resolution |
| * should be performed. The default flags are suitable for communication with |
| * remote hosts. See the @ref resolver_base documentation for the set of |
| * available flags. |
| * |
| * @param handler The handler to be called when the resolve operation |
| * completes. Copies will be made of the handler as required. The function |
| * signature of the handler must be: |
| * @code void handler( |
| * const boost::system::error_code& error, // Result of operation. |
| * resolver::results_type results // Resolved endpoints as a range. |
| * ); @endcode |
| * Regardless of whether the asynchronous operation completes immediately or |
| * not, the handler will not be invoked from within this function. On |
| * immediate completion, invocation of the handler will be performed in a |
| * manner equivalent to using boost::asio::post(). |
| * |
| * A successful resolve operation is guaranteed to pass a non-empty range to |
| * the handler. |
| * |
| * @note On POSIX systems, host names may be locally defined in the file |
| * <tt>/etc/hosts</tt>. On Windows, host names may be defined in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\hosts</tt>. Remote host name |
| * resolution is performed using DNS. Operating systems may use additional |
| * locations when resolving host names (such as NETBIOS names on Windows). |
| * |
| * On POSIX systems, service names are typically defined in the file |
| * <tt>/etc/services</tt>. On Windows, service names may be found in the file |
| * <tt>c:\\windows\\system32\\drivers\\etc\\services</tt>. Operating systems |
| * may use additional locations when resolving service names. |
| */ |
| template < |
| BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code, |
| results_type)) ResolveHandler |
| BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)> |
| BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler, |
| void (boost::system::error_code, results_type)) |
| async_resolve(const protocol_type& protocol, |
| BOOST_ASIO_STRING_VIEW_PARAM host, BOOST_ASIO_STRING_VIEW_PARAM service, |
| resolver_base::flags resolve_flags, |
| BOOST_ASIO_MOVE_ARG(ResolveHandler) handler |
| BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type)) |
| { |
| basic_resolver_query<protocol_type> q( |
| protocol, static_cast<std::string>(host), |
| static_cast<std::string>(service), resolve_flags); |
| |
| return boost::asio::async_initiate<ResolveHandler, |
| void (boost::system::error_code, results_type)>( |
| initiate_async_resolve(this), handler, q); |
| } |
| |
| /// Perform reverse resolution of an endpoint to a list of entries. |
| /** |
| * This function is used to resolve an endpoint into a list of endpoint |
| * entries. |
| * |
| * @param e An endpoint object that determines what endpoints will be |
| * returned. |
| * |
| * @returns A range object representing the list of endpoint entries. A |
| * successful call to this function is guaranteed to return a non-empty |
| * range. |
| * |
| * @throws boost::system::system_error Thrown on failure. |
| */ |
| results_type resolve(const endpoint_type& e) |
| { |
| boost::system::error_code ec; |
| results_type i = impl_.get_service().resolve( |
| impl_.get_implementation(), e, ec); |
| boost::asio::detail::throw_error(ec, "resolve"); |
| return i; |
| } |
| |
| /// Perform reverse resolution of an endpoint to a list of entries. |
| /** |
| * This function is used to resolve an endpoint into a list of endpoint |
| * entries. |
| * |
| * @param e An endpoint object that determines what endpoints will be |
| * returned. |
| * |
| * @param ec Set to indicate what error occurred, if any. |
| * |
| * @returns A range object representing the list of endpoint entries. An |
| * empty range is returned if an error occurs. A successful call to this |
| * function is guaranteed to return a non-empty range. |
| */ |
| results_type resolve(const endpoint_type& e, boost::system::error_code& ec) |
| { |
| return impl_.get_service().resolve(impl_.get_implementation(), e, ec); |
| } |
| |
| /// Asynchronously perform reverse resolution of an endpoint to a list of |
| /// entries. |
| /** |
| * This function is used to asynchronously resolve an endpoint into a list of |
| * endpoint entries. |
| * |
| * @param e An endpoint object that determines what endpoints will be |
| * returned. |
| * |
| * @param handler The handler to be called when the resolve operation |
| * completes. Copies will be made of the handler as required. The function |
| * signature of the handler must be: |
| * @code void handler( |
| * const boost::system::error_code& error, // Result of operation. |
| * resolver::results_type results // Resolved endpoints as a range. |
| * ); @endcode |
| * Regardless of whether the asynchronous operation completes immediately or |
| * not, the handler will not be invoked from within this function. On |
| * immediate completion, invocation of the handler will be performed in a |
| * manner equivalent to using boost::asio::post(). |
| * |
| * A successful resolve operation is guaranteed to pass a non-empty range to |
| * the handler. |
| */ |
| template < |
| BOOST_ASIO_COMPLETION_TOKEN_FOR(void (boost::system::error_code, |
| results_type)) ResolveHandler |
| BOOST_ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)> |
| BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler, |
| void (boost::system::error_code, results_type)) |
| async_resolve(const endpoint_type& e, |
| BOOST_ASIO_MOVE_ARG(ResolveHandler) handler |
| BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(executor_type)) |
| { |
| return boost::asio::async_initiate<ResolveHandler, |
| void (boost::system::error_code, results_type)>( |
| initiate_async_resolve(this), handler, e); |
| } |
| |
| private: |
| // Disallow copying and assignment. |
| basic_resolver(const basic_resolver&) BOOST_ASIO_DELETED; |
| basic_resolver& operator=(const basic_resolver&) BOOST_ASIO_DELETED; |
| |
| class initiate_async_resolve |
| { |
| public: |
| typedef Executor executor_type; |
| |
| explicit initiate_async_resolve(basic_resolver* self) |
| : self_(self) |
| { |
| } |
| |
| executor_type get_executor() const BOOST_ASIO_NOEXCEPT |
| { |
| return self_->get_executor(); |
| } |
| |
| template <typename ResolveHandler, typename Query> |
| void operator()(BOOST_ASIO_MOVE_ARG(ResolveHandler) handler, |
| const Query& q) const |
| { |
| // If you get an error on the following line it means that your handler |
| // does not meet the documented type requirements for a ResolveHandler. |
| BOOST_ASIO_RESOLVE_HANDLER_CHECK( |
| ResolveHandler, handler, results_type) type_check; |
| |
| boost::asio::detail::non_const_lvalue<ResolveHandler> handler2(handler); |
| self_->impl_.get_service().async_resolve( |
| self_->impl_.get_implementation(), q, |
| handler2.value, self_->impl_.get_executor()); |
| } |
| |
| private: |
| basic_resolver* self_; |
| }; |
| |
| # if defined(BOOST_ASIO_WINDOWS_RUNTIME) |
| boost::asio::detail::io_object_impl< |
| boost::asio::detail::winrt_resolver_service<InternetProtocol>, |
| Executor> impl_; |
| # else |
| boost::asio::detail::io_object_impl< |
| boost::asio::detail::resolver_service<InternetProtocol>, |
| Executor> impl_; |
| # endif |
| }; |
| |
| } // namespace ip |
| } // namespace asio |
| } // namespace boost |
| |
| #include <boost/asio/detail/pop_options.hpp> |
| |
| #endif // BOOST_ASIO_IP_BASIC_RESOLVER_HPP |