ares-test-live.cc (27117B)
1 /* MIT License 2 * 3 * Copyright (c) The c-ares project and its contributors 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a copy 6 * of this software and associated documentation files (the "Software"), to deal 7 * in the Software without restriction, including without limitation the rights 8 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 * copies of the Software, and to permit persons to whom the Software is 10 * furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice (including the next 13 * paragraph) shall be included in all copies or substantial portions of the 14 * Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 22 * SOFTWARE. 23 * 24 * SPDX-License-Identifier: MIT 25 */ 26 // This file includes tests that attempt to do real lookups 27 // of DNS names using the local machine's live infrastructure. 28 // As a result, we don't check the results very closely, to allow 29 // for varying local configurations. 30 31 #include "ares-test.h" 32 33 #ifdef HAVE_NETDB_H 34 #include <netdb.h> 35 #endif 36 37 namespace ares { 38 namespace test { 39 40 // Use the address of CloudFlare's public DNS servers as example addresses that are 41 // likely to be accessible everywhere/everywhen. We used to use google but they 42 // stopped returning reverse dns answers in Dec 2023 43 unsigned char cflare_addr4[4] = { 0x01, 0x01, 0x01, 0x01 }; 44 unsigned char cflare_addr6[16] = { 45 0x26, 0x06, 0x47, 0x00, 0x47, 0x00, 0x00, 0x00, 46 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x11 47 }; 48 49 MATCHER_P(IncludesAtLeastNumAddresses, n, "") { 50 if(!arg) 51 return false; 52 int cnt = 0; 53 for (const ares_addrinfo_node* ai = arg->nodes; ai != NULL; ai = ai->ai_next) 54 cnt++; 55 return cnt >= n; 56 } 57 58 MATCHER_P(OnlyIncludesAddrType, addrtype, "") { 59 if(!arg) 60 return false; 61 for (const ares_addrinfo_node* ai = arg->nodes; ai != NULL; ai = ai->ai_next) 62 if (ai->ai_family != addrtype) 63 return false; 64 return true; 65 } 66 67 MATCHER_P(IncludesAddrType, addrtype, "") { 68 if(!arg) 69 return false; 70 for (const ares_addrinfo_node* ai = arg->nodes; ai != NULL; ai = ai->ai_next) 71 if (ai->ai_family == addrtype) 72 return true; 73 return false; 74 } 75 76 //VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetAddrInfoV4) { 77 //struct ares_addrinfo_hints hints = {0, 0, 0, 0}; 78 //hints.ai_family = AF_INET; 79 //AddrInfoResult result; 80 //ares_getaddrinfo(channel_, "www.google.com.", NULL, &hints, AddrInfoCallback, &result); 81 //Process(); 82 //EXPECT_TRUE(result.done_); 83 //EXPECT_EQ(ARES_SUCCESS, result.status_); 84 //EXPECT_THAT(result.ai_, IncludesAtLeastNumAddresses(1)); 85 //EXPECT_THAT(result.ai_, OnlyIncludesAddrType(AF_INET)); 86 //} 87 88 //VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetAddrInfoV6) { 89 //struct ares_addrinfo_hints hints = {0, 0, 0, 0}; 90 //hints.ai_family = AF_INET6; 91 //AddrInfoResult result; 92 //ares_getaddrinfo(channel_, "www.google.com.", NULL, &hints, AddrInfoCallback, &result); 93 //Process(); 94 //EXPECT_TRUE(result.done_); 95 //EXPECT_EQ(ARES_SUCCESS, result.status_); 96 //EXPECT_THAT(result.ai_, IncludesAtLeastNumAddresses(1)); 97 //EXPECT_THAT(result.ai_, OnlyIncludesAddrType(AF_INET6)); 98 //} 99 100 //VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetAddrInfoUnspec) { 101 //struct ares_addrinfo_hints hints = {0, 0, 0, 0}; 102 //hints.ai_family = AF_UNSPEC; 103 //AddrInfoResult result; 104 //ares_getaddrinfo(channel_, "www.google.com.", NULL, &hints, AddrInfoCallback, &result); 105 //Process(); 106 //EXPECT_TRUE(result.done_); 107 //EXPECT_EQ(ARES_SUCCESS, result.status_); 108 //EXPECT_THAT(result.ai_, IncludesAtLeastNumAddresses(2)); 109 //EXPECT_THAT(result.ai_, IncludesAddrType(AF_INET6)); 110 //EXPECT_THAT(result.ai_, IncludesAddrType(AF_INET)); 111 //} 112 113 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetHostByNameV4) { 114 HostResult result; 115 ares_gethostbyname(channel_, "www.google.com.", AF_INET, HostCallback, &result); 116 Process(); 117 EXPECT_TRUE(result.done_); 118 EXPECT_EQ(ARES_SUCCESS, result.status_); 119 EXPECT_LT(0, (int)result.host_.addrs_.size()); 120 EXPECT_EQ(AF_INET, result.host_.addrtype_); 121 } 122 123 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetHostByNameV6) { 124 HostResult result; 125 ares_gethostbyname(channel_, "www.google.com.", AF_INET6, HostCallback, &result); 126 Process(); 127 EXPECT_TRUE(result.done_); 128 EXPECT_EQ(ARES_SUCCESS, result.status_); 129 EXPECT_LT(0, (int)result.host_.addrs_.size()); 130 EXPECT_EQ(AF_INET6, result.host_.addrtype_); 131 } 132 133 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetHostByAddrV4) { 134 HostResult result; 135 ares_gethostbyaddr(channel_, cflare_addr4, sizeof(cflare_addr4), AF_INET, HostCallback, &result); 136 Process(); 137 EXPECT_TRUE(result.done_); 138 EXPECT_EQ(ARES_SUCCESS, result.status_); 139 EXPECT_LT(0, (int)result.host_.addrs_.size()); 140 EXPECT_EQ(AF_INET, result.host_.addrtype_); 141 } 142 143 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetHostByAddrV6) { 144 HostResult result; 145 ares_gethostbyaddr(channel_, cflare_addr6, sizeof(cflare_addr6), AF_INET6, HostCallback, &result); 146 Process(); 147 EXPECT_TRUE(result.done_); 148 EXPECT_EQ(ARES_SUCCESS, result.status_); 149 EXPECT_LT(0, (int)result.host_.addrs_.size()); 150 EXPECT_EQ(AF_INET6, result.host_.addrtype_); 151 } 152 153 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetHostByNameFile) { 154 struct hostent *host = nullptr; 155 156 // Still need a channel even to query /etc/hosts. 157 EXPECT_EQ(ARES_ENOTFOUND, 158 ares_gethostbyname_file(nullptr, "localhost", AF_INET, &host)); 159 160 int rc = ares_gethostbyname_file(channel_, "bogus.mcname", AF_INET, &host); 161 EXPECT_EQ(nullptr, host); 162 EXPECT_EQ(ARES_ENOTFOUND, rc); 163 164 rc = ares_gethostbyname_file(channel_, "localhost", AF_INET, &host); 165 if (rc == ARES_SUCCESS) { 166 EXPECT_NE(nullptr, host); 167 ares_free_hostent(host); 168 } 169 } 170 171 TEST_P(DefaultChannelModeTest, LiveGetLocalhostByNameV4) { 172 HostResult result; 173 ares_gethostbyname(channel_, "localhost", AF_INET, HostCallback, &result); 174 Process(); 175 EXPECT_TRUE(result.done_); 176 if (result.status_ != ARES_ECONNREFUSED) { 177 EXPECT_EQ(ARES_SUCCESS, result.status_); 178 EXPECT_EQ(1, (int)result.host_.addrs_.size()); 179 EXPECT_EQ(AF_INET, result.host_.addrtype_); 180 EXPECT_NE(SIZE_MAX, result.host_.name_.find("localhost")); 181 } 182 } 183 184 TEST_P(DefaultChannelModeTest, LiveGetLocalhostByNameV6) { 185 HostResult result; 186 ares_gethostbyname(channel_, "localhost", AF_INET6, HostCallback, &result); 187 Process(); 188 EXPECT_TRUE(result.done_); 189 if (result.status_ != ARES_ECONNREFUSED) { 190 EXPECT_EQ(ARES_SUCCESS, result.status_); 191 EXPECT_EQ(1, (int)result.host_.addrs_.size()); 192 EXPECT_EQ(AF_INET6, result.host_.addrtype_); 193 std::stringstream ss; 194 ss << HostEnt(result.host_); 195 EXPECT_NE(SIZE_MAX, result.host_.name_.find("localhost")); 196 } 197 } 198 199 TEST_P(DefaultChannelModeTest, LiveGetNonExistLocalhostByNameV4) { 200 HostResult result; 201 ares_gethostbyname(channel_, "idonotexist.localhost", AF_INET, HostCallback, &result); 202 Process(); 203 EXPECT_TRUE(result.done_); 204 if (result.status_ != ARES_ECONNREFUSED) { 205 EXPECT_EQ(ARES_SUCCESS, result.status_); 206 EXPECT_EQ(1, (int)result.host_.addrs_.size()); 207 EXPECT_EQ(AF_INET, result.host_.addrtype_); 208 EXPECT_NE(SIZE_MAX, result.host_.name_.find("idonotexist.localhost")); 209 } 210 } 211 212 TEST_P(DefaultChannelModeTest, LiveGetNonExistLocalhostByNameV6) { 213 HostResult result; 214 ares_gethostbyname(channel_, "idonotexist.localhost", AF_INET6, HostCallback, &result); 215 Process(); 216 EXPECT_TRUE(result.done_); 217 if (result.status_ != ARES_ECONNREFUSED) { 218 EXPECT_EQ(ARES_SUCCESS, result.status_); 219 EXPECT_EQ(1, (int)result.host_.addrs_.size()); 220 EXPECT_EQ(AF_INET6, result.host_.addrtype_); 221 std::stringstream ss; 222 ss << HostEnt(result.host_); 223 EXPECT_NE(SIZE_MAX, result.host_.name_.find("idonotexist.localhost")); 224 } 225 } 226 227 TEST_P(DefaultChannelModeTest, LiveGetLocalhostByNameIPV4) { 228 HostResult result; 229 ares_gethostbyname(channel_, "127.0.0.1", AF_INET, HostCallback, &result); 230 Process(); 231 EXPECT_TRUE(result.done_); 232 EXPECT_EQ(ARES_SUCCESS, result.status_); 233 EXPECT_EQ(1, (int)result.host_.addrs_.size()); 234 EXPECT_EQ(AF_INET, result.host_.addrtype_); 235 std::stringstream ss; 236 ss << HostEnt(result.host_); 237 EXPECT_EQ("{'127.0.0.1' aliases=[] addrs=[127.0.0.1]}", ss.str()); 238 } 239 240 TEST_P(DefaultChannelModeTest, LiveGetLocalhostByNameIPV6) { 241 HostResult result; 242 ares_gethostbyname(channel_, "::1", AF_INET6, HostCallback, &result); 243 Process(); 244 EXPECT_TRUE(result.done_); 245 if (result.status_ != ARES_ENOTFOUND) { 246 EXPECT_EQ(ARES_SUCCESS, result.status_); 247 EXPECT_EQ(1, (int)result.host_.addrs_.size()); 248 EXPECT_EQ(AF_INET6, result.host_.addrtype_); 249 std::stringstream ss; 250 ss << HostEnt(result.host_); 251 EXPECT_EQ("{'::1' aliases=[] addrs=[0000:0000:0000:0000:0000:0000:0000:0001]}", ss.str()); 252 } 253 } 254 255 TEST_P(DefaultChannelModeTest, LiveGetLocalhostFailFamily) { 256 HostResult result; 257 ares_gethostbyname(channel_, "127.0.0.1", AF_INET+AF_INET6, HostCallback, &result); 258 Process(); 259 EXPECT_TRUE(result.done_); 260 EXPECT_EQ(ARES_ENOTIMP, result.status_); 261 } 262 263 TEST_P(DefaultChannelModeTest, LiveGetLocalhostByAddrV4) { 264 HostResult result; 265 struct in_addr addr; 266 addr.s_addr = htonl(INADDR_LOOPBACK); 267 ares_gethostbyaddr(channel_, &addr, sizeof(addr), AF_INET, HostCallback, &result); 268 Process(); 269 EXPECT_TRUE(result.done_); 270 if (result.status_ != ARES_ENOTFOUND) { 271 EXPECT_EQ(ARES_SUCCESS, result.status_); 272 EXPECT_LT(0, (int)result.host_.addrs_.size()); 273 EXPECT_EQ(AF_INET, result.host_.addrtype_); 274 // oddly, travis does not resolve to localhost, but a random hostname starting with travis-job 275 if (result.host_.name_.find("travis-job") == SIZE_MAX) { 276 EXPECT_NE(SIZE_MAX, 277 result.host_.name_.find("localhost")); 278 } 279 } 280 } 281 282 TEST_P(DefaultChannelModeTest, LiveGetLocalhostByAddrV6) { 283 HostResult result; 284 struct in6_addr addr; 285 memset(&addr, 0, sizeof(addr)); 286 addr.s6_addr[15] = 1; // in6addr_loopback 287 ares_gethostbyaddr(channel_, &addr, sizeof(addr), AF_INET6, HostCallback, &result); 288 Process(); 289 EXPECT_TRUE(result.done_); 290 if (result.status_ != ARES_ENOTFOUND) { 291 EXPECT_EQ(ARES_SUCCESS, result.status_); 292 EXPECT_LT(0, (int)result.host_.addrs_.size()); 293 EXPECT_EQ(AF_INET6, result.host_.addrtype_); 294 const std::string& name = result.host_.name_; 295 EXPECT_TRUE(SIZE_MAX != name.find("localhost") || 296 SIZE_MAX != name.find("ip6-loopback")); 297 } 298 } 299 300 TEST_P(DefaultChannelModeTest, LiveGetHostByAddrFailFamily) { 301 HostResult result; 302 unsigned char addr[4] = {8, 8, 8, 8}; 303 ares_gethostbyaddr(channel_, addr, sizeof(addr), AF_INET6+AF_INET, 304 HostCallback, &result); 305 EXPECT_TRUE(result.done_); 306 EXPECT_EQ(ARES_ENOTIMP, result.status_); 307 } 308 309 TEST_P(DefaultChannelModeTest, LiveGetHostByAddrFailAddrSize) { 310 HostResult result; 311 unsigned char addr[4] = {8, 8, 8, 8}; 312 ares_gethostbyaddr(channel_, addr, sizeof(addr) - 1, AF_INET, 313 HostCallback, &result); 314 EXPECT_TRUE(result.done_); 315 EXPECT_EQ(ARES_ENOTIMP, result.status_); 316 } 317 318 TEST_P(DefaultChannelModeTest, LiveGetHostByAddrFailAlloc) { 319 HostResult result; 320 unsigned char addr[4] = {8, 8, 8, 8}; 321 SetAllocFail(1); 322 ares_gethostbyaddr(channel_, addr, sizeof(addr), AF_INET, 323 HostCallback, &result); 324 EXPECT_TRUE(result.done_); 325 EXPECT_EQ(ARES_ENOMEM, result.status_); 326 } 327 328 INSTANTIATE_TEST_SUITE_P(Modes, DefaultChannelModeTest, 329 ::testing::Values("f", "b", "fb", "bf")); 330 331 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveSearchA) { 332 SearchResult result; 333 ares_search(channel_, "www.youtube.com.", C_IN, T_A, 334 SearchCallback, &result); 335 Process(); 336 EXPECT_TRUE(result.done_); 337 EXPECT_EQ(ARES_SUCCESS, result.status_); 338 } 339 340 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveSearchEmptyA) { 341 SearchResult result; 342 ares_search(channel_, "", C_IN, T_A, 343 SearchCallback, &result); 344 Process(); 345 EXPECT_TRUE(result.done_); 346 EXPECT_NE(ARES_SUCCESS, result.status_); 347 } 348 349 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveSearchNS) { 350 SearchResult result; 351 ares_search(channel_, "google.com.", C_IN, T_NS, 352 SearchCallback, &result); 353 Process(); 354 EXPECT_TRUE(result.done_); 355 EXPECT_EQ(ARES_SUCCESS, result.status_); 356 } 357 358 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveSearchMX) { 359 SearchResult result; 360 ares_search(channel_, "google.com.", C_IN, T_MX, 361 SearchCallback, &result); 362 Process(); 363 EXPECT_TRUE(result.done_); 364 EXPECT_EQ(ARES_SUCCESS, result.status_); 365 } 366 367 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveSearchTXT) { 368 SearchResult result; 369 ares_search(channel_, "google.com.", C_IN, T_TXT, 370 SearchCallback, &result); 371 Process(); 372 EXPECT_TRUE(result.done_); 373 EXPECT_EQ(ARES_SUCCESS, result.status_); 374 } 375 376 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveSearchSOA) { 377 SearchResult result; 378 ares_search(channel_, "google.com.", C_IN, T_SOA, 379 SearchCallback, &result); 380 Process(); 381 EXPECT_TRUE(result.done_); 382 EXPECT_EQ(ARES_SUCCESS, result.status_); 383 } 384 385 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveSearchSRV) { 386 SearchResult result; 387 ares_search(channel_, "_imap._tcp.gmail.com.", C_IN, T_SRV, 388 SearchCallback, &result); 389 Process(); 390 EXPECT_TRUE(result.done_); 391 EXPECT_EQ(ARES_SUCCESS, result.status_); 392 } 393 394 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveSearchANY) { 395 SearchResult result; 396 ares_search(channel_, "google.com.", C_IN, T_ANY, 397 SearchCallback, &result); 398 Process(); 399 EXPECT_TRUE(result.done_); 400 EXPECT_EQ(ARES_SUCCESS, result.status_); 401 } 402 403 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetNameInfoV4) { 404 NameInfoResult result; 405 struct sockaddr_in sockaddr; 406 memset(&sockaddr, 0, sizeof(sockaddr)); 407 sockaddr.sin_family = AF_INET; 408 sockaddr.sin_port = htons(53); 409 sockaddr.sin_addr.s_addr = htonl(0x08080808); 410 ares_getnameinfo(channel_, (const struct sockaddr*)&sockaddr, sizeof(sockaddr), 411 ARES_NI_LOOKUPHOST|ARES_NI_LOOKUPSERVICE|ARES_NI_UDP, 412 NameInfoCallback, &result); 413 Process(); 414 EXPECT_TRUE(result.done_); 415 EXPECT_EQ(ARES_SUCCESS, result.status_); 416 if (verbose) std::cerr << "8.8.8.8:53 => " << result.node_ << "/" << result.service_ << std::endl; 417 } 418 419 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetNameInfoV4NoPort) { 420 NameInfoResult result; 421 struct sockaddr_in sockaddr; 422 memset(&sockaddr, 0, sizeof(sockaddr)); 423 sockaddr.sin_family = AF_INET; 424 sockaddr.sin_port = htons(0); 425 sockaddr.sin_addr.s_addr = htonl(0x08080808); 426 ares_getnameinfo(channel_, (const struct sockaddr*)&sockaddr, sizeof(sockaddr), 427 ARES_NI_LOOKUPHOST|ARES_NI_LOOKUPSERVICE|ARES_NI_UDP, 428 NameInfoCallback, &result); 429 Process(); 430 EXPECT_TRUE(result.done_); 431 EXPECT_EQ(ARES_SUCCESS, result.status_); 432 if (verbose) std::cerr << "8.8.8.8:0 => " << result.node_ << "/" << result.service_ << std::endl; 433 } 434 435 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetNameInfoV4UnassignedPort) { 436 NameInfoResult result; 437 struct sockaddr_in sockaddr; 438 memset(&sockaddr, 0, sizeof(sockaddr)); 439 sockaddr.sin_family = AF_INET; 440 sockaddr.sin_port = htons(4); // Unassigned at IANA 441 sockaddr.sin_addr.s_addr = htonl(0x08080808); 442 ares_getnameinfo(channel_, (const struct sockaddr*)&sockaddr, sizeof(sockaddr), 443 ARES_NI_LOOKUPHOST|ARES_NI_LOOKUPSERVICE|ARES_NI_UDP, 444 NameInfoCallback, &result); 445 Process(); 446 EXPECT_TRUE(result.done_); 447 EXPECT_EQ(ARES_SUCCESS, result.status_); 448 if (verbose) std::cerr << "8.8.8.8:4 => " << result.node_ << "/" << result.service_ << std::endl; 449 } 450 451 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetNameInfoV6Both) { 452 NameInfoResult result; 453 struct sockaddr_in6 sockaddr; 454 memset(&sockaddr, 0, sizeof(sockaddr)); 455 sockaddr.sin6_family = AF_INET6; 456 sockaddr.sin6_port = htons(53); 457 memcpy(sockaddr.sin6_addr.s6_addr, cflare_addr6, 16); 458 ares_getnameinfo(channel_, (const struct sockaddr*)&sockaddr, sizeof(sockaddr), 459 ARES_NI_TCP|ARES_NI_LOOKUPHOST|ARES_NI_LOOKUPSERVICE|ARES_NI_NOFQDN, 460 NameInfoCallback, &result); 461 Process(); 462 EXPECT_TRUE(result.done_); 463 EXPECT_EQ(ARES_SUCCESS, result.status_); 464 if (verbose) std::cerr << "[2001:4860:4860::8888]:53 => " << result.node_ << "/" << result.service_ << std::endl; 465 } 466 467 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetNameInfoV6Neither) { 468 NameInfoResult result; 469 struct sockaddr_in6 sockaddr; 470 memset(&sockaddr, 0, sizeof(sockaddr)); 471 sockaddr.sin6_family = AF_INET6; 472 sockaddr.sin6_port = htons(53); 473 memcpy(sockaddr.sin6_addr.s6_addr, cflare_addr6, 16); 474 ares_getnameinfo(channel_, (const struct sockaddr*)&sockaddr, sizeof(sockaddr), 475 ARES_NI_TCP|ARES_NI_NOFQDN, // Neither specified => assume lookup host. 476 NameInfoCallback, &result); 477 Process(); 478 EXPECT_TRUE(result.done_); 479 EXPECT_EQ(ARES_SUCCESS, result.status_); 480 if (verbose) std::cerr << "[2001:4860:4860::8888]:53 => " << result.node_ << "/" << result.service_ << std::endl; 481 } 482 483 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetNameInfoV4Numeric) { 484 NameInfoResult result; 485 struct sockaddr_in sockaddr; 486 memset(&sockaddr, 0, sizeof(sockaddr)); 487 sockaddr.sin_family = AF_INET; 488 sockaddr.sin_port = htons(53); 489 sockaddr.sin_addr.s_addr = htonl(0x08080808); 490 ares_getnameinfo(channel_, (const struct sockaddr*)&sockaddr, sizeof(sockaddr), 491 ARES_NI_LOOKUPHOST|ARES_NI_LOOKUPSERVICE|ARES_NI_TCP|ARES_NI_NUMERICHOST, 492 NameInfoCallback, &result); 493 Process(); 494 EXPECT_TRUE(result.done_); 495 EXPECT_EQ(ARES_SUCCESS, result.status_); 496 EXPECT_EQ("8.8.8.8", result.node_); 497 if (verbose) std::cerr << "8.8.8.8:53 => " << result.node_ << "/" << result.service_ << std::endl; 498 } 499 500 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetNameInfoV6Numeric) { 501 NameInfoResult result; 502 struct sockaddr_in6 sockaddr; 503 memset(&sockaddr, 0, sizeof(sockaddr)); 504 sockaddr.sin6_family = AF_INET6; 505 sockaddr.sin6_port = htons(53); 506 memcpy(sockaddr.sin6_addr.s6_addr, cflare_addr6, 16); 507 ares_getnameinfo(channel_, (const struct sockaddr*)&sockaddr, sizeof(sockaddr), 508 ARES_NI_LOOKUPHOST|ARES_NI_LOOKUPSERVICE|ARES_NI_DCCP|ARES_NI_NUMERICHOST, 509 NameInfoCallback, &result); 510 Process(); 511 EXPECT_TRUE(result.done_); 512 EXPECT_EQ(ARES_SUCCESS, result.status_); 513 EXPECT_EQ("2606:4700:4700::1111%0", result.node_); 514 if (verbose) std::cerr << "[2606:4700:4700::1111]:53 => " << result.node_ << "/" << result.service_ << std::endl; 515 } 516 517 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetNameInfoV6LinkLocal) { 518 NameInfoResult result; 519 struct sockaddr_in6 sockaddr; 520 memset(&sockaddr, 0, sizeof(sockaddr)); 521 sockaddr.sin6_family = AF_INET6; 522 sockaddr.sin6_port = htons(53); 523 unsigned char addr6[16] = {0xfe, 0x80, 0x01, 0x02, 0x01, 0x02, 0x00, 0x00, 524 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x04}; 525 memcpy(sockaddr.sin6_addr.s6_addr, addr6, 16); 526 ares_getnameinfo(channel_, (const struct sockaddr*)&sockaddr, sizeof(sockaddr), 527 ARES_NI_LOOKUPHOST|ARES_NI_LOOKUPSERVICE|ARES_NI_DCCP|ARES_NI_NUMERICHOST, 528 NameInfoCallback, &result); 529 Process(); 530 EXPECT_TRUE(result.done_); 531 EXPECT_EQ(ARES_SUCCESS, result.status_); 532 EXPECT_EQ("fe80:102:102::304%0", result.node_); 533 if (verbose) std::cerr << "[fe80:102:102::304]:53 => " << result.node_ << "/" << result.service_ << std::endl; 534 } 535 536 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetNameInfoV4NotFound) { 537 NameInfoResult result; 538 struct sockaddr_in sockaddr; 539 memset(&sockaddr, 0, sizeof(sockaddr)); 540 sockaddr.sin_family = AF_INET; 541 sockaddr.sin_port = htons(4); // Port 4 unassigned at IANA 542 // RFC5737 says 192.0.2.0 should not be used publicly. 543 sockaddr.sin_addr.s_addr = htonl(0xC0000200); 544 ares_getnameinfo(channel_, (const struct sockaddr*)&sockaddr, sizeof(sockaddr), 545 ARES_NI_LOOKUPHOST|ARES_NI_LOOKUPSERVICE|ARES_NI_UDP, 546 NameInfoCallback, &result); 547 Process(); 548 EXPECT_TRUE(result.done_); 549 EXPECT_EQ(ARES_SUCCESS, result.status_); 550 EXPECT_EQ("192.0.2.0", result.node_); 551 if (verbose) std::cerr << "192.0.2.0:53 => " << result.node_ << "/" << result.service_ << std::endl; 552 } 553 554 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetNameInfoV4NotFoundFail) { 555 NameInfoResult result; 556 struct sockaddr_in sockaddr; 557 memset(&sockaddr, 0, sizeof(sockaddr)); 558 sockaddr.sin_family = AF_INET; 559 sockaddr.sin_port = htons(53); 560 // RFC5737 says 192.0.2.0 should not be used publicly. 561 sockaddr.sin_addr.s_addr = htonl(0xC0000200); 562 ares_getnameinfo(channel_, (const struct sockaddr*)&sockaddr, sizeof(sockaddr), 563 ARES_NI_LOOKUPHOST|ARES_NI_LOOKUPSERVICE|ARES_NI_UDP|ARES_NI_NAMEREQD, 564 NameInfoCallback, &result); 565 Process(); 566 EXPECT_TRUE(result.done_); 567 EXPECT_EQ(ARES_ENOTFOUND, result.status_); 568 } 569 570 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetNameInfoV6NotFound) { 571 NameInfoResult result; 572 struct sockaddr_in6 sockaddr; 573 memset(&sockaddr, 0, sizeof(sockaddr)); 574 sockaddr.sin6_family = AF_INET6; 575 sockaddr.sin6_port = htons(53); 576 // 2001:db8::/32 is only supposed to be used in documentation. 577 unsigned char addr6[16] = {0x20, 0x01, 0x0d, 0xb8, 0x01, 0x02, 0x00, 0x00, 578 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x04}; 579 memcpy(sockaddr.sin6_addr.s6_addr, addr6, 16); 580 ares_getnameinfo(channel_, (const struct sockaddr*)&sockaddr, sizeof(sockaddr), 581 ARES_NI_LOOKUPHOST|ARES_NI_LOOKUPSERVICE|ARES_NI_UDP, 582 NameInfoCallback, &result); 583 Process(); 584 EXPECT_TRUE(result.done_); 585 EXPECT_EQ(ARES_SUCCESS, result.status_); 586 EXPECT_EQ("2001:db8:102::304%0", result.node_); 587 if (verbose) std::cerr << "[2001:db8:102::304]:53 => " << result.node_ << "/" << result.service_ << std::endl; 588 } 589 590 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetNameInvalidFamily) { 591 NameInfoResult result; 592 struct sockaddr_in6 sockaddr; 593 memset(&sockaddr, 0, sizeof(sockaddr)); 594 sockaddr.sin6_family = AF_INET6 + AF_INET; 595 sockaddr.sin6_port = htons(53); 596 memcpy(sockaddr.sin6_addr.s6_addr, cflare_addr6, 16); 597 ares_getnameinfo(channel_, (const struct sockaddr*)&sockaddr, sizeof(sockaddr), 598 ARES_NI_LOOKUPHOST|ARES_NI_LOOKUPSERVICE|ARES_NI_UDP, 599 NameInfoCallback, &result); 600 Process(); 601 EXPECT_TRUE(result.done_); 602 EXPECT_EQ(ARES_ENOTIMP, result.status_); 603 } 604 605 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetNameInvalidFlags) { 606 NameInfoResult result; 607 struct sockaddr_in6 sockaddr; 608 memset(&sockaddr, 0, sizeof(sockaddr)); 609 sockaddr.sin6_family = AF_INET6; 610 sockaddr.sin6_port = htons(53); 611 memcpy(sockaddr.sin6_addr.s6_addr, cflare_addr6, 16); 612 // Ask for both a name-required, and a numeric host. 613 ares_getnameinfo(channel_, (const struct sockaddr*)&sockaddr, sizeof(sockaddr), 614 ARES_NI_LOOKUPHOST|ARES_NI_LOOKUPSERVICE|ARES_NI_UDP|ARES_NI_NUMERICHOST|ARES_NI_NAMEREQD, 615 NameInfoCallback, &result); 616 Process(); 617 EXPECT_TRUE(result.done_); 618 EXPECT_EQ(ARES_EBADFLAGS, result.status_); 619 } 620 621 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetServiceInfo) { 622 NameInfoResult result; 623 struct sockaddr_in sockaddr; 624 memset(&sockaddr, 0, sizeof(sockaddr)); 625 sockaddr.sin_family = AF_INET; 626 sockaddr.sin_port = htons(53); 627 sockaddr.sin_addr.s_addr = htonl(0x08080808); 628 // Just look up service info 629 ares_getnameinfo(channel_, (const struct sockaddr*)&sockaddr, sizeof(sockaddr), 630 ARES_NI_LOOKUPSERVICE|ARES_NI_SCTP, 631 NameInfoCallback, &result); 632 Process(); 633 EXPECT_TRUE(result.done_); 634 EXPECT_EQ(ARES_SUCCESS, result.status_); 635 EXPECT_EQ("", result.node_); 636 } 637 638 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetServiceInfoNumeric) { 639 NameInfoResult result; 640 struct sockaddr_in sockaddr; 641 memset(&sockaddr, 0, sizeof(sockaddr)); 642 sockaddr.sin_family = AF_INET; 643 sockaddr.sin_port = htons(53); 644 sockaddr.sin_addr.s_addr = htonl(0x08080808); 645 // Just look up service info 646 ares_getnameinfo(channel_, (const struct sockaddr*)&sockaddr, sizeof(sockaddr), 647 ARES_NI_LOOKUPSERVICE|ARES_NI_SCTP|ARES_NI_NUMERICSERV, 648 NameInfoCallback, &result); 649 Process(); 650 EXPECT_TRUE(result.done_); 651 EXPECT_EQ(ARES_SUCCESS, result.status_); 652 EXPECT_EQ("", result.node_); 653 EXPECT_EQ("53", result.service_); 654 } 655 656 VIRT_NONVIRT_TEST_F(DefaultChannelTest, LiveGetNameInfoAllocFail) { 657 NameInfoResult result; 658 struct sockaddr_in sockaddr; 659 memset(&sockaddr, 0, sizeof(sockaddr)); 660 sockaddr.sin_family = AF_INET; 661 sockaddr.sin_port = htons(53); 662 sockaddr.sin_addr.s_addr = htonl(0x08080808); 663 SetAllocFail(1); 664 ares_getnameinfo(channel_, (const struct sockaddr*)&sockaddr, sizeof(sockaddr), 665 ARES_NI_LOOKUPHOST|ARES_NI_LOOKUPSERVICE|ARES_NI_UDP, 666 NameInfoCallback, &result); 667 Process(); 668 EXPECT_TRUE(result.done_); 669 EXPECT_EQ(ARES_ENOMEM, result.status_); 670 } 671 672 673 674 TEST_F(DefaultChannelTest, LiveSetServers) { 675 struct ares_addr_node server1; 676 struct ares_addr_node server2; 677 server1.next = &server2; 678 server1.family = AF_INET; 679 server1.addr.addr4.s_addr = htonl(0x01020304); 680 server2.next = nullptr; 681 server2.family = AF_INET; 682 server2.addr.addr4.s_addr = htonl(0x02030405); 683 684 HostResult result; 685 ares_gethostbyname(channel_, "www.google.com.", AF_INET, HostCallback, &result); 686 EXPECT_EQ(ARES_SUCCESS, ares_set_servers(channel_, &server1)); 687 ares_cancel(channel_); 688 } 689 690 TEST_F(DefaultChannelTest, LiveSetServersPorts) { 691 struct ares_addr_port_node server1; 692 struct ares_addr_port_node server2; 693 server1.next = &server2; 694 server1.family = AF_INET; 695 server1.addr.addr4.s_addr = htonl(0x01020304); 696 server1.udp_port = 111; 697 server1.tcp_port = 111; 698 server2.next = nullptr; 699 server2.family = AF_INET; 700 server2.addr.addr4.s_addr = htonl(0x02030405); 701 server2.udp_port = 0; 702 server2.tcp_port = 0; 703 EXPECT_EQ(ARES_ENODATA, ares_set_servers_ports(nullptr, &server1)); 704 705 // Change while pending will requeue any requests to new servers 706 HostResult result; 707 ares_gethostbyname(channel_, "www.google.com.", AF_INET, HostCallback, &result); 708 EXPECT_EQ(ARES_SUCCESS, ares_set_servers_ports(channel_, &server1)); 709 ares_cancel(channel_); 710 } 711 712 TEST_F(DefaultChannelTest, LiveSetServersCSV) { 713 HostResult result; 714 ares_gethostbyname(channel_, "www.google.com.", AF_INET, HostCallback, &result); 715 // Change while pending will requeue any requests to new servers 716 EXPECT_EQ(ARES_SUCCESS, ares_set_servers_csv(channel_, "1.2.3.4,2.3.4.5")); 717 EXPECT_EQ(ARES_SUCCESS, ares_set_servers_ports_csv(channel_, "1.2.3.4:56,2.3.4.5:67")); 718 ares_cancel(channel_); 719 } 720 721 722 } // namespace test 723 } // namespace ares