OpenVPN 3 Core Library
Loading...
Searching...
No Matches
test_remotelist.cpp
Go to the documentation of this file.
1// OpenVPN -- An application to securely tunnel IP networks
2// over a single port, with support for SSL/TLS-based
3// session authentication and key exchange,
4// packet encryption, packet authentication, and
5// packet compression.
6//
7// Copyright (C) 2012- OpenVPN Inc.
8//
9// SPDX-License-Identifier: MPL-2.0 OR AGPL-3.0-only WITH openvpn3-openssl-exception
10//
11
12
13#include "test_common.hpp"
14
15#include <openvpn/client/remotelist.hpp>
16
17using namespace openvpn;
18
25struct BulkResolveNotifyLog : RemoteList::BulkResolve::NotifyCallback
26{
27 explicit BulkResolveNotifyLog(const std::string &msg = "")
28 : msg_(msg)
29 {
30 }
31 void bulk_resolve_done() override
32 {
33 OPENVPN_LOG(msg_);
34 }
35 const std::string msg_;
36};
37
38
39
40TEST(RemoteList, CtorRemoteOverride)
41{
42 struct TestOverride : public RemoteList::RemoteOverride
43 {
44 TestOverride(const std::string &server_host,
45 const std::string &server_port,
46 const Protocol &transport_protocol)
47 {
48 item_.reset(new RemoteList::Item);
49 item_->server_host = server_host;
50 item_->server_port = server_port;
51 item_->transport_protocol = transport_protocol;
52 }
53 RemoteList::Item::Ptr get() override
54 {
55 return item_;
56 }
57 RemoteList::Item::Ptr item_;
58 };
59
60 TestOverride test_ovr("1.1.1.1", "1111", Protocol(Protocol::UDPv4));
61 RemoteList rl(&test_ovr);
62
63 ASSERT_EQ(rl.defined(), true);
64 ASSERT_EQ(rl.size(), 1UL);
65 ASSERT_EQ(rl.get_item(0)->server_host, "1.1.1.1");
66 ASSERT_EQ(rl.get_item(0)->server_port, "1111");
67 ASSERT_EQ(rl.get_item(0)->transport_protocol, Protocol(Protocol::UDPv4));
68}
69
70
71
72TEST(RemoteList, CtorSingleHost)
73{
74 RemoteList rl("1.1.1.1", "1111", Protocol(Protocol::TCPv6), "");
75 ASSERT_EQ(rl.defined(), true);
76 ASSERT_EQ(rl.size(), 1UL);
77 ASSERT_EQ(rl.get_item(0)->server_host, "1.1.1.1");
78 ASSERT_EQ(rl.get_item(0)->server_port, "1111");
79 ASSERT_EQ(rl.get_item(0)->transport_protocol, Protocol(Protocol::TCPv6));
80}
81TEST(RemoteList, CtorSingleHostBadPort)
82{
83 JY_EXPECT_THROW(
84 RemoteList("1.1.1.1", "99999", Protocol(Protocol::TCPv6), "CtorSingleHostBadPort"),
85 HostPort::host_port_error,
86 "CtorSingleHostBadPort");
87}
88
89
90TEST(RemoteList, CtorRemoteList)
91{
92 OptionList cfg;
93 cfg.parse_from_config(
94 "proto tcp6\n"
95 "remote 0.default.invalid\n"
96 "port 9999\n"
97 "remote 1.domain.invalid 1111 udp\n"
98 "<connection>\n"
99 " remote 2.domain.invalid\n"
100 " port 8888\n"
101 "</connection>\n"
102 "<connection>\n"
103 " proto udp6\n"
104 " remote 3:f00d:4::1\n"
105 "</connection>\n",
106 nullptr);
107 cfg.update_map();
108
109 RandomAPI::Ptr rng;
110 RemoteList rl(cfg, "", 0, nullptr, rng);
111 ASSERT_EQ(rl.defined(), true);
112 ASSERT_EQ(rl.size(), 4UL);
113 ASSERT_EQ(rl.get_item(0)->server_host, "0.default.invalid");
114 ASSERT_EQ(rl.get_item(0)->server_port, "9999");
115 ASSERT_EQ(rl.get_item(0)->transport_protocol, Protocol(Protocol::TCPv6));
116 ASSERT_EQ(rl.get_item(1)->server_host, "1.domain.invalid");
117 ASSERT_EQ(rl.get_item(1)->server_port, "1111");
118 ASSERT_EQ(rl.get_item(1)->transport_protocol, Protocol(Protocol::UDP));
119 ASSERT_EQ(rl.get_item(2)->server_host, "2.domain.invalid");
120 ASSERT_EQ(rl.get_item(2)->server_port, "8888");
121 ASSERT_EQ(rl.get_item(2)->transport_protocol, Protocol(Protocol::TCPv6));
122 ASSERT_EQ(rl.get_item(3)->server_host, "3:f00d:4::1");
123 ASSERT_EQ(rl.get_item(3)->server_port, "9999");
124 ASSERT_EQ(rl.get_item(3)->transport_protocol, Protocol(Protocol::UDPv6));
125}
126TEST(RemoteList, CtorRemoteListConnBlockOnly)
127{
128 OptionList cfg;
129 cfg.parse_from_config(
130 "remote 1.noblock.invalid 1111 udp\n"
131 "<connection>\n"
132 " remote 2.block.invalid\n"
133 "</connection>\n",
134 nullptr);
135 cfg.update_map();
136
137 RandomAPI::Ptr rng;
138 RemoteList rl(cfg, "", RemoteList::CONN_BLOCK_ONLY, nullptr, rng);
139 ASSERT_EQ(rl.defined(), true);
140 ASSERT_EQ(rl.size(), 1UL);
141 ASSERT_EQ(rl.get_item(0)->server_host, "2.block.invalid");
142}
143TEST(RemoteList, CtorRemoteListEmpty)
144{
145 OptionList cfg;
146 cfg.parse_from_config("", nullptr);
147 cfg.update_map();
148
149 RandomAPI::Ptr rng;
150 ASSERT_THROW(RemoteList(cfg, "", 0, nullptr, rng), option_error);
151 RemoteList rl(cfg, "", RemoteList::ALLOW_EMPTY, nullptr, rng);
152}
153TEST(RemoteList, CtorRemoteListConnBlockFactory)
154{
155 struct TestConnBlock : public RemoteList::ConnBlock
156 {
157 void new_item(const RemoteList::Item &item) override
158 {
159 OPENVPN_LOG("TestConnBlock: " << item.to_string());
160 }
161 };
162 struct TestConnBlockFactory : public RemoteList::ConnBlockFactory
163 {
164 RemoteList::ConnBlock::Ptr new_conn_block(const OptionList::Ptr &opt) override
165 {
166 if (opt->exists("block-option"))
167 return RemoteList::ConnBlock::Ptr(new TestConnBlock());
168 return RemoteList::ConnBlock::Ptr();
169 }
170 };
171
172 OptionList cfg;
173 cfg.parse_from_config(
174 "<block>\n"
175 " remote block.invalid\n"
176 " block-option\n"
177 "</block>\n"
178 "<block>\n"
179 " remote block.invalid\n"
180 " unknown-block-option\n"
181 "</block>\n",
182 nullptr);
183 cfg.update_map();
184 TestConnBlockFactory tcbf;
185
186 RandomAPI::Ptr rng;
187 testLog->startCollecting();
188 RemoteList rl1(cfg, "block", 0, &tcbf, rng);
189 std::string output1(testLog->stopCollecting());
190 ASSERT_NE(output1.find("TestConnBlock"), std::string::npos);
191 ASSERT_EQ(rl1.size(), 2UL);
192
193 testLog->startCollecting();
194 RemoteList rl2(cfg, "block", RemoteList::CONN_BLOCK_OMIT_UNDEF, &tcbf, rng);
195 std::string output2(testLog->stopCollecting());
196 ASSERT_NE(output2.find("TestConnBlock"), std::string::npos);
197 ASSERT_EQ(rl2.size(), 1UL);
198}
199TEST(RemoteList, CtorRemoteListWarnUnsupported)
200{
201 OptionList cfg;
202 cfg.parse_from_config(
203 "<connection>\n"
204 " remote block.invalid\n"
205 " http-proxy\n"
206 " http-proxy-option\n"
207 " http-proxy-user-pass\n"
208 "</connection>\n",
209 nullptr);
210 cfg.update_map();
211
212 RandomAPI::Ptr rng;
213 testLog->startCollecting();
214 RemoteList rl(cfg, "", RemoteList::WARN_UNSUPPORTED, nullptr, rng);
215 std::string output(testLog->stopCollecting());
216
217 ASSERT_NE(output.find(" http-proxy "), std::string::npos);
218 ASSERT_NE(output.find(" http-proxy-option "), std::string::npos);
219 ASSERT_NE(output.find(" http-proxy-user-pass "), std::string::npos);
220}
221TEST(RemoteList, CtorRemoteListBlockLimit)
222{
223 OptionList cfg;
224 cfg.parse_from_config(
225 "<connection>\n"
226 " remote block.invalid\n"
227 " directive-with-a-way-too-long-name-to-be-accepted-by-the-block-parser\n"
228 "</connection>\n",
229 nullptr);
230 cfg.update_map();
231
232 RandomAPI::Ptr rng;
233 JY_EXPECT_THROW(RemoteList(cfg, "", 0, nullptr, rng), option_error, "connection_block");
234}
235
236
237TEST(RemoteList, ListTraversal)
238{
239 OptionList cfg;
240 cfg.parse_from_config(
241 "remote 1.domain.tld 1111 udp\n"
242 "remote 2.domain.tld 2222 udp\n",
243 nullptr);
244 cfg.update_map();
245
246 using ResultsType = openvpn_io::ip::tcp::resolver::results_type;
247 using EndpointType = ResultsType::endpoint_type;
248 using EndpointList = std::vector<EndpointType>;
249
250 std::string addr;
251 std::string port;
252 Protocol proto;
253
254 RemoteList::Ptr rl(new RemoteList(cfg, "", 0, nullptr, nullptr));
255 bool available = rl->endpoint_available(&addr, &port, &proto);
256 ASSERT_EQ(available, false);
257 ASSERT_EQ(addr, "1.domain.tld");
258
259 // Create fake resolver results and feed them into RemoteList
260 EndpointType ep;
261 EndpointList epl;
262 epl.push_back({openvpn_io::ip::make_address("1.1.1.1"), 1111});
263 epl.push_back({openvpn_io::ip::make_address("1.1.1.11"), 1111});
264 epl.push_back({openvpn_io::ip::make_address("1::1"), 1111});
265 ResultsType results(ResultsType::create(epl.cbegin(), epl.cend(), addr, port));
266 rl->set_endpoint_range(results);
267
268 // Iterate through results
269 available = rl->endpoint_available(&addr, &port, &proto);
270 ASSERT_EQ(available, true);
271 ASSERT_EQ(addr, "1.domain.tld");
272 ASSERT_NO_THROW(rl->get_endpoint(ep));
273 ASSERT_EQ(ep.address().to_string(), "1.1.1.1");
274 rl->next();
275 ASSERT_NO_THROW(rl->get_endpoint(ep));
276 ASSERT_EQ(ep.address().to_string(), "1.1.1.11");
277 rl->next();
278 ASSERT_NO_THROW(rl->get_endpoint(ep));
279 ASSERT_EQ(ep.address().to_string(), "1::1");
280
281 rl->next();
282 available = rl->endpoint_available(&addr, &port, &proto);
283 ASSERT_EQ(available, false);
284 ASSERT_EQ(addr, "2.domain.tld");
285
286 rl->next();
287 available = rl->endpoint_available(&addr, &port, &proto);
288 ASSERT_EQ(available, false);
289 ASSERT_EQ(addr, "1.domain.tld");
290}
291
292
293TEST(RemoteList, RemoteListBulkResolve)
294{
295 OptionList cfg;
296 cfg.parse_from_config(
297 "remote-cache-lifetime 1\n"
298 "remote 1.1.1.1 1111 udp\n"
299 "remote 2:cafe::1 2222 tcp\n"
300 "remote 3.domain.tld 3333 udp4\n"
301 "remote 3.domain.tld 33333 udp\n"
302 "remote 4.domain.tld 4444 udp6\n"
303 "remote 5.noresolve.tld 5555 udp4\n",
304 nullptr);
305 cfg.update_map();
306
307 RandomAPI::Ptr rng(new MTRand(3735928559));
308 RemoteList::Ptr rl(new RemoteList(cfg, "", 0, nullptr, rng));
309 rl->set_enable_cache(true);
310
311 openvpn_io::io_context ioctx;
312 SessionStats::Ptr stats(new SessionStats());
313 FakeAsyncResolvable<
314 RemoteList::BulkResolve,
315 openvpn_io::io_context &,
316 const RemoteList::Ptr &,
317 const SessionStats::Ptr &>
318 fake_bulkres(ioctx, rl, stats);
319
320 fake_bulkres.set_results("1.1.1.1", "1111", {{"1.1.1.1", 1111}});
321 fake_bulkres.set_results("2:cafe::1", "2222", {{"2:cafe::1", 2222}});
322 fake_bulkres.set_results("3.domain.tld", "3333", {{"3.3.3.3", 3333}, {"3::3", 3333}});
323 fake_bulkres.set_results("4.domain.tld", "4444", {{"4.4.4.4", 4444}, {"4::4", 4444}});
324
325 BulkResolveNotifyLog logmsg("<<<RemoteListBulkResolve>>>");
326 testLog->startCollecting();
327 fake_bulkres.start(&logmsg);
328 std::string output(testLog->stopCollecting());
329 ASSERT_NE(output.find("<<<RemoteListBulkResolve>>>"), std::string::npos);
330
331 ASSERT_EQ(5UL, rl->size())
332 << "Unexpected remote list item count" << std::endl
333 << output;
334
335 ASSERT_EQ(rl->get_item(0)->res_addr_list_defined(), true);
336 ASSERT_EQ(rl->get_item(0)->res_addr_list->size(), 1UL);
337 ASSERT_EQ(rl->get_item(0)->res_addr_list->at(0)->to_string(), "1.1.1.1");
338 ASSERT_EQ(rl->get_item(1)->res_addr_list_defined(), true);
339 ASSERT_EQ(rl->get_item(1)->res_addr_list->size(), 1UL);
340 ASSERT_EQ(rl->get_item(1)->res_addr_list->at(0)->to_string(), "2:cafe::1");
341 ASSERT_EQ(rl->get_item(2)->res_addr_list_defined(), true);
342 ASSERT_EQ(rl->get_item(2)->res_addr_list->size(), 1UL);
343 ASSERT_EQ(rl->get_item(2)->res_addr_list->at(0)->to_string(), "3.3.3.3");
344 ASSERT_EQ(rl->get_item(3)->res_addr_list_defined(), true);
345 ASSERT_EQ(rl->get_item(3)->res_addr_list->size(), 2UL);
346 ASSERT_EQ(rl->get_item(3)->res_addr_list->at(0)->to_string(), "3.3.3.3");
347 ASSERT_EQ(rl->get_item(3)->res_addr_list->at(1)->to_string(), "3::3");
348 ASSERT_EQ(rl->get_item(3)->actual_host(), rl->get_item(2)->actual_host());
349 ASSERT_EQ(rl->get_item(4)->res_addr_list_defined(), true);
350 ASSERT_EQ(rl->get_item(4)->res_addr_list->size(), 1UL);
351 ASSERT_EQ(rl->get_item(4)->res_addr_list->at(0)->to_string(), "4::4");
352
353
354 // Process PUSH reply, setting cache lifetime to 24 hours
355 OptionList push_options;
356 push_options.parse_from_config("remote-cache-lifetime 86400\n", nullptr);
357 push_options.update_map();
358 rl->process_push(push_options);
359
360 rl->next();
361 rl->next();
362 rl->next();
363 rl->next();
364
365 // Now at IPv6 address of 'remote 3.domain.tld 33333 udp'
366 auto ep = fake_bulkres.init_endpoint();
367 rl->get_endpoint(ep);
368 ASSERT_EQ(ep.address().to_string(), "3::3");
369
370
371 // Test re-resolve of list items with different results
372 fake_bulkres.set_results("3.domain.tld", "3333", {{"333::333", 3333}, {"33::33", 3333}, {"33.33.33.33", 3333}});
373 fake_bulkres.set_results("4.domain.tld", "4444", {{"44::44", 4444}, {"444::444", 4444}});
374
375 std::this_thread::sleep_for(std::chrono::seconds(1)); // for cache decay, sorry mom
376 BulkResolveNotifyIgn ignore;
377 testLog->startCollecting();
378 fake_bulkres.start(&ignore);
379 output = testLog->stopCollecting();
380
381 ASSERT_EQ(5UL, rl->size())
382 << "Unexpected remote list item count" << std::endl
383 << output;
384
385 ASSERT_EQ(rl->get_item(0)->res_addr_list_defined(), true);
386 ASSERT_EQ(rl->get_item(0)->res_addr_list->size(), 1UL);
387 ASSERT_EQ(rl->get_item(0)->res_addr_list->at(0)->to_string(), "1.1.1.1");
388 ASSERT_EQ(rl->get_item(1)->res_addr_list_defined(), true);
389 ASSERT_EQ(rl->get_item(1)->res_addr_list->size(), 1UL);
390 ASSERT_EQ(rl->get_item(1)->res_addr_list->at(0)->to_string(), "2:cafe::1");
391 ASSERT_EQ(rl->get_item(2)->res_addr_list_defined(), true);
392 ASSERT_EQ(rl->get_item(2)->res_addr_list->size(), 1UL);
393 ASSERT_EQ(rl->get_item(2)->res_addr_list->at(0)->to_string(), "33.33.33.33");
394 ASSERT_EQ(rl->get_item(3)->res_addr_list_defined(), true);
395 ASSERT_EQ(rl->get_item(3)->res_addr_list->size(), 3UL);
396 ASSERT_EQ(rl->get_item(3)->res_addr_list->at(0)->to_string(), "333::333");
397 ASSERT_EQ(rl->get_item(3)->res_addr_list->at(1)->to_string(), "33::33");
398 ASSERT_EQ(rl->get_item(3)->res_addr_list->at(2)->to_string(), "33.33.33.33");
399 ASSERT_EQ(rl->get_item(4)->res_addr_list_defined(), true);
400 ASSERT_EQ(rl->get_item(4)->res_addr_list->size(), 2UL);
401 ASSERT_EQ(rl->get_item(4)->res_addr_list->at(0)->to_string(), "44::44");
402 ASSERT_EQ(rl->get_item(4)->res_addr_list->at(1)->to_string(), "444::444");
403
404 // Now we should be at first address of 'remote 3.domain.tld 33333 udp'
405 // as the item address index was reset
406 rl->get_endpoint(ep);
407 ASSERT_EQ(ep.address().to_string(), "333::333");
408
409
410 // back to old results, add 33333 in case it gets randomized before the other 3.domain.tld
411 fake_bulkres.set_results("3.domain.tld", "3333", {{"3.3.3.3", 3333}, {"3::3", 3333}});
412 fake_bulkres.set_results("3.domain.tld", "33333", {{"3.3.3.3", 33333}, {"3::3", 33333}});
413 fake_bulkres.set_results("4.domain.tld", "4444", {{"4.4.4.4", 4444}, {"4::4", 4444}});
414
415 testLog->startCollecting();
416 fake_bulkres.start(&ignore);
417 output = testLog->stopCollecting();
418
419 // Cache was still be good, i.e. no updated 3 and 4
420 ASSERT_EQ(5UL, rl->size())
421 << "Unexpected remote list item count" << std::endl
422 << output;
423
424 ASSERT_EQ(rl->get_item(2)->res_addr_list_defined(), true);
425 ASSERT_EQ(rl->get_item(2)->res_addr_list->size(), 1UL);
426 ASSERT_EQ(rl->get_item(2)->res_addr_list->at(0)->to_string(), "33.33.33.33");
427 ASSERT_EQ(rl->get_item(3)->res_addr_list_defined(), true);
428 ASSERT_EQ(rl->get_item(3)->res_addr_list->size(), 3UL);
429 ASSERT_EQ(rl->get_item(3)->res_addr_list->at(0)->to_string(), "333::333");
430 ASSERT_EQ(rl->get_item(3)->res_addr_list->at(1)->to_string(), "33::33");
431 ASSERT_EQ(rl->get_item(3)->res_addr_list->at(2)->to_string(), "33.33.33.33");
432 ASSERT_EQ(rl->get_item(4)->res_addr_list_defined(), true);
433 ASSERT_EQ(rl->get_item(4)->res_addr_list->size(), 2UL);
434 ASSERT_EQ(rl->get_item(4)->res_addr_list->at(0)->to_string(), "44::44");
435 ASSERT_EQ(rl->get_item(4)->res_addr_list->at(1)->to_string(), "444::444");
436
437
438 // And now for something completely different
439 rl->reset_cache();
440 rl->randomize();
441
442 testLog->startCollecting();
443 fake_bulkres.start(&ignore);
444 output = testLog->stopCollecting();
445
446 ASSERT_EQ(5UL, rl->size())
447 << "Unexpected remote list item count" << std::endl
448 << output;
449
450 for (size_t i = 0; i < rl->size(); ++i)
451 {
452 ASSERT_EQ(rl->get_item(i)->res_addr_list_defined(), true);
453 if (rl->get_item(i)->server_host[0] == '1')
454 {
455 ASSERT_EQ(rl->get_item(i)->res_addr_list->size(), 1UL);
456 ASSERT_EQ(rl->get_item(i)->res_addr_list->at(0)->to_string(), "1.1.1.1");
457 }
458 else if (rl->get_item(i)->server_host[0] == '2')
459 {
460 ASSERT_EQ(rl->get_item(i)->res_addr_list->size(), 1UL);
461 ASSERT_EQ(rl->get_item(i)->res_addr_list->at(0)->to_string(), "2:cafe::1");
462 }
463 else if (rl->get_item(i)->server_host[0] == '3')
464 {
465 if (rl->get_item(i)->transport_protocol.is_ipv4())
466 {
467 ASSERT_EQ(rl->get_item(i)->res_addr_list->size(), 1UL);
468 ASSERT_EQ(rl->get_item(i)->res_addr_list->at(0)->to_string(), "3.3.3.3");
469 }
470 else
471 {
472 ASSERT_EQ(rl->get_item(i)->res_addr_list->size(), 2UL);
473 }
474 }
475 else if (rl->get_item(i)->server_host[0] == '4')
476 {
477 ASSERT_EQ(rl->get_item(i)->res_addr_list->size(), 1UL);
478 ASSERT_EQ(rl->get_item(i)->res_addr_list->at(0)->to_string(), "4::4");
479 }
480 }
481
482 for (size_t i = 0; i < rl->size(); ++i)
483 {
484 for (size_t j = 0; j < rl->get_item(i)->res_addr_list->size(); ++j)
485 {
486 std::string host;
487 std::string port;
488 Protocol proto;
489 ASSERT_EQ(rl->endpoint_available(&host, &port, &proto), true);
490 ASSERT_EQ(rl->get_item(i)->actual_host(), host);
491 ASSERT_EQ(rl->get_item(i)->server_port, port);
492 if (rl->current_transport_protocol().is_ipv4()
493 || rl->current_transport_protocol().is_ipv6())
494 {
495 ASSERT_EQ(rl->current_transport_protocol(), proto);
496 }
497
498 auto ep1 = fake_bulkres.init_endpoint();
499 auto ep2 = fake_bulkres.init_endpoint();
500 rl->get_endpoint(ep1);
501 rl->get_item(i)->get_endpoint(ep2, j);
502 ASSERT_EQ(ep1, ep2);
503
504 rl->next();
505 }
506 }
507}
508
509
510
511TEST(RemoteList, RemoteRandomHostname)
512{
513 OptionList cfg;
514 cfg.parse_from_config(
515 "remote-random-hostname\n"
516 "remote 1.1.1.1\n"
517 "remote 2.domain.invalid\n"
518 "<connection>\n"
519 " remote 3.domain.invalid\n"
520 "</connection>\n"
521 "<connection>\n"
522 " remote 4:cafe::1\n"
523 "</connection>\n",
524 nullptr);
525 cfg.update_map();
526
527 RandomAPI::Ptr rng(new FakeSecureRand(0xf7));
528 RemoteList rl(cfg, "", 0, nullptr, rng);
529
530 ASSERT_EQ(rl.size(), 4UL);
531 ASSERT_EQ(rl.get_item(0)->actual_host(), "1.1.1.1");
532 ASSERT_EQ(rl.get_item(1)->actual_host(), "f7f8f9fafbfc.2.domain.invalid");
533 ASSERT_EQ(rl.get_item(2)->actual_host(), "fdfeff000102.3.domain.invalid");
534 ASSERT_EQ(rl.get_item(3)->actual_host(), "4:cafe::1");
535 rl.next();
536 ASSERT_EQ(rl.current_server_host(), "030405060708.2.domain.invalid");
537 rl.next();
538 ASSERT_EQ(rl.current_server_host(), "090a0b0c0d0e.3.domain.invalid");
539
540 ASSERT_EQ(rl.get_enable_cache(), false);
541 rl.set_enable_cache(true);
542 ASSERT_EQ(rl.get_enable_cache(), true);
543 rl.next();
544 rl.next();
545
546 rl.next();
547 ASSERT_EQ(rl.current_server_host(), "030405060708.2.domain.invalid");
548 rl.next();
549 ASSERT_EQ(rl.current_server_host(), "090a0b0c0d0e.3.domain.invalid");
550}
551TEST(RemoteList, RemoteRandomHostnameNoRNG)
552{
553 OptionList cfg;
554 cfg.parse_from_config(
555 "remote-random-hostname\n"
556 "remote domain.invalid\n",
557 nullptr);
558 cfg.update_map();
559
560 RandomAPI::Ptr no_rng;
561 RemoteList rl(cfg, "", 0, nullptr, no_rng);
562 ASSERT_EQ(rl.current_server_host(), "domain.invalid");
563}
564
565
566TEST(RemoteList, OverrideFunctions)
567{
568 OptionList cfg;
569 cfg.parse_from_config(
570 "remote-random-hostname\n"
571 "remote config.host.invalid 1111 udp6\n"
572 "remote config.host.invalid 1111 tcp\n"
573 "remote config.host.invalid 1111 tls4\n",
574 nullptr);
575 cfg.update_map();
576
577 RandomAPI::Ptr rng(new FakeSecureRand(0xf7));
578 RemoteList rl(cfg, "", 0, nullptr, rng);
579 ASSERT_EQ(rl.size(), 3UL);
580
581 rl.set_proto_version_override(IP::Addr::Version::V6);
582 for (size_t i = 0; i < rl.size(); ++i)
583 ASSERT_TRUE(rl.get_item(i)->transport_protocol.is_ipv6());
584
585 rl.set_proto_version_override(IP::Addr::Version::V4);
586 for (size_t i = 0; i < rl.size(); ++i)
587 ASSERT_TRUE(rl.get_item(i)->transport_protocol.is_ipv4());
588
589 rl.handle_proto_override(Protocol(Protocol::UDPv4), true);
590 ASSERT_EQ(rl.size(), 1UL);
591 ASSERT_EQ(rl.current_transport_protocol(), Protocol(Protocol::TCPv4));
592
593 rl.set_port_override("4711");
594 ASSERT_EQ(rl.size(), 1UL);
595 ASSERT_EQ(rl.get_item(0)->server_port, "4711");
596
597 rl.set_server_override("override.host.invalid");
598 ASSERT_EQ(rl.size(), 1UL);
599 ASSERT_EQ(rl.current_server_host(), "override.host.invalid");
600}
openvpn::OptionList::parse_from_config
void parse_from_config(const std::string &str, Limits *lim)
Definition options.hpp:985
openvpn::Protocol::is_ipv4
bool is_ipv4() const
Definition protocol.hpp:91
openvpn::Protocol::is_ipv6
bool is_ipv6() const
Definition protocol.hpp:95
openvpn::RCPtr
The smart pointer class.
Definition rc.hpp:119
openvpn::RemoteList::set_endpoint_range
void set_endpoint_range(EPRANGE &endpoint_range)
Definition remotelist.hpp:667
openvpn::RemoteList::endpoint_available
bool endpoint_available(std::string *server_host, std::string *server_port, Protocol *transport_protocol) const
Definition remotelist.hpp:650
openvpn::RemoteList::get_endpoint
void get_endpoint(EP &endpoint) const
Definition remotelist.hpp:678
openvpn::RemoteList::set_server_override
void set_server_override(const std::string &server_override)
Definition remotelist.hpp:554
openvpn::RemoteList::next
void next(Advance type=Advance::Addr)
Definition remotelist.hpp:625
openvpn::RemoteList::handle_proto_override
void handle_proto_override(const Protocol &proto_override, const bool tcp_proxy_enabled)
Definition remotelist.hpp:610
openvpn::RemoteList::defined
bool defined() const
Definition remotelist.hpp:686
openvpn::RemoteList::get_enable_cache
bool get_enable_cache() const
Definition remotelist.hpp:548
openvpn::RemoteList::set_enable_cache
void set_enable_cache(const bool enable_cache_arg)
Definition remotelist.hpp:543
openvpn::RemoteList::set_proto_version_override
void set_proto_version_override(const IP::Addr::Version v)
Definition remotelist.hpp:582
openvpn::RemoteList::get_item
Item::Ptr get_item(const size_t index) const
Definition remotelist.hpp:697
openvpn::RemoteList::set_port_override
void set_port_override(const std::string &port_override)
Definition remotelist.hpp:569
openvpn::RemoteList::current_transport_protocol
const Protocol & current_transport_protocol() const
Definition remotelist.hpp:710
openvpn::RemoteList::process_push
void process_push(const OptionList &opt)
Definition remotelist.hpp:537
openvpn::RemoteList::current_server_host
std::string current_server_host() const
Definition remotelist.hpp:703
openvpn::RemoteList::size
size_t size() const
Definition remotelist.hpp:692
testLog
openvpn::LogOutputCollector * testLog
Definition core_tests.cpp:25
OPENVPN_LOG
#define OPENVPN_LOG(args)
Definition logdatetime.hpp:23
BulkResolveNotifyIgn::bulk_resolve_done
void bulk_resolve_done() override
Definition test_remotelist.cpp:21
BulkResolveNotifyLog::BulkResolveNotifyLog
BulkResolveNotifyLog(const std::string &msg="")
Definition test_remotelist.cpp:27
BulkResolveNotifyLog::bulk_resolve_done
void bulk_resolve_done() override
Definition test_remotelist.cpp:31
BulkResolveNotifyLog::msg_
const std::string msg_
Definition test_remotelist.cpp:35
openvpn::RemoteList::ConnBlockFactory::new_conn_block
virtual ConnBlock::Ptr new_conn_block(const OptionList::Ptr &opt)=0
openvpn::RemoteList::ConnBlock::new_item
virtual void new_item(const Item &item)=0
openvpn::RemoteList::Item::to_string
std::string to_string() const
Definition remotelist.hpp:210
port
proxy_host_port port
Definition test_capture.cpp:696
host
proxy_host_port host
Definition test_capture.cpp:682
test_common.hpp
JY_EXPECT_THROW
#define JY_EXPECT_THROW
Definition test_helper.hpp:427
TEST
TEST(RemoteList, CtorRemoteOverride)
Definition test_remotelist.cpp:40
msg
#define msg(flags,...)
Definition xkey_msg_compat.h:14