mirror/openvpn3
0
0
Fork 0
mirror of https://github.com/OpenVPN/openvpn3.git synced 2024-09-20 12:12:15 +02:00
Code

rename RemoteList::PreResolve to BulkResolve

Browse Source 
Since we're now using it to also re-lookup stale RemoteList items the
new name makes more sense. Also changed the NotifyCallback method to
bulk_resolve_done().

Signed-off-by: Heiko Hund <heiko@openvpn.net>
This commit is contained in:
Heiko Hund 2021-09-16 23:12:26 +02:00
parent e365c44b08
commit c540642c87
3 changed files with 45 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
openvpn/client/cliconnect.hpp
View File

@ -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<thread_unsafe_refcount>
{
@ -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<AsioWork> asio_work;
RemoteList::PreResolve::Ptr pre_resolve;
RemoteList::BulkResolve::Ptr bulk_resolve;
};
}

23
openvpn/client/remotelist.hpp
View File

@ -271,22 +271,23 @@ namespace openvpn {
typedef RCPtr<RemoteList> 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<thread_unsafe_refcount>, 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<thread_unsafe_refcount>, protected AsyncResolvableTCP
{
public:
typedef RCPtr<PreResolve> Ptr;
typedef RCPtr<BulkResolve> 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);

40
test/unittests/test_remotelist.cpp
View File

@ -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("<<<RemoteListPreResolve>>>");
BulkResolveNotifyLog logmsg("<<<RemoteListBulkResolve>>>");
testLog->startCollecting();
fake_preres.start(&logmsg);
fake_bulkres.start(&logmsg);
std::string output(testLog->stopCollecting());
ASSERT_NE(output.find("<<<RemoteListPreResolve>>>"), std::string::npos);
ASSERT_NE(output.find("<<<RemoteListBulkResolve>>>"), 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);