Zach Stein | e20867f | 2018-08-02 20:20:15 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2018 The WebRTC Project Authors. All rights reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
Steve Anton | 10542f2 | 2019-01-11 17:11:00 | [diff] [blame] | 11 | #include "p2p/base/basic_async_resolver_factory.h" |
Zach Stein | e20867f | 2018-08-02 20:20:15 | [diff] [blame] | 12 | |
Harald Alvestrand | e6e2f28 | 2021-03-24 12:13:28 | [diff] [blame] | 13 | #include <memory> |
| 14 | #include <utility> |
| 15 | |
| 16 | #include "absl/memory/memory.h" |
| 17 | #include "api/async_dns_resolver.h" |
Mirko Bonadei | e5f4c6b | 2021-01-15 09:41:01 | [diff] [blame] | 18 | #include "rtc_base/async_resolver.h" |
Harald Alvestrand | 0ccfbd2 | 2021-04-08 07:25:04 | [diff] [blame] | 19 | #include "rtc_base/logging.h" |
Zach Stein | e20867f | 2018-08-02 20:20:15 | [diff] [blame] | 20 | |
| 21 | namespace webrtc { |
| 22 | |
| 23 | rtc::AsyncResolverInterface* BasicAsyncResolverFactory::Create() { |
| 24 | return new rtc::AsyncResolver(); |
| 25 | } |
| 26 | |
Harald Alvestrand | e6e2f28 | 2021-03-24 12:13:28 | [diff] [blame] | 27 | class WrappingAsyncDnsResolver; |
| 28 | |
| 29 | class WrappingAsyncDnsResolverResult : public AsyncDnsResolverResult { |
| 30 | public: |
| 31 | explicit WrappingAsyncDnsResolverResult(WrappingAsyncDnsResolver* owner) |
| 32 | : owner_(owner) {} |
| 33 | ~WrappingAsyncDnsResolverResult() {} |
| 34 | |
| 35 | // Note: Inline declaration not possible, since it refers to |
| 36 | // WrappingAsyncDnsResolver. |
| 37 | bool GetResolvedAddress(int family, rtc::SocketAddress* addr) const override; |
| 38 | int GetError() const override; |
| 39 | |
| 40 | private: |
| 41 | WrappingAsyncDnsResolver* const owner_; |
| 42 | }; |
| 43 | |
| 44 | class WrappingAsyncDnsResolver : public AsyncDnsResolverInterface, |
| 45 | public sigslot::has_slots<> { |
| 46 | public: |
| 47 | explicit WrappingAsyncDnsResolver(rtc::AsyncResolverInterface* wrapped) |
| 48 | : wrapped_(absl::WrapUnique(wrapped)), result_(this) {} |
| 49 | |
Harald Alvestrand | 0ccfbd2 | 2021-04-08 07:25:04 | [diff] [blame] | 50 | ~WrappingAsyncDnsResolver() override { |
| 51 | // Workaround to get around the fact that sigslot-using objects can't be |
| 52 | // destroyed from within their callback: Alert class users early. |
| 53 | // TODO(bugs.webrtc.org/12651): Delete this class once the sigslot users are |
| 54 | // gone. |
| 55 | RTC_CHECK(!within_resolve_result_); |
| 56 | wrapped_.release()->Destroy(false); |
| 57 | } |
Harald Alvestrand | e6e2f28 | 2021-03-24 12:13:28 | [diff] [blame] | 58 | |
| 59 | void Start(const rtc::SocketAddress& addr, |
| 60 | std::function<void()> callback) override { |
Harald Alvestrand | 0ccfbd2 | 2021-04-08 07:25:04 | [diff] [blame] | 61 | RTC_DCHECK_RUN_ON(&sequence_checker_); |
| 62 | RTC_DCHECK_EQ(State::kNotStarted, state_); |
Harald Alvestrand | e6e2f28 | 2021-03-24 12:13:28 | [diff] [blame] | 63 | state_ = State::kStarted; |
| 64 | callback_ = callback; |
| 65 | wrapped_->SignalDone.connect(this, |
| 66 | &WrappingAsyncDnsResolver::OnResolveResult); |
| 67 | wrapped_->Start(addr); |
| 68 | } |
| 69 | |
| 70 | const AsyncDnsResolverResult& result() const override { |
Harald Alvestrand | 0ccfbd2 | 2021-04-08 07:25:04 | [diff] [blame] | 71 | RTC_DCHECK_RUN_ON(&sequence_checker_); |
| 72 | RTC_DCHECK_EQ(State::kResolved, state_); |
Harald Alvestrand | e6e2f28 | 2021-03-24 12:13:28 | [diff] [blame] | 73 | return result_; |
| 74 | } |
| 75 | |
Harald Alvestrand | e6e2f28 | 2021-03-24 12:13:28 | [diff] [blame] | 76 | private: |
| 77 | enum class State { kNotStarted, kStarted, kResolved }; |
| 78 | |
Harald Alvestrand | 0ccfbd2 | 2021-04-08 07:25:04 | [diff] [blame] | 79 | friend class WrappingAsyncDnsResolverResult; |
| 80 | // For use by WrappingAsyncDnsResolverResult |
| 81 | rtc::AsyncResolverInterface* wrapped() const { |
| 82 | RTC_DCHECK_RUN_ON(&sequence_checker_); |
| 83 | return wrapped_.get(); |
| 84 | } |
| 85 | |
Harald Alvestrand | e6e2f28 | 2021-03-24 12:13:28 | [diff] [blame] | 86 | void OnResolveResult(rtc::AsyncResolverInterface* ref) { |
Harald Alvestrand | 0ccfbd2 | 2021-04-08 07:25:04 | [diff] [blame] | 87 | RTC_DCHECK_RUN_ON(&sequence_checker_); |
Harald Alvestrand | e6e2f28 | 2021-03-24 12:13:28 | [diff] [blame] | 88 | RTC_DCHECK(state_ == State::kStarted); |
| 89 | RTC_DCHECK_EQ(ref, wrapped_.get()); |
| 90 | state_ = State::kResolved; |
Harald Alvestrand | 0ccfbd2 | 2021-04-08 07:25:04 | [diff] [blame] | 91 | within_resolve_result_ = true; |
Harald Alvestrand | e6e2f28 | 2021-03-24 12:13:28 | [diff] [blame] | 92 | callback_(); |
Harald Alvestrand | 0ccfbd2 | 2021-04-08 07:25:04 | [diff] [blame] | 93 | within_resolve_result_ = false; |
Harald Alvestrand | e6e2f28 | 2021-03-24 12:13:28 | [diff] [blame] | 94 | } |
| 95 | |
Harald Alvestrand | 0ccfbd2 | 2021-04-08 07:25:04 | [diff] [blame] | 96 | // The class variables need to be accessed on a single thread. |
| 97 | SequenceChecker sequence_checker_; |
| 98 | std::function<void()> callback_ RTC_GUARDED_BY(sequence_checker_); |
| 99 | std::unique_ptr<rtc::AsyncResolverInterface> wrapped_ |
| 100 | RTC_GUARDED_BY(sequence_checker_); |
| 101 | State state_ RTC_GUARDED_BY(sequence_checker_) = State::kNotStarted; |
| 102 | WrappingAsyncDnsResolverResult result_ RTC_GUARDED_BY(sequence_checker_); |
| 103 | bool within_resolve_result_ RTC_GUARDED_BY(sequence_checker_) = false; |
Harald Alvestrand | e6e2f28 | 2021-03-24 12:13:28 | [diff] [blame] | 104 | }; |
| 105 | |
| 106 | bool WrappingAsyncDnsResolverResult::GetResolvedAddress( |
| 107 | int family, |
| 108 | rtc::SocketAddress* addr) const { |
| 109 | if (!owner_->wrapped()) { |
| 110 | return false; |
| 111 | } |
| 112 | return owner_->wrapped()->GetResolvedAddress(family, addr); |
| 113 | } |
| 114 | |
| 115 | int WrappingAsyncDnsResolverResult::GetError() const { |
| 116 | if (!owner_->wrapped()) { |
| 117 | return -1; // FIXME: Find a code that makes sense. |
| 118 | } |
| 119 | return owner_->wrapped()->GetError(); |
| 120 | } |
| 121 | |
| 122 | std::unique_ptr<webrtc::AsyncDnsResolverInterface> |
| 123 | WrappingAsyncDnsResolverFactory::Create() { |
| 124 | return std::make_unique<WrappingAsyncDnsResolver>(wrapped_factory_->Create()); |
| 125 | } |
| 126 | |
| 127 | std::unique_ptr<webrtc::AsyncDnsResolverInterface> |
| 128 | WrappingAsyncDnsResolverFactory::CreateAndResolve( |
| 129 | const rtc::SocketAddress& addr, |
| 130 | std::function<void()> callback) { |
| 131 | std::unique_ptr<webrtc::AsyncDnsResolverInterface> resolver = Create(); |
| 132 | resolver->Start(addr, callback); |
| 133 | return resolver; |
| 134 | } |
| 135 | |
Zach Stein | e20867f | 2018-08-02 20:20:15 | [diff] [blame] | 136 | } // namespace webrtc |