summaryrefslogtreecommitdiffstats
path: root/src/c-ares/test/ares-test-init.cc
diff options
context:
space:
mode:
Diffstat (limited to 'src/c-ares/test/ares-test-init.cc')
-rw-r--r--src/c-ares/test/ares-test-init.cc595
1 files changed, 595 insertions, 0 deletions
diff --git a/src/c-ares/test/ares-test-init.cc b/src/c-ares/test/ares-test-init.cc
new file mode 100644
index 000000000..66570ace5
--- /dev/null
+++ b/src/c-ares/test/ares-test-init.cc
@@ -0,0 +1,595 @@
+#include "ares-test.h"
+
+// library initialization is only needed for windows builds
+#ifdef WIN32
+#define EXPECTED_NONINIT ARES_ENOTINITIALIZED
+#else
+#define EXPECTED_NONINIT ARES_SUCCESS
+#endif
+
+namespace ares {
+namespace test {
+
+TEST(LibraryInit, Basic) {
+ EXPECT_EQ(EXPECTED_NONINIT, ares_library_initialized());
+ EXPECT_EQ(ARES_SUCCESS, ares_library_init(ARES_LIB_INIT_ALL));
+ EXPECT_EQ(ARES_SUCCESS, ares_library_initialized());
+ ares_library_cleanup();
+ EXPECT_EQ(EXPECTED_NONINIT, ares_library_initialized());
+}
+
+TEST(LibraryInit, UnexpectedCleanup) {
+ EXPECT_EQ(EXPECTED_NONINIT, ares_library_initialized());
+ ares_library_cleanup();
+ EXPECT_EQ(EXPECTED_NONINIT, ares_library_initialized());
+}
+
+TEST(LibraryInit, DISABLED_InvalidParam) {
+ // TODO: police flags argument to ares_library_init()
+ EXPECT_EQ(ARES_EBADQUERY, ares_library_init(ARES_LIB_INIT_ALL << 2));
+ EXPECT_EQ(EXPECTED_NONINIT, ares_library_initialized());
+ ares_library_cleanup();
+}
+
+TEST(LibraryInit, Nested) {
+ EXPECT_EQ(EXPECTED_NONINIT, ares_library_initialized());
+ EXPECT_EQ(ARES_SUCCESS, ares_library_init(ARES_LIB_INIT_ALL));
+ EXPECT_EQ(ARES_SUCCESS, ares_library_initialized());
+ EXPECT_EQ(ARES_SUCCESS, ares_library_init(ARES_LIB_INIT_ALL));
+ EXPECT_EQ(ARES_SUCCESS, ares_library_initialized());
+ ares_library_cleanup();
+ EXPECT_EQ(ARES_SUCCESS, ares_library_initialized());
+ ares_library_cleanup();
+ EXPECT_EQ(EXPECTED_NONINIT, ares_library_initialized());
+}
+
+TEST(LibraryInit, BasicChannelInit) {
+ EXPECT_EQ(ARES_SUCCESS, ares_library_init(ARES_LIB_INIT_ALL));
+ ares_channel channel = nullptr;
+ EXPECT_EQ(ARES_SUCCESS, ares_init(&channel));
+ EXPECT_NE(nullptr, channel);
+ ares_destroy(channel);
+ ares_library_cleanup();
+}
+
+TEST_F(LibraryTest, OptionsChannelInit) {
+ struct ares_options opts = {0};
+ int optmask = 0;
+ opts.flags = ARES_FLAG_USEVC | ARES_FLAG_PRIMARY;
+ optmask |= ARES_OPT_FLAGS;
+ opts.timeout = 2000;
+ optmask |= ARES_OPT_TIMEOUTMS;
+ opts.tries = 2;
+ optmask |= ARES_OPT_TRIES;
+ opts.ndots = 4;
+ optmask |= ARES_OPT_NDOTS;
+ opts.udp_port = 54;
+ optmask |= ARES_OPT_UDP_PORT;
+ opts.tcp_port = 54;
+ optmask |= ARES_OPT_TCP_PORT;
+ opts.socket_send_buffer_size = 514;
+ optmask |= ARES_OPT_SOCK_SNDBUF;
+ opts.socket_receive_buffer_size = 514;
+ optmask |= ARES_OPT_SOCK_RCVBUF;
+ opts.ednspsz = 1280;
+ optmask |= ARES_OPT_EDNSPSZ;
+ opts.nservers = 2;
+ opts.servers = (struct in_addr *)malloc(opts.nservers * sizeof(struct in_addr));
+ opts.servers[0].s_addr = htonl(0x01020304);
+ opts.servers[1].s_addr = htonl(0x02030405);
+ optmask |= ARES_OPT_SERVERS;
+ opts.ndomains = 2;
+ opts.domains = (char **)malloc(opts.ndomains * sizeof(char *));
+ opts.domains[0] = strdup("example.com");
+ opts.domains[1] = strdup("example2.com");
+ optmask |= ARES_OPT_DOMAINS;
+ opts.lookups = strdup("b");
+ optmask |= ARES_OPT_LOOKUPS;
+ optmask |= ARES_OPT_ROTATE;
+
+ ares_channel channel = nullptr;
+ EXPECT_EQ(ARES_SUCCESS, ares_init_options(&channel, &opts, optmask));
+ EXPECT_NE(nullptr, channel);
+
+ ares_channel channel2 = nullptr;
+ EXPECT_EQ(ARES_SUCCESS, ares_dup(&channel2, channel));
+
+ struct ares_options opts2 = {0};
+ int optmask2 = 0;
+ EXPECT_EQ(ARES_SUCCESS, ares_save_options(channel2, &opts2, &optmask2));
+
+ // Note that not all opts-settable fields are saved (e.g.
+ // ednspsz, socket_{send,receive}_buffer_size).
+ EXPECT_EQ(opts.flags, opts2.flags);
+ EXPECT_EQ(opts.timeout, opts2.timeout);
+ EXPECT_EQ(opts.tries, opts2.tries);
+ EXPECT_EQ(opts.ndots, opts2.ndots);
+ EXPECT_EQ(opts.udp_port, opts2.udp_port);
+ EXPECT_EQ(opts.tcp_port, opts2.tcp_port);
+ EXPECT_EQ(1, opts2.nservers); // Truncated by ARES_FLAG_PRIMARY
+ EXPECT_EQ(opts.servers[0].s_addr, opts2.servers[0].s_addr);
+ EXPECT_EQ(opts.ndomains, opts2.ndomains);
+ EXPECT_EQ(std::string(opts.domains[0]), std::string(opts2.domains[0]));
+ EXPECT_EQ(std::string(opts.domains[1]), std::string(opts2.domains[1]));
+ EXPECT_EQ(std::string(opts.lookups), std::string(opts2.lookups));
+
+ ares_destroy_options(&opts);
+ ares_destroy_options(&opts2);
+ ares_destroy(channel);
+ ares_destroy(channel2);
+}
+
+TEST_F(LibraryTest, ChannelAllocFail) {
+ ares_channel channel;
+ for (int ii = 1; ii <= 25; ii++) {
+ ClearFails();
+ SetAllocFail(ii);
+ channel = nullptr;
+ int rc = ares_init(&channel);
+ // The number of allocations depends on local environment, so don't expect ENOMEM.
+ if (rc == ARES_ENOMEM) {
+ EXPECT_EQ(nullptr, channel);
+ } else {
+ ares_destroy(channel);
+ }
+ }
+}
+
+TEST_F(LibraryTest, OptionsChannelAllocFail) {
+ struct ares_options opts = {0};
+ int optmask = 0;
+ opts.flags = ARES_FLAG_USEVC;
+ optmask |= ARES_OPT_FLAGS;
+ opts.timeout = 2;
+ optmask |= ARES_OPT_TIMEOUT;
+ opts.tries = 2;
+ optmask |= ARES_OPT_TRIES;
+ opts.ndots = 4;
+ optmask |= ARES_OPT_NDOTS;
+ opts.udp_port = 54;
+ optmask |= ARES_OPT_UDP_PORT;
+ opts.tcp_port = 54;
+ optmask |= ARES_OPT_TCP_PORT;
+ opts.socket_send_buffer_size = 514;
+ optmask |= ARES_OPT_SOCK_SNDBUF;
+ opts.socket_receive_buffer_size = 514;
+ optmask |= ARES_OPT_SOCK_RCVBUF;
+ opts.ednspsz = 1280;
+ optmask |= ARES_OPT_EDNSPSZ;
+ opts.nservers = 2;
+ opts.servers = (struct in_addr *)malloc(opts.nservers * sizeof(struct in_addr));
+ opts.servers[0].s_addr = htonl(0x01020304);
+ opts.servers[1].s_addr = htonl(0x02030405);
+ optmask |= ARES_OPT_SERVERS;
+ opts.ndomains = 2;
+ opts.domains = (char **)malloc(opts.ndomains * sizeof(char *));
+ opts.domains[0] = strdup("example.com");
+ opts.domains[1] = strdup("example2.com");
+ optmask |= ARES_OPT_DOMAINS;
+ opts.lookups = strdup("b");
+ optmask |= ARES_OPT_LOOKUPS;
+ optmask |= ARES_OPT_ROTATE;
+
+ ares_channel channel = nullptr;
+ for (int ii = 1; ii <= 8; ii++) {
+ ClearFails();
+ SetAllocFail(ii);
+ int rc = ares_init_options(&channel, &opts, optmask);
+ if (rc == ARES_ENOMEM) {
+ EXPECT_EQ(nullptr, channel);
+ } else {
+ EXPECT_EQ(ARES_SUCCESS, rc);
+ ares_destroy(channel);
+ channel = nullptr;
+ }
+ }
+ ClearFails();
+
+ EXPECT_EQ(ARES_SUCCESS, ares_init_options(&channel, &opts, optmask));
+ EXPECT_NE(nullptr, channel);
+
+ // Add some servers and a sortlist for flavour.
+ EXPECT_EQ(ARES_SUCCESS,
+ ares_set_servers_csv(channel, "1.2.3.4,0102:0304:0506:0708:0910:1112:1314:1516,2.3.4.5"));
+ EXPECT_EQ(ARES_SUCCESS, ares_set_sortlist(channel, "1.2.3.4 2.3.4.5"));
+
+ ares_channel channel2 = nullptr;
+ for (int ii = 1; ii <= 18; ii++) {
+ ClearFails();
+ SetAllocFail(ii);
+ EXPECT_EQ(ARES_ENOMEM, ares_dup(&channel2, channel)) << ii;
+ EXPECT_EQ(nullptr, channel2) << ii;
+ }
+
+ struct ares_options opts2;
+ int optmask2 = 0;
+ for (int ii = 1; ii <= 6; ii++) {
+ memset(&opts2, 0, sizeof(opts2));
+ ClearFails();
+ SetAllocFail(ii);
+ EXPECT_EQ(ARES_ENOMEM, ares_save_options(channel, &opts2, &optmask2)) << ii;
+ // May still have allocations even after ARES_ENOMEM return code.
+ ares_destroy_options(&opts2);
+ }
+ ares_destroy_options(&opts);
+ ares_destroy(channel);
+}
+
+TEST_F(LibraryTest, FailChannelInit) {
+ EXPECT_EQ(ARES_SUCCESS,
+ ares_library_init_mem(ARES_LIB_INIT_ALL,
+ &LibraryTest::amalloc,
+ &LibraryTest::afree,
+ &LibraryTest::arealloc));
+ SetAllocFail(1);
+ ares_channel channel = nullptr;
+ EXPECT_EQ(ARES_ENOMEM, ares_init(&channel));
+ EXPECT_EQ(nullptr, channel);
+ ares_library_cleanup();
+}
+
+#ifndef WIN32
+TEST_F(LibraryTest, EnvInit) {
+ ares_channel channel = nullptr;
+ EnvValue v1("LOCALDOMAIN", "this.is.local");
+ EnvValue v2("RES_OPTIONS", "options debug ndots:3 retry:3 rotate retrans:2");
+ EXPECT_EQ(ARES_SUCCESS, ares_init(&channel));
+ ares_destroy(channel);
+}
+
+TEST_F(LibraryTest, EnvInitAllocFail) {
+ ares_channel channel;
+ EnvValue v1("LOCALDOMAIN", "this.is.local");
+ EnvValue v2("RES_OPTIONS", "options debug ndots:3 retry:3 rotate retrans:2");
+ for (int ii = 1; ii <= 10; ii++) {
+ ClearFails();
+ SetAllocFail(ii);
+ channel = nullptr;
+ int rc = ares_init(&channel);
+ if (rc == ARES_SUCCESS) {
+ ares_destroy(channel);
+ } else {
+ EXPECT_EQ(ARES_ENOMEM, rc);
+ }
+ }
+}
+#endif
+
+TEST_F(DefaultChannelTest, SetAddresses) {
+ ares_set_local_ip4(channel_, 0x01020304);
+ byte addr6[16] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+ 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10};
+ ares_set_local_ip6(channel_, addr6);
+ ares_set_local_dev(channel_, "dummy");
+}
+
+TEST_F(DefaultChannelTest, SetSortlistFailures) {
+ EXPECT_EQ(ARES_ENODATA, ares_set_sortlist(nullptr, "1.2.3.4"));
+ EXPECT_EQ(ARES_SUCCESS, ares_set_sortlist(channel_, "xyzzy ; lwk"));
+ EXPECT_EQ(ARES_SUCCESS, ares_set_sortlist(channel_, "xyzzy ; 0x123"));
+}
+
+TEST_F(DefaultChannelTest, SetSortlistVariants) {
+ EXPECT_EQ(ARES_SUCCESS, ares_set_sortlist(channel_, "1.2.3.4"));
+ EXPECT_EQ(ARES_SUCCESS, ares_set_sortlist(channel_, "1.2.3.4 ; 2.3.4.5"));
+ EXPECT_EQ(ARES_SUCCESS, ares_set_sortlist(channel_, "129.1.1.1"));
+ EXPECT_EQ(ARES_SUCCESS, ares_set_sortlist(channel_, "192.1.1.1"));
+ EXPECT_EQ(ARES_SUCCESS, ares_set_sortlist(channel_, "224.1.1.1"));
+ EXPECT_EQ(ARES_SUCCESS, ares_set_sortlist(channel_, "225.1.1.1"));
+}
+
+TEST_F(DefaultChannelTest, SetSortlistAllocFail) {
+ for (int ii = 1; ii <= 3; ii++) {
+ ClearFails();
+ SetAllocFail(ii);
+ EXPECT_EQ(ARES_ENOMEM, ares_set_sortlist(channel_, "12.13.0.0/16 1234::5678/40 1.2.3.4")) << ii;
+ }
+}
+
+#ifdef USE_WINSOCK
+TEST(Init, NoLibraryInit) {
+ ares_channel channel = nullptr;
+ EXPECT_EQ(ARES_ENOTINITIALIZED, ares_init(&channel));
+}
+#endif
+
+#ifdef HAVE_CONTAINER
+// These tests rely on the ability of non-root users to create a chroot
+// using Linux namespaces.
+
+
+// The library uses a variety of information sources to initialize a channel,
+// in particular to determine:
+// - search: the search domains to use
+// - servers: the name servers to use
+// - lookup: whether to check files or DNS or both (e.g. "fb")
+// - options: various resolver options
+// - sortlist: the order of preference for IP addresses
+//
+// The first source from the following list is used:
+// - init_by_options(): explicitly specified values in struct ares_options
+// - init_by_environment(): values from the environment:
+// - LOCALDOMAIN -> search (single value)
+// - RES_OPTIONS -> options
+// - init_by_resolv_conf(): values from various config files:
+// - /etc/resolv.conf -> search, lookup, servers, sortlist, options
+// - /etc/nsswitch.conf -> lookup
+// - /etc/host.conf -> lookup
+// - /etc/svc.conf -> lookup
+// - init_by_defaults(): fallback values:
+// - gethostname(3) -> domain
+// - "fb" -> lookup
+
+NameContentList filelist = {
+ {"/etc/resolv.conf", "nameserver 1.2.3.4\n"
+ "sortlist 1.2.3.4/16 2.3.4.5\n"
+ "search first.com second.com\n"},
+ {"/etc/hosts", "3.4.5.6 ahostname.com\n"},
+ {"/etc/nsswitch.conf", "hosts: files\n"}};
+CONTAINED_TEST_F(LibraryTest, ContainerChannelInit,
+ "myhostname", "mydomainname.org", filelist) {
+ ares_channel channel = nullptr;
+ EXPECT_EQ(ARES_SUCCESS, ares_init(&channel));
+ std::vector<std::string> actual = GetNameServers(channel);
+ std::vector<std::string> expected = {"1.2.3.4"};
+ EXPECT_EQ(expected, actual);
+
+ struct ares_options opts;
+ int optmask = 0;
+ ares_save_options(channel, &opts, &optmask);
+ EXPECT_EQ(2, opts.ndomains);
+ EXPECT_EQ(std::string("first.com"), std::string(opts.domains[0]));
+ EXPECT_EQ(std::string("second.com"), std::string(opts.domains[1]));
+ ares_destroy_options(&opts);
+
+ HostResult result;
+ ares_gethostbyname(channel, "ahostname.com", AF_INET, HostCallback, &result);
+ ProcessWork(channel, NoExtraFDs, nullptr);
+ EXPECT_TRUE(result.done_);
+ std::stringstream ss;
+ ss << result.host_;
+ EXPECT_EQ("{'ahostname.com' aliases=[] addrs=[3.4.5.6]}", ss.str());
+
+ ares_destroy(channel);
+ return HasFailure();
+}
+
+CONTAINED_TEST_F(LibraryTest, ContainerSortlistOptionInit,
+ "myhostname", "mydomainname.org", filelist) {
+ ares_channel channel = nullptr;
+ struct ares_options opts = {0};
+ int optmask = 0;
+ optmask |= ARES_OPT_SORTLIST;
+ opts.nsort = 0;
+ // Explicitly specifying an empty sortlist in the options should override the
+ // environment.
+ EXPECT_EQ(ARES_SUCCESS, ares_init_options(&channel, &opts, optmask));
+ ares_save_options(channel, &opts, &optmask);
+ EXPECT_EQ(0, opts.nsort);
+ EXPECT_EQ(nullptr, opts.sortlist);
+ EXPECT_EQ(ARES_OPT_SORTLIST, (optmask & ARES_OPT_SORTLIST));
+ ares_destroy_options(&opts);
+
+ ares_destroy(channel);
+ return HasFailure();
+}
+
+NameContentList fullresolv = {
+ {"/etc/resolv.conf", " nameserver 1.2.3.4 \n"
+ "search first.com second.com\n"
+ "lookup bind\n"
+ "options debug ndots:5\n"
+ "sortlist 1.2.3.4/16 2.3.4.5\n"}};
+CONTAINED_TEST_F(LibraryTest, ContainerFullResolvInit,
+ "myhostname", "mydomainname.org", fullresolv) {
+ ares_channel channel = nullptr;
+ EXPECT_EQ(ARES_SUCCESS, ares_init(&channel));
+
+ struct ares_options opts;
+ int optmask = 0;
+ ares_save_options(channel, &opts, &optmask);
+ EXPECT_EQ(std::string("b"), std::string(opts.lookups));
+ EXPECT_EQ(5, opts.ndots);
+ ares_destroy_options(&opts);
+
+ ares_destroy(channel);
+ return HasFailure();
+}
+
+NameContentList hostconf = {
+ {"/etc/resolv.conf", "nameserver 1.2.3.4\n"
+ "sortlist1.2.3.4\n" // malformed line
+ "search first.com second.com\n"},
+ {"/etc/host.conf", "order bind hosts\n"}};
+CONTAINED_TEST_F(LibraryTest, ContainerHostConfInit,
+ "myhostname", "mydomainname.org", hostconf) {
+ ares_channel channel = nullptr;
+ EXPECT_EQ(ARES_SUCCESS, ares_init(&channel));
+
+ struct ares_options opts;
+ int optmask = 0;
+ ares_save_options(channel, &opts, &optmask);
+ EXPECT_EQ(std::string("bf"), std::string(opts.lookups));
+ ares_destroy_options(&opts);
+
+ ares_destroy(channel);
+ return HasFailure();
+}
+
+NameContentList svcconf = {
+ {"/etc/resolv.conf", "nameserver 1.2.3.4\n"
+ "search first.com second.com\n"},
+ {"/etc/svc.conf", "hosts= bind\n"}};
+CONTAINED_TEST_F(LibraryTest, ContainerSvcConfInit,
+ "myhostname", "mydomainname.org", svcconf) {
+ ares_channel channel = nullptr;
+ EXPECT_EQ(ARES_SUCCESS, ares_init(&channel));
+
+ struct ares_options opts;
+ int optmask = 0;
+ ares_save_options(channel, &opts, &optmask);
+ EXPECT_EQ(std::string("b"), std::string(opts.lookups));
+ ares_destroy_options(&opts);
+
+ ares_destroy(channel);
+ return HasFailure();
+}
+
+// Failures when expected config filenames are inaccessible.
+class MakeUnreadable {
+ public:
+ explicit MakeUnreadable(const std::string& filename)
+ : filename_(filename) {
+ chmod(filename_.c_str(), 0000);
+ }
+ ~MakeUnreadable() { chmod(filename_.c_str(), 0644); }
+ private:
+ std::string filename_;
+};
+
+CONTAINED_TEST_F(LibraryTest, ContainerResolvConfNotReadable,
+ "myhostname", "mydomainname.org", filelist) {
+ ares_channel channel = nullptr;
+ MakeUnreadable hide("/etc/resolv.conf");
+ // Unavailable /etc/resolv.conf falls back to defaults
+ EXPECT_EQ(ARES_SUCCESS, ares_init(&channel));
+ return HasFailure();
+}
+CONTAINED_TEST_F(LibraryTest, ContainerNsswitchConfNotReadable,
+ "myhostname", "mydomainname.org", filelist) {
+ ares_channel channel = nullptr;
+ // Unavailable /etc/nsswitch.conf falls back to defaults.
+ MakeUnreadable hide("/etc/nsswitch.conf");
+ EXPECT_EQ(ARES_SUCCESS, ares_init(&channel));
+
+ struct ares_options opts;
+ int optmask = 0;
+ ares_save_options(channel, &opts, &optmask);
+ EXPECT_EQ(std::string("fb"), std::string(opts.lookups));
+ ares_destroy_options(&opts);
+
+ ares_destroy(channel);
+ return HasFailure();
+}
+CONTAINED_TEST_F(LibraryTest, ContainerHostConfNotReadable,
+ "myhostname", "mydomainname.org", hostconf) {
+ ares_channel channel = nullptr;
+ // Unavailable /etc/host.conf falls back to defaults.
+ MakeUnreadable hide("/etc/host.conf");
+ EXPECT_EQ(ARES_SUCCESS, ares_init(&channel));
+ ares_destroy(channel);
+ return HasFailure();
+}
+CONTAINED_TEST_F(LibraryTest, ContainerSvcConfNotReadable,
+ "myhostname", "mydomainname.org", svcconf) {
+ ares_channel channel = nullptr;
+ // Unavailable /etc/svc.conf falls back to defaults.
+ MakeUnreadable hide("/etc/svc.conf");
+ EXPECT_EQ(ARES_SUCCESS, ares_init(&channel));
+ ares_destroy(channel);
+ return HasFailure();
+}
+
+NameContentList rotateenv = {
+ {"/etc/resolv.conf", "nameserver 1.2.3.4\n"
+ "search first.com second.com\n"
+ "options rotate\n"}};
+CONTAINED_TEST_F(LibraryTest, ContainerRotateInit,
+ "myhostname", "mydomainname.org", rotateenv) {
+ ares_channel channel = nullptr;
+ EXPECT_EQ(ARES_SUCCESS, ares_init(&channel));
+
+ struct ares_options opts;
+ int optmask = 0;
+ ares_save_options(channel, &opts, &optmask);
+ EXPECT_EQ(ARES_OPT_ROTATE, (optmask & ARES_OPT_ROTATE));
+ ares_destroy_options(&opts);
+
+ ares_destroy(channel);
+ return HasFailure();
+}
+
+CONTAINED_TEST_F(LibraryTest, ContainerRotateOverride,
+ "myhostname", "mydomainname.org", rotateenv) {
+ ares_channel channel = nullptr;
+ struct ares_options opts = {0};
+ int optmask = ARES_OPT_NOROTATE;
+ EXPECT_EQ(ARES_SUCCESS, ares_init_options(&channel, &opts, optmask));
+
+ optmask = 0;
+ ares_save_options(channel, &opts, &optmask);
+ EXPECT_EQ(ARES_OPT_NOROTATE, (optmask & ARES_OPT_NOROTATE));
+ ares_destroy_options(&opts);
+
+ ares_destroy(channel);
+ return HasFailure();
+}
+
+NameContentList multiresolv = {
+ {"/etc/resolv.conf", " nameserver 1::2 ; ;;\n"
+ " domain first.com\n"},
+ {"/etc/nsswitch.conf", "hosts: files\n"}};
+CONTAINED_TEST_F(LibraryTest, ContainerMultiResolvInit,
+ "myhostname", "mydomainname.org", multiresolv) {
+ ares_channel channel = nullptr;
+ EXPECT_EQ(ARES_SUCCESS, ares_init(&channel));
+ std::vector<std::string> actual = GetNameServers(channel);
+ std::vector<std::string> expected = {"0001:0000:0000:0000:0000:0000:0000:0002"};
+ EXPECT_EQ(expected, actual);
+
+ struct ares_options opts;
+ int optmask = 0;
+ ares_save_options(channel, &opts, &optmask);
+ EXPECT_EQ(1, opts.ndomains);
+ EXPECT_EQ(std::string("first.com"), std::string(opts.domains[0]));
+ ares_destroy_options(&opts);
+
+ ares_destroy(channel);
+ return HasFailure();
+}
+
+NameContentList systemdresolv = {
+ {"/etc/resolv.conf", "nameserver 1.2.3.4\n"
+ "domain first.com\n"},
+ {"/etc/nsswitch.conf", "hosts: junk resolve files\n"}};
+CONTAINED_TEST_F(LibraryTest, ContainerSystemdResolvInit,
+ "myhostname", "mydomainname.org", systemdresolv) {
+ ares_channel channel = nullptr;
+ EXPECT_EQ(ARES_SUCCESS, ares_init(&channel));
+
+ struct ares_options opts;
+ int optmask = 0;
+ ares_save_options(channel, &opts, &optmask);
+ EXPECT_EQ(std::string("bf"), std::string(opts.lookups));
+ ares_destroy_options(&opts);
+
+ ares_destroy(channel);
+ return HasFailure();
+}
+
+NameContentList empty = {}; // no files
+CONTAINED_TEST_F(LibraryTest, ContainerEmptyInit,
+ "host.domain.org", "domain.org", empty) {
+ ares_channel channel = nullptr;
+ EXPECT_EQ(ARES_SUCCESS, ares_init(&channel));
+ std::vector<std::string> actual = GetNameServers(channel);
+ std::vector<std::string> expected = {"127.0.0.1"};
+ EXPECT_EQ(expected, actual);
+
+ struct ares_options opts;
+ int optmask = 0;
+ ares_save_options(channel, &opts, &optmask);
+ EXPECT_EQ(1, opts.ndomains);
+ EXPECT_EQ(std::string("domain.org"), std::string(opts.domains[0]));
+ EXPECT_EQ(std::string("fb"), std::string(opts.lookups));
+ ares_destroy_options(&opts);
+
+
+ ares_destroy(channel);
+ return HasFailure();
+}
+
+#endif
+
+} // namespace test
+} // namespace ares
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-06 05:16:55 +0000