ares-test.cc 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839
  1. #include "ares_setup.h"
  2. #include "ares.h"
  3. #include "ares_nameser.h"
  4. #include "ares-test.h"
  5. #include "ares-test-ai.h"
  6. #include "dns-proto.h"
  7. // Include ares internal files for DNS protocol details
  8. #include "ares_dns.h"
  9. #ifdef HAVE_NETDB_H
  10. #include <netdb.h>
  11. #endif
  12. #ifdef HAVE_NETINET_TCP_H
  13. #include <netinet/tcp.h>
  14. #endif
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <functional>
  18. #include <sstream>
  19. #ifdef WIN32
  20. #define BYTE_CAST (char *)
  21. #define mkdir_(d, p) mkdir(d)
  22. #else
  23. #define BYTE_CAST
  24. #define mkdir_(d, p) mkdir(d, p)
  25. #endif
  26. namespace ares {
  27. namespace test {
  28. bool verbose = false;
  29. static constexpr int dynamic_port = 0;
  30. int mock_port = dynamic_port;
  31. const std::vector<int> both_families = {AF_INET, AF_INET6};
  32. const std::vector<int> ipv4_family = {AF_INET};
  33. const std::vector<int> ipv6_family = {AF_INET6};
  34. const std::vector<std::pair<int, bool>> both_families_both_modes = {
  35. std::make_pair<int, bool>(AF_INET, false),
  36. std::make_pair<int, bool>(AF_INET, true),
  37. std::make_pair<int, bool>(AF_INET6, false),
  38. std::make_pair<int, bool>(AF_INET6, true)
  39. };
  40. const std::vector<std::pair<int, bool>> ipv4_family_both_modes = {
  41. std::make_pair<int, bool>(AF_INET, false),
  42. std::make_pair<int, bool>(AF_INET, true)
  43. };
  44. const std::vector<std::pair<int, bool>> ipv6_family_both_modes = {
  45. std::make_pair<int, bool>(AF_INET6, false),
  46. std::make_pair<int, bool>(AF_INET6, true)
  47. };
  48. // Which parameters to use in tests
  49. std::vector<int> families = both_families;
  50. std::vector<std::pair<int, bool>> families_modes = both_families_both_modes;
  51. unsigned long long LibraryTest::fails_ = 0;
  52. std::map<size_t, int> LibraryTest::size_fails_;
  53. void ProcessWork(ares_channel channel,
  54. std::function<std::set<int>()> get_extrafds,
  55. std::function<void(int)> process_extra) {
  56. int nfds, count;
  57. fd_set readers, writers;
  58. struct timeval tv;
  59. while (true) {
  60. // Retrieve the set of file descriptors that the library wants us to monitor.
  61. FD_ZERO(&readers);
  62. FD_ZERO(&writers);
  63. nfds = ares_fds(channel, &readers, &writers);
  64. if (nfds == 0) // no work left to do in the library
  65. return;
  66. // Add in the extra FDs if present.
  67. std::set<int> extrafds = get_extrafds();
  68. for (int extrafd : extrafds) {
  69. FD_SET(extrafd, &readers);
  70. if (extrafd >= nfds) {
  71. nfds = extrafd + 1;
  72. }
  73. }
  74. // Wait for activity or timeout.
  75. tv.tv_sec = 0;
  76. tv.tv_usec = 100000; // 100ms
  77. count = select(nfds, &readers, &writers, nullptr, &tv);
  78. if (count < 0) {
  79. fprintf(stderr, "select() failed, errno %d\n", errno);
  80. return;
  81. }
  82. // Let the library process any activity.
  83. ares_process(channel, &readers, &writers);
  84. // Let the provided callback process any activity on the extra FD.
  85. for (int extrafd : extrafds) {
  86. if (FD_ISSET(extrafd, &readers)) {
  87. process_extra(extrafd);
  88. }
  89. }
  90. }
  91. }
  92. // static
  93. void LibraryTest::SetAllocFail(int nth) {
  94. assert(nth > 0);
  95. assert(nth <= (int)(8 * sizeof(fails_)));
  96. fails_ |= (1LL << (nth - 1));
  97. }
  98. // static
  99. void LibraryTest::SetAllocSizeFail(size_t size) {
  100. size_fails_[size]++;
  101. }
  102. // static
  103. void LibraryTest::ClearFails() {
  104. fails_ = 0;
  105. size_fails_.clear();
  106. }
  107. // static
  108. bool LibraryTest::ShouldAllocFail(size_t size) {
  109. bool fail = (fails_ & 0x01);
  110. fails_ >>= 1;
  111. if (size_fails_[size] > 0) {
  112. size_fails_[size]--;
  113. fail = true;
  114. }
  115. return fail;
  116. }
  117. // static
  118. void* LibraryTest::amalloc(size_t size) {
  119. if (ShouldAllocFail(size) || size == 0) {
  120. if (verbose) std::cerr << "Failing malloc(" << size << ") request" << std::endl;
  121. return nullptr;
  122. } else {
  123. return malloc(size);
  124. }
  125. }
  126. // static
  127. void* LibraryTest::arealloc(void *ptr, size_t size) {
  128. if (ShouldAllocFail(size)) {
  129. if (verbose) std::cerr << "Failing realloc(" << ptr << ", " << size << ") request" << std::endl;
  130. return nullptr;
  131. } else {
  132. return realloc(ptr, size);
  133. }
  134. }
  135. // static
  136. void LibraryTest::afree(void *ptr) {
  137. free(ptr);
  138. }
  139. std::set<int> NoExtraFDs() {
  140. return std::set<int>();
  141. }
  142. void DefaultChannelTest::Process() {
  143. ProcessWork(channel_, NoExtraFDs, nullptr);
  144. }
  145. void DefaultChannelModeTest::Process() {
  146. ProcessWork(channel_, NoExtraFDs, nullptr);
  147. }
  148. MockServer::MockServer(int family, int port)
  149. : udpport_(port), tcpport_(port), qid_(-1) {
  150. // Create a TCP socket to receive data on.
  151. tcpfd_ = socket(family, SOCK_STREAM, 0);
  152. EXPECT_NE(-1, tcpfd_);
  153. int optval = 1;
  154. setsockopt(tcpfd_, SOL_SOCKET, SO_REUSEADDR,
  155. BYTE_CAST &optval , sizeof(int));
  156. // Send TCP data right away.
  157. setsockopt(tcpfd_, IPPROTO_TCP, TCP_NODELAY,
  158. BYTE_CAST &optval , sizeof(int));
  159. // Create a UDP socket to receive data on.
  160. udpfd_ = socket(family, SOCK_DGRAM, 0);
  161. EXPECT_NE(-1, udpfd_);
  162. // Bind the sockets to the given port.
  163. if (family == AF_INET) {
  164. struct sockaddr_in addr;
  165. memset(&addr, 0, sizeof(addr));
  166. addr.sin_family = AF_INET;
  167. addr.sin_addr.s_addr = htonl(INADDR_ANY);
  168. addr.sin_port = htons(tcpport_);
  169. int tcprc = bind(tcpfd_, (struct sockaddr*)&addr, sizeof(addr));
  170. EXPECT_EQ(0, tcprc) << "Failed to bind AF_INET to TCP port " << tcpport_;
  171. addr.sin_port = htons(udpport_);
  172. int udprc = bind(udpfd_, (struct sockaddr*)&addr, sizeof(addr));
  173. EXPECT_EQ(0, udprc) << "Failed to bind AF_INET to UDP port " << udpport_;
  174. // retrieve system-assigned port
  175. if (udpport_ == dynamic_port) {
  176. ares_socklen_t len = sizeof(addr);
  177. auto result = getsockname(udpfd_, (struct sockaddr*)&addr, &len);
  178. EXPECT_EQ(0, result);
  179. udpport_ = ntohs(addr.sin_port);
  180. EXPECT_NE(dynamic_port, udpport_);
  181. }
  182. if (tcpport_ == dynamic_port) {
  183. ares_socklen_t len = sizeof(addr);
  184. auto result = getsockname(tcpfd_, (struct sockaddr*)&addr, &len);
  185. EXPECT_EQ(0, result);
  186. tcpport_ = ntohs(addr.sin_port);
  187. EXPECT_NE(dynamic_port, tcpport_);
  188. }
  189. } else {
  190. EXPECT_EQ(AF_INET6, family);
  191. struct sockaddr_in6 addr;
  192. memset(&addr, 0, sizeof(addr));
  193. addr.sin6_family = AF_INET6;
  194. memset(&addr.sin6_addr, 0, sizeof(addr.sin6_addr)); // in6addr_any
  195. addr.sin6_port = htons(tcpport_);
  196. int tcprc = bind(tcpfd_, (struct sockaddr*)&addr, sizeof(addr));
  197. EXPECT_EQ(0, tcprc) << "Failed to bind AF_INET6 to TCP port " << tcpport_;
  198. addr.sin6_port = htons(udpport_);
  199. int udprc = bind(udpfd_, (struct sockaddr*)&addr, sizeof(addr));
  200. EXPECT_EQ(0, udprc) << "Failed to bind AF_INET6 to UDP port " << udpport_;
  201. // retrieve system-assigned port
  202. if (udpport_ == dynamic_port) {
  203. ares_socklen_t len = sizeof(addr);
  204. auto result = getsockname(udpfd_, (struct sockaddr*)&addr, &len);
  205. EXPECT_EQ(0, result);
  206. udpport_ = ntohs(addr.sin6_port);
  207. EXPECT_NE(dynamic_port, udpport_);
  208. }
  209. if (tcpport_ == dynamic_port) {
  210. ares_socklen_t len = sizeof(addr);
  211. auto result = getsockname(tcpfd_, (struct sockaddr*)&addr, &len);
  212. EXPECT_EQ(0, result);
  213. tcpport_ = ntohs(addr.sin6_port);
  214. EXPECT_NE(dynamic_port, tcpport_);
  215. }
  216. }
  217. if (verbose) std::cerr << "Configured "
  218. << (family == AF_INET ? "IPv4" : "IPv6")
  219. << " mock server with TCP socket " << tcpfd_
  220. << " on port " << tcpport_
  221. << " and UDP socket " << udpfd_
  222. << " on port " << udpport_ << std::endl;
  223. // For TCP, also need to listen for connections.
  224. EXPECT_EQ(0, listen(tcpfd_, 5)) << "Failed to listen for TCP connections";
  225. }
  226. MockServer::~MockServer() {
  227. for (int fd : connfds_) {
  228. sclose(fd);
  229. }
  230. sclose(tcpfd_);
  231. sclose(udpfd_);
  232. }
  233. void MockServer::ProcessPacket(int fd, struct sockaddr_storage *addr, socklen_t addrlen,
  234. byte *data, int len) {
  235. // Assume the packet is a well-formed DNS request and extract the request
  236. // details.
  237. if (len < NS_HFIXEDSZ) {
  238. std::cerr << "Packet too short (" << len << ")" << std::endl;
  239. return;
  240. }
  241. int qid = DNS_HEADER_QID(data);
  242. if (DNS_HEADER_QR(data) != 0) {
  243. std::cerr << "Not a request" << std::endl;
  244. return;
  245. }
  246. if (DNS_HEADER_OPCODE(data) != O_QUERY) {
  247. std::cerr << "Not a query (opcode " << DNS_HEADER_OPCODE(data)
  248. << ")" << std::endl;
  249. return;
  250. }
  251. if (DNS_HEADER_QDCOUNT(data) != 1) {
  252. std::cerr << "Unexpected question count (" << DNS_HEADER_QDCOUNT(data)
  253. << ")" << std::endl;
  254. return;
  255. }
  256. byte* question = data + 12;
  257. int qlen = len - 12;
  258. char *name = nullptr;
  259. long enclen;
  260. ares_expand_name(question, data, len, &name, &enclen);
  261. if (!name) {
  262. std::cerr << "Failed to retrieve name" << std::endl;
  263. return;
  264. }
  265. qlen -= enclen;
  266. question += enclen;
  267. std::string namestr(name);
  268. ares_free_string(name);
  269. if (qlen < 4) {
  270. std::cerr << "Unexpected question size (" << qlen
  271. << " bytes after name)" << std::endl;
  272. return;
  273. }
  274. if (DNS_QUESTION_CLASS(question) != C_IN) {
  275. std::cerr << "Unexpected question class (" << DNS_QUESTION_CLASS(question)
  276. << ")" << std::endl;
  277. return;
  278. }
  279. int rrtype = DNS_QUESTION_TYPE(question);
  280. if (verbose) {
  281. std::vector<byte> req(data, data + len);
  282. std::cerr << "received " << (fd == udpfd_ ? "UDP" : "TCP") << " request " << PacketToString(req)
  283. << " on port " << (fd == udpfd_ ? udpport_ : tcpport_) << std::endl;
  284. std::cerr << "ProcessRequest(" << qid << ", '" << namestr
  285. << "', " << RRTypeToString(rrtype) << ")" << std::endl;
  286. }
  287. ProcessRequest(fd, addr, addrlen, qid, namestr, rrtype);
  288. }
  289. void MockServer::ProcessFD(int fd) {
  290. if (fd != tcpfd_ && fd != udpfd_ && connfds_.find(fd) == connfds_.end()) {
  291. // Not one of our FDs.
  292. return;
  293. }
  294. if (fd == tcpfd_) {
  295. int connfd = accept(tcpfd_, NULL, NULL);
  296. if (connfd < 0) {
  297. std::cerr << "Error accepting connection on fd " << fd << std::endl;
  298. } else {
  299. connfds_.insert(connfd);
  300. }
  301. return;
  302. }
  303. // Activity on a data-bearing file descriptor.
  304. struct sockaddr_storage addr;
  305. socklen_t addrlen = sizeof(addr);
  306. byte buffer[2048];
  307. int len = recvfrom(fd, BYTE_CAST buffer, sizeof(buffer), 0,
  308. (struct sockaddr *)&addr, &addrlen);
  309. byte* data = buffer;
  310. if (fd != udpfd_) {
  311. if (len == 0) {
  312. connfds_.erase(std::find(connfds_.begin(), connfds_.end(), fd));
  313. sclose(fd);
  314. return;
  315. }
  316. if (len < 2) {
  317. std::cerr << "Packet too short (" << len << ")" << std::endl;
  318. return;
  319. }
  320. /* TCP might aggregate the various requests into a single packet, so we
  321. * need to split */
  322. while (len) {
  323. int tcplen = (data[0] << 8) + data[1];
  324. data += 2;
  325. len -= 2;
  326. if (tcplen > len) {
  327. std::cerr << "Warning: TCP length " << tcplen
  328. << " doesn't match remaining data length " << len << std::endl;
  329. }
  330. int process_len = (tcplen > len)?len:tcplen;
  331. ProcessPacket(fd, &addr, addrlen, data, process_len);
  332. len -= process_len;
  333. data += process_len;
  334. }
  335. } else {
  336. /* UDP is always a single packet */
  337. ProcessPacket(fd, &addr, addrlen, data, len);
  338. }
  339. }
  340. std::set<int> MockServer::fds() const {
  341. std::set<int> result = connfds_;
  342. result.insert(tcpfd_);
  343. result.insert(udpfd_);
  344. return result;
  345. }
  346. void MockServer::ProcessRequest(int fd, struct sockaddr_storage* addr, int addrlen,
  347. int qid, const std::string& name, int rrtype) {
  348. // Before processing, let gMock know the request is happening.
  349. OnRequest(name, rrtype);
  350. if (reply_.size() == 0) {
  351. return;
  352. }
  353. // Make a local copy of the current pending reply.
  354. std::vector<byte> reply = reply_;
  355. if (qid_ >= 0) {
  356. // Use the explicitly specified query ID.
  357. qid = qid_;
  358. }
  359. if (reply.size() >= 2) {
  360. // Overwrite the query ID if space to do so.
  361. reply[0] = (byte)((qid >> 8) & 0xff);
  362. reply[1] = (byte)(qid & 0xff);
  363. }
  364. if (verbose) std::cerr << "sending reply " << PacketToString(reply)
  365. << " on port " << ((fd == udpfd_) ? udpport_ : tcpport_) << std::endl;
  366. // Prefix with 2-byte length if TCP.
  367. if (fd != udpfd_) {
  368. int len = reply.size();
  369. std::vector<byte> vlen = {(byte)((len & 0xFF00) >> 8), (byte)(len & 0xFF)};
  370. reply.insert(reply.begin(), vlen.begin(), vlen.end());
  371. // Also, don't bother with the destination address.
  372. addr = nullptr;
  373. addrlen = 0;
  374. }
  375. int rc = sendto(fd, BYTE_CAST reply.data(), reply.size(), 0,
  376. (struct sockaddr *)addr, addrlen);
  377. if (rc < static_cast<int>(reply.size())) {
  378. std::cerr << "Failed to send full reply, rc=" << rc << std::endl;
  379. }
  380. }
  381. // static
  382. MockChannelOptsTest::NiceMockServers MockChannelOptsTest::BuildServers(int count, int family, int base_port) {
  383. NiceMockServers servers;
  384. assert(count > 0);
  385. for (int ii = 0; ii < count; ii++) {
  386. int port = base_port == dynamic_port ? dynamic_port : base_port + ii;
  387. std::unique_ptr<NiceMockServer> server(new NiceMockServer(family, port));
  388. servers.push_back(std::move(server));
  389. }
  390. return servers;
  391. }
  392. MockChannelOptsTest::MockChannelOptsTest(int count,
  393. int family,
  394. bool force_tcp,
  395. struct ares_options* givenopts,
  396. int optmask)
  397. : servers_(BuildServers(count, family, mock_port)),
  398. server_(*servers_[0].get()), channel_(nullptr) {
  399. // Set up channel options.
  400. struct ares_options opts;
  401. if (givenopts) {
  402. memcpy(&opts, givenopts, sizeof(opts));
  403. } else {
  404. memset(&opts, 0, sizeof(opts));
  405. }
  406. // Point the library at the first mock server by default (overridden below).
  407. opts.udp_port = server_.udpport();
  408. optmask |= ARES_OPT_UDP_PORT;
  409. opts.tcp_port = server_.tcpport();
  410. optmask |= ARES_OPT_TCP_PORT;
  411. // If not already overridden, set short-ish timeouts.
  412. if (!(optmask & (ARES_OPT_TIMEOUTMS|ARES_OPT_TIMEOUT))) {
  413. opts.timeout = 1500;
  414. optmask |= ARES_OPT_TIMEOUTMS;
  415. }
  416. // If not already overridden, set 3 retries.
  417. if (!(optmask & ARES_OPT_TRIES)) {
  418. opts.tries = 3;
  419. optmask |= ARES_OPT_TRIES;
  420. }
  421. // If not already overridden, set search domains.
  422. const char *domains[3] = {"first.com", "second.org", "third.gov"};
  423. if (!(optmask & ARES_OPT_DOMAINS)) {
  424. opts.ndomains = 3;
  425. opts.domains = (char**)domains;
  426. optmask |= ARES_OPT_DOMAINS;
  427. }
  428. if (force_tcp) {
  429. opts.flags |= ARES_FLAG_USEVC;
  430. optmask |= ARES_OPT_FLAGS;
  431. }
  432. EXPECT_EQ(ARES_SUCCESS, ares_init_options(&channel_, &opts, optmask));
  433. EXPECT_NE(nullptr, channel_);
  434. // Set up servers after construction so we can set individual ports
  435. struct ares_addr_port_node* prev = nullptr;
  436. struct ares_addr_port_node* first = nullptr;
  437. for (const auto& server : servers_) {
  438. struct ares_addr_port_node* node = (struct ares_addr_port_node*)malloc(sizeof(*node));
  439. if (prev) {
  440. prev->next = node;
  441. } else {
  442. first = node;
  443. }
  444. node->next = nullptr;
  445. node->family = family;
  446. node->udp_port = server->udpport();
  447. node->tcp_port = server->tcpport();
  448. if (family == AF_INET) {
  449. node->addr.addr4.s_addr = htonl(0x7F000001);
  450. } else {
  451. memset(&node->addr.addr6, 0, sizeof(node->addr.addr6));
  452. node->addr.addr6._S6_un._S6_u8[15] = 1;
  453. }
  454. prev = node;
  455. }
  456. EXPECT_EQ(ARES_SUCCESS, ares_set_servers_ports(channel_, first));
  457. while (first) {
  458. prev = first;
  459. first = first->next;
  460. free(prev);
  461. }
  462. if (verbose) {
  463. std::cerr << "Configured library with servers:";
  464. std::vector<std::string> servers = GetNameServers(channel_);
  465. for (const auto& server : servers) {
  466. std::cerr << " " << server;
  467. }
  468. std::cerr << std::endl;
  469. }
  470. }
  471. MockChannelOptsTest::~MockChannelOptsTest() {
  472. if (channel_) {
  473. ares_destroy(channel_);
  474. }
  475. channel_ = nullptr;
  476. }
  477. std::set<int> MockChannelOptsTest::fds() const {
  478. std::set<int> fds;
  479. for (const auto& server : servers_) {
  480. std::set<int> serverfds = server->fds();
  481. fds.insert(serverfds.begin(), serverfds.end());
  482. }
  483. return fds;
  484. }
  485. void MockChannelOptsTest::ProcessFD(int fd) {
  486. for (auto& server : servers_) {
  487. server->ProcessFD(fd);
  488. }
  489. }
  490. void MockChannelOptsTest::Process() {
  491. using namespace std::placeholders;
  492. ProcessWork(channel_,
  493. std::bind(&MockChannelOptsTest::fds, this),
  494. std::bind(&MockChannelOptsTest::ProcessFD, this, _1));
  495. }
  496. std::ostream& operator<<(std::ostream& os, const HostResult& result) {
  497. os << '{';
  498. if (result.done_) {
  499. os << StatusToString(result.status_);
  500. if (result.host_.addrtype_ != -1) {
  501. os << " " << result.host_;
  502. } else {
  503. os << ", (no hostent)";
  504. }
  505. } else {
  506. os << "(incomplete)";
  507. }
  508. os << '}';
  509. return os;
  510. }
  511. HostEnt::HostEnt(const struct hostent *hostent) : addrtype_(-1) {
  512. if (!hostent)
  513. return;
  514. if (hostent->h_name)
  515. name_ = hostent->h_name;
  516. if (hostent->h_aliases) {
  517. char** palias = hostent->h_aliases;
  518. while (*palias != nullptr) {
  519. aliases_.push_back(*palias);
  520. palias++;
  521. }
  522. }
  523. addrtype_ = hostent->h_addrtype;
  524. if (hostent->h_addr_list) {
  525. char** paddr = hostent->h_addr_list;
  526. while (*paddr != nullptr) {
  527. std::string addr = AddressToString(*paddr, hostent->h_length);
  528. addrs_.push_back(addr);
  529. paddr++;
  530. }
  531. }
  532. }
  533. std::ostream& operator<<(std::ostream& os, const HostEnt& host) {
  534. os << "{'";
  535. if (host.name_.length() > 0) {
  536. os << host.name_;
  537. }
  538. os << "' aliases=[";
  539. for (size_t ii = 0; ii < host.aliases_.size(); ii++) {
  540. if (ii > 0) os << ", ";
  541. os << host.aliases_[ii];
  542. }
  543. os << "] ";
  544. os << "addrs=[";
  545. for (size_t ii = 0; ii < host.addrs_.size(); ii++) {
  546. if (ii > 0) os << ", ";
  547. os << host.addrs_[ii];
  548. }
  549. os << "]";
  550. os << '}';
  551. return os;
  552. }
  553. void HostCallback(void *data, int status, int timeouts,
  554. struct hostent *hostent) {
  555. EXPECT_NE(nullptr, data);
  556. if (data == nullptr)
  557. return;
  558. HostResult* result = reinterpret_cast<HostResult*>(data);
  559. result->done_ = true;
  560. result->status_ = status;
  561. result->timeouts_ = timeouts;
  562. if (hostent)
  563. result->host_ = HostEnt(hostent);
  564. if (verbose) std::cerr << "HostCallback(" << *result << ")" << std::endl;
  565. }
  566. std::ostream& operator<<(std::ostream& os, const AddrInfoResult& result) {
  567. os << '{';
  568. if (result.done_ && result.ai_) {
  569. os << StatusToString(result.status_) << " " << result.ai_;
  570. } else {
  571. os << "(incomplete)";
  572. }
  573. os << '}';
  574. return os;
  575. }
  576. std::ostream& operator<<(std::ostream& os, const AddrInfo& ai) {
  577. os << '{';
  578. if (ai == nullptr) {
  579. os << "nullptr}";
  580. return os;
  581. }
  582. struct ares_addrinfo_cname *next_cname = ai->cnames;
  583. while(next_cname) {
  584. if(next_cname->alias) {
  585. os << next_cname->alias << "->";
  586. }
  587. if(next_cname->name) {
  588. os << next_cname->name;
  589. }
  590. if((next_cname = next_cname->next))
  591. os << ", ";
  592. else
  593. os << " ";
  594. }
  595. struct ares_addrinfo_node *next = ai->nodes;
  596. while(next) {
  597. //if(next->ai_canonname) {
  598. //os << "'" << next->ai_canonname << "' ";
  599. //}
  600. unsigned short port = 0;
  601. os << "addr=[";
  602. if(next->ai_family == AF_INET) {
  603. sockaddr_in* sin = (sockaddr_in*)next->ai_addr;
  604. port = ntohs(sin->sin_port);
  605. os << AddressToString(&sin->sin_addr, 4);
  606. }
  607. else if (next->ai_family == AF_INET6) {
  608. sockaddr_in6* sin = (sockaddr_in6*)next->ai_addr;
  609. port = ntohs(sin->sin6_port);
  610. os << "[" << AddressToString(&sin->sin6_addr, 16) << "]";
  611. }
  612. else
  613. os << "unknown family";
  614. if(port) {
  615. os << ":" << port;
  616. }
  617. os << "]";
  618. if((next = next->ai_next))
  619. os << ", ";
  620. }
  621. os << '}';
  622. return os;
  623. }
  624. void AddrInfoCallback(void *data, int status, int timeouts,
  625. struct ares_addrinfo *ai) {
  626. EXPECT_NE(nullptr, data);
  627. AddrInfoResult* result = reinterpret_cast<AddrInfoResult*>(data);
  628. result->done_ = true;
  629. result->status_ = status;
  630. result->timeouts_= timeouts;
  631. result->ai_ = AddrInfo(ai);
  632. if (verbose) std::cerr << "AddrInfoCallback(" << *result << ")" << std::endl;
  633. }
  634. std::ostream& operator<<(std::ostream& os, const SearchResult& result) {
  635. os << '{';
  636. if (result.done_) {
  637. os << StatusToString(result.status_) << " " << PacketToString(result.data_);
  638. } else {
  639. os << "(incomplete)";
  640. }
  641. os << '}';
  642. return os;
  643. }
  644. void SearchCallback(void *data, int status, int timeouts,
  645. unsigned char *abuf, int alen) {
  646. EXPECT_NE(nullptr, data);
  647. SearchResult* result = reinterpret_cast<SearchResult*>(data);
  648. result->done_ = true;
  649. result->status_ = status;
  650. result->timeouts_ = timeouts;
  651. result->data_.assign(abuf, abuf + alen);
  652. if (verbose) std::cerr << "SearchCallback(" << *result << ")" << std::endl;
  653. }
  654. std::ostream& operator<<(std::ostream& os, const NameInfoResult& result) {
  655. os << '{';
  656. if (result.done_) {
  657. os << StatusToString(result.status_) << " " << result.node_ << " " << result.service_;
  658. } else {
  659. os << "(incomplete)";
  660. }
  661. os << '}';
  662. return os;
  663. }
  664. void NameInfoCallback(void *data, int status, int timeouts,
  665. char *node, char *service) {
  666. EXPECT_NE(nullptr, data);
  667. NameInfoResult* result = reinterpret_cast<NameInfoResult*>(data);
  668. result->done_ = true;
  669. result->status_ = status;
  670. result->timeouts_ = timeouts;
  671. result->node_ = std::string(node ? node : "");
  672. result->service_ = std::string(service ? service : "");
  673. if (verbose) std::cerr << "NameInfoCallback(" << *result << ")" << std::endl;
  674. }
  675. std::vector<std::string> GetNameServers(ares_channel channel) {
  676. struct ares_addr_port_node* servers = nullptr;
  677. EXPECT_EQ(ARES_SUCCESS, ares_get_servers_ports(channel, &servers));
  678. struct ares_addr_port_node* server = servers;
  679. std::vector<std::string> results;
  680. while (server) {
  681. std::stringstream ss;
  682. switch (server->family) {
  683. case AF_INET:
  684. ss << AddressToString((char*)&server->addr.addr4, 4);
  685. break;
  686. case AF_INET6:
  687. if (server->udp_port != 0) {
  688. ss << '[';
  689. }
  690. ss << AddressToString((char*)&server->addr.addr6, 16);
  691. if (server->udp_port != 0) {
  692. ss << ']';
  693. }
  694. break;
  695. default:
  696. results.push_back("<unknown family>");
  697. break;
  698. }
  699. if (server->udp_port != 0) {
  700. ss << ":" << server->udp_port;
  701. }
  702. results.push_back(ss.str());
  703. server = server->next;
  704. }
  705. if (servers) ares_free_data(servers);
  706. return results;
  707. }
  708. TransientDir::TransientDir(const std::string& dirname) : dirname_(dirname) {
  709. if (mkdir_(dirname_.c_str(), 0755) != 0) {
  710. std::cerr << "Failed to create subdirectory '" << dirname_ << "'" << std::endl;
  711. }
  712. }
  713. TransientDir::~TransientDir() {
  714. rmdir(dirname_.c_str());
  715. }
  716. TransientFile::TransientFile(const std::string& filename,
  717. const std::string& contents)
  718. : filename_(filename) {
  719. FILE *f = fopen(filename.c_str(), "w");
  720. if (f == nullptr) {
  721. std::cerr << "Error: failed to create '" << filename << "'" << std::endl;
  722. return;
  723. }
  724. int rc = fwrite(contents.data(), 1, contents.size(), f);
  725. if (rc != (int)contents.size()) {
  726. std::cerr << "Error: failed to write contents of '" << filename << "'" << std::endl;
  727. }
  728. fclose(f);
  729. }
  730. TransientFile::~TransientFile() {
  731. unlink(filename_.c_str());
  732. }
  733. std::string TempNam(const char *dir, const char *prefix) {
  734. char *p = tempnam(dir, prefix);
  735. std::string result(p);
  736. free(p);
  737. return result;
  738. }
  739. TempFile::TempFile(const std::string& contents)
  740. : TransientFile(TempNam(nullptr, "ares"), contents) {
  741. }
  742. VirtualizeIO::VirtualizeIO(ares_channel c)
  743. : channel_(c)
  744. {
  745. ares_set_socket_functions(channel_, &default_functions, 0);
  746. }
  747. VirtualizeIO::~VirtualizeIO() {
  748. ares_set_socket_functions(channel_, 0, 0);
  749. }
  750. } // namespace test
  751. } // namespace ares