diff --git a/openvpn/client/cliconnect.hpp b/openvpn/client/cliconnect.hpp index f30a9e72..f8442d9b 100644 --- a/openvpn/client/cliconnect.hpp +++ b/openvpn/client/cliconnect.hpp @@ -67,7 +67,7 @@ namespace openvpn { // list rotation. Only gives up on auth failure or other fatal errors that // cannot be remedied by retrying. class ClientConnect : ClientProto::NotifyCallback, - RemoteList::PreResolve::NotifyCallback, + RemoteList::BulkResolve::NotifyCallback, ClientLifeCycle::NotifyCallback, public RC { @@ -103,15 +103,15 @@ namespace openvpn { throw ErrorCode(Error::NETWORK_UNAVAILABLE, true, "Network Unavailable"); RemoteList::Ptr remote_list = client_options->remote_list_precache(); - RemoteList::PreResolve::Ptr preres(new RemoteList::PreResolve(io_context, - remote_list, - client_options->stats_ptr())); - if (preres->work_available()) + RemoteList::BulkResolve::Ptr bulkres(new RemoteList::BulkResolve(io_context, + remote_list, + client_options->stats_ptr())); + if (bulkres->work_available()) { ClientEvent::Base::Ptr ev = new ClientEvent::Resolve(); client_options->events().add_event(std::move(ev)); - pre_resolve = preres; - pre_resolve->start(this); // asynchronous -- will call back to pre_resolve_done + bulk_resolve = bulkres; + bulk_resolve->start(this); // asynchronous -- will call back to bulk_resolve_done } else new_client(); @@ -136,8 +136,8 @@ namespace openvpn { if (!halt) { halt = true; - if (pre_resolve) - pre_resolve->cancel(); + if (bulk_resolve) + bulk_resolve->cancel(); if (client) { client->tun_set_disconnect(); @@ -294,7 +294,7 @@ namespace openvpn { } } - virtual void pre_resolve_done() override + virtual void bulk_resolve_done() override { if (!halt && generation == 0) new_client(); @@ -401,8 +401,8 @@ namespace openvpn { void client_proto_renegotiated() override { // Try to re-lookup potentially outdated RemoteList::Items - if (pre_resolve) - pre_resolve->start(this); + if (bulk_resolve) + bulk_resolve->start(this); } void queue_restart(const unsigned int delay_ms = 2000) @@ -701,7 +701,7 @@ namespace openvpn { AsioTimer conn_timer; bool conn_timer_pending; std::unique_ptr asio_work; - RemoteList::PreResolve::Ptr pre_resolve; + RemoteList::BulkResolve::Ptr bulk_resolve; }; } diff --git a/openvpn/client/remotelist.hpp b/openvpn/client/remotelist.hpp index 925a820d..410cd618 100644 --- a/openvpn/client/remotelist.hpp +++ b/openvpn/client/remotelist.hpp @@ -271,22 +271,23 @@ namespace openvpn { typedef RCPtr Ptr; - // Helper class used to pre-resolve all items in remote list. + // Helper class used to resolve all items in remote list. // This is useful in tun_persist mode, where it may be necessary // to pre-resolve all potential remote server items prior - // to initial tunnel establishment. - class PreResolve : public virtual RC, protected AsyncResolvableTCP + // to initial tunnel establishment. Also used when trying to + // re-resolve items which had too many failed attempts. + class BulkResolve : public virtual RC, protected AsyncResolvableTCP { public: - typedef RCPtr Ptr; + typedef RCPtr Ptr; struct NotifyCallback { // client callback when resolve operation is complete - virtual void pre_resolve_done() = 0; + virtual void bulk_resolve_done() = 0; }; - PreResolve(openvpn_io::io_context& io_context_arg, + BulkResolve(openvpn_io::io_context& io_context_arg, const RemoteList::Ptr& remote_list_arg, const SessionStats::Ptr& stats_arg) : AsyncResolvableTCP(io_context_arg), @@ -307,7 +308,7 @@ namespace openvpn { { if (notify_callback_arg) { - // This method is a no-op (i.e. pre_resolve_done is called immediately) + // This method is a no-op (i.e. bulk_resolve_done is called immediately) // if caching not enabled in underlying remote_list or if start() was // previously called and is still in progress. if (!notify_callback && work_available()) @@ -318,7 +319,7 @@ namespace openvpn { resolve_next(); } else - notify_callback_arg->pre_resolve_done(); + notify_callback_arg->bulk_resolve_done(); } } @@ -341,7 +342,7 @@ namespace openvpn { if (item->need_resolve() && !item_in_use) { // next item to resolve - OPENVPN_LOG_REMOTELIST("*** PreResolve RESOLVE on " << item->to_string()); + OPENVPN_LOG_REMOTELIST("*** BulkResolve RESOLVE on " << item->to_string()); async_resolve_name(item->actual_host(), item->server_port); return; } @@ -357,7 +358,7 @@ namespace openvpn { if (remote_list->cached_item_exists()) remote_list->prune_uncached(); cancel(); - ncb->pre_resolve_done(); + ncb->bulk_resolve_done(); } } @@ -388,7 +389,7 @@ namespace openvpn { else { // resolve failed - OPENVPN_LOG("DNS pre-resolve error on " << resolve_item->actual_host() + OPENVPN_LOG("DNS bulk-resolve error on " << resolve_item->actual_host() << ": " << error.message()); if (stats) stats->error(Error::RESOLVE_ERROR); diff --git a/test/unittests/test_remotelist.cpp b/test/unittests/test_remotelist.cpp index a084a1e7..a4285bff 100644 --- a/test/unittests/test_remotelist.cpp +++ b/test/unittests/test_remotelist.cpp @@ -24,13 +24,13 @@ using namespace openvpn; -struct PreResolveNotifyIgn : RemoteList::PreResolve::NotifyCallback { - void pre_resolve_done() override {} +struct BulkResolveNotifyIgn : RemoteList::BulkResolve::NotifyCallback { + void bulk_resolve_done() override {} }; -struct PreResolveNotifyLog : RemoteList::PreResolve::NotifyCallback { - explicit PreResolveNotifyLog(const std::string& msg = "") +struct BulkResolveNotifyLog : RemoteList::BulkResolve::NotifyCallback { + explicit BulkResolveNotifyLog(const std::string& msg = "") : msg_(msg) {} - void pre_resolve_done() override { + void bulk_resolve_done() override { OPENVPN_LOG(msg_); } const std::string msg_; @@ -289,7 +289,7 @@ TEST(RemoteList, ListTraversal) } -TEST(RemoteList, RemoteListPreResolve) +TEST(RemoteList, RemoteListBulkResolve) { OptionList cfg; cfg.parse_from_config( @@ -309,22 +309,22 @@ TEST(RemoteList, RemoteListPreResolve) openvpn_io::io_context ioctx; SessionStats::Ptr stats(new SessionStats()); FakeAsyncResolvable< - RemoteList::PreResolve, + RemoteList::BulkResolve, openvpn_io::io_context&, const RemoteList::Ptr&, const SessionStats::Ptr&> - fake_preres(ioctx, rl, stats); + fake_bulkres(ioctx, rl, stats); - fake_preres.set_results("1.1.1.1", "1111", { {"1.1.1.1", 1111} }); - fake_preres.set_results("2:cafe::1", "2222", { {"2:cafe::1", 2222} }); - fake_preres.set_results("3.domain.tld", "3333", { {"3.3.3.3", 3333}, {"3::3", 3333} }); - fake_preres.set_results("4.domain.tld", "4444", { {"4.4.4.4", 4444}, {"4::4", 4444} }); + fake_bulkres.set_results("1.1.1.1", "1111", { {"1.1.1.1", 1111} }); + fake_bulkres.set_results("2:cafe::1", "2222", { {"2:cafe::1", 2222} }); + fake_bulkres.set_results("3.domain.tld", "3333", { {"3.3.3.3", 3333}, {"3::3", 3333} }); + fake_bulkres.set_results("4.domain.tld", "4444", { {"4.4.4.4", 4444}, {"4::4", 4444} }); - PreResolveNotifyLog logmsg("<<>>"); + BulkResolveNotifyLog logmsg("<<>>"); testLog->startCollecting(); - fake_preres.start(&logmsg); + fake_bulkres.start(&logmsg); std::string output(testLog->stopCollecting()); - ASSERT_NE(output.find("<<>>"), std::string::npos); + ASSERT_NE(output.find("<<>>"), std::string::npos); ASSERT_EQ(5, rl->size()) << "Unexpected remote list item count" << std::endl @@ -349,13 +349,13 @@ TEST(RemoteList, RemoteListPreResolve) ASSERT_EQ(rl->get_item(4).res_addr_list->at(0)->to_string(), "4::4"); // in case it gets randomized before the other 3.domain.tld - fake_preres.set_results("3.domain.tld", "33333", { {"3.3.3.3", 33333}, {"3::3", 33333} }); + fake_bulkres.set_results("3.domain.tld", "33333", { {"3.3.3.3", 33333}, {"3::3", 33333} }); rl->reset_cache(); rl->randomize(); - PreResolveNotifyIgn ignore; + BulkResolveNotifyIgn ignore; testLog->startCollecting(); - fake_preres.start(&ignore); + fake_bulkres.start(&ignore); output = testLog->stopCollecting(); ASSERT_EQ(5, rl->size()) @@ -409,8 +409,8 @@ TEST(RemoteList, RemoteListPreResolve) ASSERT_EQ(rl->current_transport_protocol(), proto); } - auto ep1 = fake_preres.init_endpoint(); - auto ep2 = fake_preres.init_endpoint(); + auto ep1 = fake_bulkres.init_endpoint(); + auto ep2 = fake_bulkres.init_endpoint(); rl->get_endpoint(ep1); rl->get_item(i).get_endpoint(ep2, j); ASSERT_EQ(ep1, ep2);