diff --git a/BUILD.gn b/BUILD.gn index 661e36f16a..4558737a0a 100644 --- a/BUILD.gn +++ b/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", diff --git a/rtc_base/BUILD.gn b/rtc_base/BUILD.gn index f3810fdd36..c45b580711 100644 --- a/rtc_base/BUILD.gn +++ b/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 = [ diff --git a/rtc_base/async_dns_resolver.cc b/rtc_base/async_dns_resolver.cc new file mode 100644 index 0000000000..3f6381087b --- /dev/null +++ b/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 +#include +#include +#include + +#include "rtc_base/logging.h" +#include "rtc_base/platform_thread.h" + +#if defined(WEBRTC_MAC) || defined(WEBRTC_IOS) +#include +#endif + +namespace webrtc { + +namespace { + +#ifdef __native_client__ +int ResolveHostname(absl::string_view hostname, + int family, + std::vector* 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& 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> task( + static_cast*>(context)); + std::move (*task)(); +} + +// Post a task into the system-defined global concurrent queue. +void PostTaskToGlobalQueue( + std::unique_ptr> 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 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 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 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>(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 diff --git a/rtc_base/async_dns_resolver.h b/rtc_base/async_dns_resolver.h new file mode 100644 index 0000000000..75112459b2 --- /dev/null +++ b/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 + +#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 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 callback) override; + // Start address resolution of the hostname in `addr` matching `family`. + void Start(const rtc::SocketAddress& addr, + int family, + std::function callback) override; + const AsyncDnsResolverResult& result() const override; + + private: + ScopedTaskSafety safety_; + AsyncDnsResolverResultImpl result_; +}; + +} // namespace webrtc +#endif // RTC_BASE_ASYNC_DNS_RESOLVER_H_ diff --git a/rtc_base/async_dns_resolver_unittest.cc b/rtc_base/async_dns_resolver_unittest.cc new file mode 100644 index 0000000000..3cfb7f8f0b --- /dev/null +++ b/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