summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/asio/include/asio/ip/basic_resolver.hpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/asio/include/asio/ip/basic_resolver.hpp')
-rw-r--r--3rdparty/asio/include/asio/ip/basic_resolver.hpp1076
1 files changed, 1076 insertions, 0 deletions
diff --git a/3rdparty/asio/include/asio/ip/basic_resolver.hpp b/3rdparty/asio/include/asio/ip/basic_resolver.hpp
new file mode 100644
index 00000000000..cfadba4af9d
--- /dev/null
+++ b/3rdparty/asio/include/asio/ip/basic_resolver.hpp
@@ -0,0 +1,1076 @@
+//
+// 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 ASIO_IP_BASIC_RESOLVER_HPP
+#define ASIO_IP_BASIC_RESOLVER_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+#include <string>
+#include "asio/any_io_executor.hpp"
+#include "asio/async_result.hpp"
+#include "asio/detail/handler_type_requirements.hpp"
+#include "asio/detail/io_object_impl.hpp"
+#include "asio/detail/non_const_lvalue.hpp"
+#include "asio/detail/string_view.hpp"
+#include "asio/detail/throw_error.hpp"
+#include "asio/error.hpp"
+#include "asio/execution_context.hpp"
+#include "asio/ip/basic_resolver_iterator.hpp"
+#include "asio/ip/basic_resolver_query.hpp"
+#include "asio/ip/basic_resolver_results.hpp"
+#include "asio/ip/resolver_base.hpp"
+#if defined(ASIO_WINDOWS_RUNTIME)
+# include "asio/detail/winrt_resolver_service.hpp"
+#else
+# include "asio/detail/resolver_service.hpp"
+#endif
+
+#if defined(ASIO_HAS_MOVE)
+# include <utility>
+#endif // defined(ASIO_HAS_MOVE)
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+namespace ip {
+
+#if !defined(ASIO_IP_BASIC_RESOLVER_FWD_DECL)
+#define ASIO_IP_BASIC_RESOLVER_FWD_DECL
+
+// Forward declaration with defaulted arguments.
+template <typename InternetProtocol, typename Executor = any_io_executor>
+class basic_resolver;
+
+#endif // !defined(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(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(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(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(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() 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 asio::error::operation_aborted error code.
+ */
+ void cancel()
+ {
+ return impl_.get_service().cancel(impl_.get_implementation());
+ }
+
+#if !defined(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 asio::system_error Thrown on failure.
+ */
+ results_type resolve(const query& q)
+ {
+ asio::error_code ec;
+ results_type r = impl_.get_service().resolve(
+ impl_.get_implementation(), q, ec);
+ 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, asio::error_code& ec)
+ {
+ return impl_.get_service().resolve(impl_.get_implementation(), q, ec);
+ }
+#endif // !defined(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 asio::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(ASIO_STRING_VIEW_PARAM host,
+ 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(ASIO_STRING_VIEW_PARAM host,
+ ASIO_STRING_VIEW_PARAM service, asio::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 asio::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(ASIO_STRING_VIEW_PARAM host,
+ ASIO_STRING_VIEW_PARAM service, resolver_base::flags resolve_flags)
+ {
+ asio::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);
+ 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(ASIO_STRING_VIEW_PARAM host,
+ ASIO_STRING_VIEW_PARAM service, resolver_base::flags resolve_flags,
+ asio::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 asio::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,
+ ASIO_STRING_VIEW_PARAM host, 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,
+ ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service,
+ asio::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 asio::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,
+ ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service,
+ resolver_base::flags resolve_flags)
+ {
+ asio::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);
+ 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,
+ ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service,
+ resolver_base::flags resolve_flags, asio::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(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 asio::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 asio::post().
+ *
+ * A successful resolve operation is guaranteed to pass a non-empty range to
+ * the handler.
+ */
+ template <
+ ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
+ results_type)) ResolveHandler
+ ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+ ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler,
+ void (asio::error_code, results_type))
+ async_resolve(const query& q,
+ ASIO_MOVE_ARG(ResolveHandler) handler
+ ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+ {
+ return asio::async_initiate<ResolveHandler,
+ void (asio::error_code, results_type)>(
+ initiate_async_resolve(this), handler, q);
+ }
+#endif // !defined(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 asio::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 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 <
+ ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
+ results_type)) ResolveHandler
+ ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+ ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler,
+ void (asio::error_code, results_type))
+ async_resolve(ASIO_STRING_VIEW_PARAM host,
+ ASIO_STRING_VIEW_PARAM service,
+ ASIO_MOVE_ARG(ResolveHandler) handler
+ ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+ {
+ return async_resolve(host, service, resolver_base::flags(),
+ 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 asio::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 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 <
+ ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
+ results_type)) ResolveHandler
+ ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+ ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler,
+ void (asio::error_code, results_type))
+ async_resolve(ASIO_STRING_VIEW_PARAM host,
+ ASIO_STRING_VIEW_PARAM service,
+ resolver_base::flags resolve_flags,
+ ASIO_MOVE_ARG(ResolveHandler) handler
+ 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 asio::async_initiate<ResolveHandler,
+ void (asio::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 asio::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 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 <
+ ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
+ results_type)) ResolveHandler
+ ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+ ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler,
+ void (asio::error_code, results_type))
+ async_resolve(const protocol_type& protocol,
+ ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service,
+ ASIO_MOVE_ARG(ResolveHandler) handler
+ ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+ {
+ return async_resolve(protocol, host, service, resolver_base::flags(),
+ 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 asio::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 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 <
+ ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
+ results_type)) ResolveHandler
+ ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+ ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler,
+ void (asio::error_code, results_type))
+ async_resolve(const protocol_type& protocol,
+ ASIO_STRING_VIEW_PARAM host, ASIO_STRING_VIEW_PARAM service,
+ resolver_base::flags resolve_flags,
+ ASIO_MOVE_ARG(ResolveHandler) handler
+ 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 asio::async_initiate<ResolveHandler,
+ void (asio::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 asio::system_error Thrown on failure.
+ */
+ results_type resolve(const endpoint_type& e)
+ {
+ asio::error_code ec;
+ results_type i = impl_.get_service().resolve(
+ impl_.get_implementation(), e, ec);
+ 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, asio::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 asio::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 asio::post().
+ *
+ * A successful resolve operation is guaranteed to pass a non-empty range to
+ * the handler.
+ */
+ template <
+ ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
+ results_type)) ResolveHandler
+ ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
+ ASIO_INITFN_AUTO_RESULT_TYPE(ResolveHandler,
+ void (asio::error_code, results_type))
+ async_resolve(const endpoint_type& e,
+ ASIO_MOVE_ARG(ResolveHandler) handler
+ ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
+ {
+ return asio::async_initiate<ResolveHandler,
+ void (asio::error_code, results_type)>(
+ initiate_async_resolve(this), handler, e);
+ }
+
+private:
+ // Disallow copying and assignment.
+ basic_resolver(const basic_resolver&) ASIO_DELETED;
+ basic_resolver& operator=(const basic_resolver&) 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 ASIO_NOEXCEPT
+ {
+ return self_->get_executor();
+ }
+
+ template <typename ResolveHandler, typename Query>
+ void operator()(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.
+ ASIO_RESOLVE_HANDLER_CHECK(
+ ResolveHandler, handler, results_type) type_check;
+
+ 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(ASIO_WINDOWS_RUNTIME)
+ asio::detail::io_object_impl<
+ asio::detail::winrt_resolver_service<InternetProtocol>,
+ Executor> impl_;
+# else
+ asio::detail::io_object_impl<
+ asio::detail::resolver_service<InternetProtocol>,
+ Executor> impl_;
+# endif
+};
+
+} // namespace ip
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_IP_BASIC_RESOLVER_HPP