Add an async DNS resolver suitable for defaulting.

This should replace the wrapping async DNS resolver used
for default resolution.

Bug: webrtc:12598
Change-Id: Ic65ecd17da7a5695d0003178aeb30824a707ec78
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/316928
Reviewed-by: Tomas Gunnarsson <tommi@webrtc.org>
Commit-Queue: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#40607}

BUILD.gn

@@ -597,6 +597,7 @@ if (rtc_include_tests && !build_with_chromium) {
       "call:fake_network_pipe_unittests",
       "p2p:libstunprober_unittests",
       "p2p:rtc_p2p_unittests",
+      "rtc_base:async_dns_resolver_unittests",
       "rtc_base:callback_list_unittests",
       "rtc_base:rtc_base_approved_unittests",
       "rtc_base:rtc_base_unittests",

rtc_base/BUILD.gn

@@ -926,6 +926,32 @@ rtc_library("async_resolver_interface") {
   ]
 }
 
+rtc_library("async_dns_resolver") {
+  sources = [
+    "async_dns_resolver.cc",
+    "async_dns_resolver.h",
+  ]
+  deps = [
+    ":logging",
+    ":macromagic",
+    ":platform_thread",
+    "../api:async_dns_resolver",
+    "../api:sequence_checker",
+    "../api/task_queue:pending_task_safety_flag",
+  ]
+}
+
+rtc_library("async_dns_resolver_unittests") {
+  testonly = true
+  sources = [ "async_dns_resolver_unittest.cc" ]
+  deps = [
+    ":async_dns_resolver",
+    ":gunit_helpers",
+    "../test:run_loop",
+    "../test:test_support",
+  ]
+}
+
 rtc_library("ip_address") {
   visibility = [ "*" ]
   sources = [

rtc_base/async_dns_resolver.cc

@@ -0,0 +1,162 @@
+/*
+ *  Copyright 2023 The WebRTC Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "rtc_base/async_dns_resolver.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "rtc_base/logging.h"
+#include "rtc_base/platform_thread.h"
+
+#if defined(WEBRTC_MAC) || defined(WEBRTC_IOS)
+#include <dispatch/dispatch.h>
+#endif
+
+namespace webrtc {
+
+namespace {
+
+#ifdef __native_client__
+int ResolveHostname(absl::string_view hostname,
+                    int family,
+                    std::vector<rtc::IPAddress>* addresses) {
+  RTC_DCHECK_NOTREACHED();
+  RTC_LOG(LS_WARNING) << "ResolveHostname() is not implemented for NaCl";
+  return -1;
+}
+#else   // notdef(__native_client__)
+int ResolveHostname(absl::string_view hostname,
+                    int family,
+                    std::vector<rtc::IPAddress>& addresses) {
+  addresses.clear();
+  struct addrinfo* result = nullptr;
+  struct addrinfo hints = {0};
+  hints.ai_family = family;
+  // `family` here will almost always be AF_UNSPEC, because `family` comes from
+  // AsyncResolver::addr_.family(), which comes from a SocketAddress constructed
+  // with a hostname. When a SocketAddress is constructed with a hostname, its
+  // family is AF_UNSPEC. However, if someday in the future we construct
+  // a SocketAddress with both a hostname and a family other than AF_UNSPEC,
+  // then it would be possible to get a specific family value here.
+
+  // The behavior of AF_UNSPEC is roughly "get both ipv4 and ipv6", as
+  // documented by the various operating systems:
+  // Linux: http://man7.org/linux/man-pages/man3/getaddrinfo.3.html
+  // Windows: https://msdn.microsoft.com/en-us/library/windows/desktop/
+  // ms738520(v=vs.85).aspx
+  // Mac: https://developer.apple.com/legacy/library/documentation/Darwin/
+  // Reference/ManPages/man3/getaddrinfo.3.html
+  // Android (source code, not documentation):
+  // https://android.googlesource.com/platform/bionic/+/
+  // 7e0bfb511e85834d7c6cb9631206b62f82701d60/libc/netbsd/net/getaddrinfo.c#1657
+  hints.ai_flags = AI_ADDRCONFIG;
+  int ret =
+      getaddrinfo(std::string(hostname).c_str(), nullptr, &hints, &result);
+  if (ret != 0) {
+    return ret;
+  }
+  struct addrinfo* cursor = result;
+  for (; cursor; cursor = cursor->ai_next) {
+    if (family == AF_UNSPEC || cursor->ai_family == family) {
+      rtc::IPAddress ip;
+      if (IPFromAddrInfo(cursor, &ip)) {
+        addresses.push_back(ip);
+      }
+    }
+  }
+  freeaddrinfo(result);
+  return 0;
+}
+#endif  // !__native_client__
+
+// Special task posting for Mac/iOS
+#if defined(WEBRTC_MAC) || defined(WEBRTC_IOS)
+void GlobalGcdRunTask(void* context) {
+  std::unique_ptr<absl::AnyInvocable<void() &&>> task(
+      static_cast<absl::AnyInvocable<void() &&>*>(context));
+  std::move (*task)();
+}
+
+// Post a task into the system-defined global concurrent queue.
+void PostTaskToGlobalQueue(
+    std::unique_ptr<absl::AnyInvocable<void() &&>> task) {
+  dispatch_async_f(
+      dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0),
+      task.release(), &GlobalGcdRunTask);
+}
+#endif  // defined(WEBRTC_MAC) || defined(WEBRTC_IOS)
+
+}  // namespace
+
+void AsyncDnsResolver::Start(const rtc::SocketAddress& addr,
+                             std::function<void()> callback) {
+  Start(addr, addr.family(), std::move(callback));
+}
+
+// Start address resolution of the hostname in `addr` matching `family`.
+void AsyncDnsResolver::Start(const rtc::SocketAddress& addr,
+                             int family,
+                             std::function<void()> callback) {
+  RTC_DCHECK_RUN_ON(&result_.sequence_checker_);
+  result_.addr_ = addr;
+  auto thread_function = [this, addr, family,
+                          caller_task_queue = webrtc::TaskQueueBase::Current(),
+                          callback = std::move(callback)] {
+    std::vector<rtc::IPAddress> addresses;
+    int error = ResolveHostname(addr.hostname(), family, addresses);
+    caller_task_queue->PostTask(
+        SafeTask(safety_.flag(), [this, error, addresses = std::move(addresses),
+                                  callback = std::move(callback)] {
+          RTC_DCHECK_RUN_ON(&result_.sequence_checker_);
+          result_.addresses_ = addresses;
+          result_.error_ = error;
+          callback();
+        }));
+  };
+#if defined(WEBRTC_MAC) || defined(WEBRTC_IOS)
+  PostTaskToGlobalQueue(
+      std::make_unique<absl::AnyInvocable<void() &&>>(thread_function));
+#else
+  rtc::PlatformThread::SpawnDetached(std::move(thread_function),
+                                     "AsyncResolver");
+#endif
+}
+
+const AsyncDnsResolverResult& AsyncDnsResolver::result() const {
+  return result_;
+}
+
+bool AsyncDnsResolverResultImpl::GetResolvedAddress(
+    int family,
+    rtc::SocketAddress* addr) const {
+  RTC_DCHECK_RUN_ON(&sequence_checker_);
+  RTC_DCHECK(addr);
+  if (error_ != 0 || addresses_.empty())
+    return false;
+
+  *addr = addr_;
+  for (const auto& address : addresses_) {
+    if (family == address.family()) {
+      addr->SetResolvedIP(address);
+      return true;
+    }
+  }
+  return false;
+}
+
+int AsyncDnsResolverResultImpl::GetError() const {
+  RTC_DCHECK_RUN_ON(&sequence_checker_);
+  return error_;
+}
+
+}  // namespace webrtc

rtc_base/async_dns_resolver.h

@@ -0,0 +1,56 @@
+/*
+ *  Copyright 2023 The WebRTC Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+#ifndef RTC_BASE_ASYNC_DNS_RESOLVER_H_
+#define RTC_BASE_ASYNC_DNS_RESOLVER_H_
+
+#include <vector>
+
+#include "api/async_dns_resolver.h"
+#include "api/sequence_checker.h"
+#include "api/task_queue/pending_task_safety_flag.h"
+#include "rtc_base/thread_annotations.h"
+
+namespace webrtc {
+// This file contains a default implementation of
+// webrtc::AsyncDnsResolverInterface, for use when there is no need for special
+// treatment.
+
+class AsyncDnsResolverResultImpl : public AsyncDnsResolverResult {
+ public:
+  bool GetResolvedAddress(int family, rtc::SocketAddress* addr) const override;
+  // Returns error from resolver.
+  int GetError() const override;
+
+ private:
+  friend class AsyncDnsResolver;
+  RTC_NO_UNIQUE_ADDRESS webrtc::SequenceChecker sequence_checker_;
+  rtc::SocketAddress addr_ RTC_GUARDED_BY(sequence_checker_);
+  std::vector<rtc::IPAddress> addresses_ RTC_GUARDED_BY(sequence_checker_);
+  int error_ RTC_GUARDED_BY(sequence_checker_);
+};
+
+class AsyncDnsResolver : public AsyncDnsResolverInterface {
+ public:
+  // Start address resolution of the hostname in `addr`.
+  void Start(const rtc::SocketAddress& addr,
+             std::function<void()> callback) override;
+  // Start address resolution of the hostname in `addr` matching `family`.
+  void Start(const rtc::SocketAddress& addr,
+             int family,
+             std::function<void()> callback) override;
+  const AsyncDnsResolverResult& result() const override;
+
+ private:
+  ScopedTaskSafety safety_;
+  AsyncDnsResolverResultImpl result_;
+};
+
+}  // namespace webrtc
+#endif  // RTC_BASE_ASYNC_DNS_RESOLVER_H_

rtc_base/async_dns_resolver_unittest.cc

@@ -0,0 +1,41 @@
+/*
+ *  Copyright 2023 The WebRTC Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "rtc_base/async_dns_resolver.h"
+
+#include "rtc_base/gunit.h"
+#include "test/gtest.h"
+#include "test/run_loop.h"
+
+namespace webrtc {
+namespace {
+const int kDefaultTimeout = 1000;
+const int kPortNumber = 3027;
+
+TEST(AsyncDnsResolver, ConstructorWorks) {
+  AsyncDnsResolver resolver;
+}
+
+TEST(AsyncDnsResolver, ResolvingLocalhostWorks) {
+  test::RunLoop loop;  // Ensure that posting back to main thread works
+  AsyncDnsResolver resolver;
+  rtc::SocketAddress address("localhost",
+                             kPortNumber);  // Port number does not matter
+  rtc::SocketAddress resolved_address;
+  bool done = false;
+  resolver.Start(address, [&done] { done = true; });
+  ASSERT_TRUE_WAIT(done, kDefaultTimeout);
+  EXPECT_EQ(resolver.result().GetError(), 0);
+  EXPECT_TRUE(resolver.result().GetResolvedAddress(AF_INET, &resolved_address));
+  EXPECT_EQ(resolved_address, rtc::SocketAddress("127.0.0.1", kPortNumber));
+}
+
+}  // namespace
+}  // namespace webrtc