1 /* 2 * Copyright (C) 2013 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include <netdb.h> 18 19 #include <gtest/gtest.h> 20 21 #include <arpa/inet.h> 22 #include <string.h> 23 #include <sys/types.h> 24 #include <sys/socket.h> 25 #include <netinet/in.h> 26 27 // https://code.google.com/p/android/issues/detail?id=13228 28 TEST(netdb, freeaddrinfo_NULL) { 29 freeaddrinfo(NULL); 30 } 31 32 TEST(netdb, getaddrinfo_NULL_host) { 33 // It's okay for the host argument to be NULL, as long as service isn't. 34 addrinfo* ai = NULL; 35 ASSERT_EQ(0, getaddrinfo(NULL, "smtp", NULL, &ai)); 36 // (sockaddr_in::sin_port and sockaddr_in6::sin6_port overlap.) 37 ASSERT_EQ(25U, ntohs(reinterpret_cast<sockaddr_in*>(ai->ai_addr)->sin_port)); 38 freeaddrinfo(ai); 39 } 40 41 TEST(netdb, getaddrinfo_NULL_service) { 42 // It's okay for the service argument to be NULL, as long as host isn't. 43 addrinfo* ai = NULL; 44 ASSERT_EQ(0, getaddrinfo("localhost", NULL, NULL, &ai)); 45 ASSERT_TRUE(ai != NULL); 46 freeaddrinfo(ai); 47 } 48 49 TEST(netdb, getaddrinfo_NULL_hints) { 50 addrinfo* ai = NULL; 51 ASSERT_EQ(0, getaddrinfo("localhost", "9999", NULL, &ai)); 52 53 bool saw_tcp = false; 54 bool saw_udp = false; 55 for (addrinfo* p = ai; p != NULL; p = p->ai_next) { 56 ASSERT_TRUE(p->ai_family == AF_INET || p->ai_family == AF_INET6); 57 if (p->ai_socktype == SOCK_STREAM) { 58 ASSERT_EQ(IPPROTO_TCP, p->ai_protocol); 59 saw_tcp = true; 60 } else if (p->ai_socktype == SOCK_DGRAM) { 61 ASSERT_EQ(IPPROTO_UDP, p->ai_protocol); 62 saw_udp = true; 63 } 64 } 65 ASSERT_TRUE(saw_tcp); 66 ASSERT_TRUE(saw_udp); 67 68 freeaddrinfo(ai); 69 } 70 71 TEST(netdb, getaddrinfo_service_lookup) { 72 addrinfo* ai = NULL; 73 ASSERT_EQ(0, getaddrinfo("localhost", "smtp", NULL, &ai)); 74 ASSERT_EQ(SOCK_STREAM, ai->ai_socktype); 75 ASSERT_EQ(IPPROTO_TCP, ai->ai_protocol); 76 ASSERT_EQ(25, ntohs(reinterpret_cast<sockaddr_in*>(ai->ai_addr)->sin_port)); 77 freeaddrinfo(ai); 78 } 79 80 TEST(netdb, getaddrinfo_hints) { 81 addrinfo hints; 82 memset(&hints, 0, sizeof(hints)); 83 hints.ai_family = AF_INET; 84 hints.ai_socktype = SOCK_STREAM; 85 hints.ai_protocol = IPPROTO_TCP; 86 87 addrinfo* ai = NULL; 88 ASSERT_EQ(0, getaddrinfo( "localhost", "9999", &hints, &ai)); 89 ASSERT_TRUE(ai != NULL); 90 // In glibc, getaddrinfo() converts ::1 to 127.0.0.1 for localhost, 91 // so one or two addrinfo may be returned. 92 addrinfo* tai = ai; 93 while (tai != NULL) { 94 ASSERT_EQ(AF_INET, tai->ai_family); 95 ASSERT_EQ(SOCK_STREAM, tai->ai_socktype); 96 ASSERT_EQ(IPPROTO_TCP, tai->ai_protocol); 97 tai = tai->ai_next; 98 } 99 freeaddrinfo(ai); 100 } 101 102 TEST(netdb, getaddrinfo_ip6_localhost) { 103 addrinfo* ai = NULL; 104 ASSERT_EQ(0, getaddrinfo("ip6-localhost", NULL, NULL, &ai)); 105 ASSERT_TRUE(ai != NULL); 106 ASSERT_GE(ai->ai_addrlen, static_cast<socklen_t>(sizeof(sockaddr_in6))); 107 ASSERT_TRUE(ai->ai_addr != NULL); 108 sockaddr_in6 *addr = reinterpret_cast<sockaddr_in6*>(ai->ai_addr); 109 ASSERT_EQ(addr->sin6_family, AF_INET6); 110 ASSERT_EQ(0, memcmp(&addr->sin6_addr, &in6addr_loopback, sizeof(in6_addr))); 111 freeaddrinfo(ai); 112 } 113 114 TEST(netdb, getnameinfo_salen) { 115 sockaddr_storage ss; 116 memset(&ss, 0, sizeof(ss)); 117 sockaddr* sa = reinterpret_cast<sockaddr*>(&ss); 118 char tmp[16]; 119 120 ss.ss_family = AF_INET; 121 socklen_t too_much = sizeof(ss); 122 socklen_t just_right = sizeof(sockaddr_in); 123 socklen_t too_little = sizeof(sockaddr_in) - 1; 124 125 ASSERT_EQ(0, getnameinfo(sa, too_much, tmp, sizeof(tmp), NULL, 0, NI_NUMERICHOST)); 126 ASSERT_STREQ("0.0.0.0", tmp); 127 ASSERT_EQ(0, getnameinfo(sa, just_right, tmp, sizeof(tmp), NULL, 0, NI_NUMERICHOST)); 128 ASSERT_STREQ("0.0.0.0", tmp); 129 ASSERT_EQ(EAI_FAMILY, getnameinfo(sa, too_little, tmp, sizeof(tmp), NULL, 0, NI_NUMERICHOST)); 130 131 ss.ss_family = AF_INET6; 132 just_right = sizeof(sockaddr_in6); 133 too_little = sizeof(sockaddr_in6) - 1; 134 too_much = just_right + 1; 135 136 ASSERT_EQ(0, getnameinfo(sa, too_much, tmp, sizeof(tmp), NULL, 0, NI_NUMERICHOST)); 137 ASSERT_STREQ("::", tmp); 138 ASSERT_EQ(0, getnameinfo(sa, just_right, tmp, sizeof(tmp), NULL, 0, NI_NUMERICHOST)); 139 ASSERT_STREQ("::", tmp); 140 ASSERT_EQ(EAI_FAMILY, getnameinfo(sa, too_little, tmp, sizeof(tmp), NULL, 0, NI_NUMERICHOST)); 141 } 142 143 TEST(netdb, getnameinfo_localhost) { 144 sockaddr_in addr; 145 char host[NI_MAXHOST]; 146 memset(&addr, 0, sizeof(sockaddr_in)); 147 addr.sin_family = AF_INET; 148 addr.sin_addr.s_addr = htonl(0x7f000001); 149 ASSERT_EQ(0, getnameinfo(reinterpret_cast<sockaddr*>(&addr), sizeof(addr), 150 host, sizeof(host), NULL, 0, 0)); 151 ASSERT_STREQ(host, "localhost"); 152 } 153 154 static void VerifyLocalhostName(const char* name) { 155 // Test possible localhost name and aliases, which depend on /etc/hosts or /system/etc/hosts. 156 ASSERT_TRUE(strcmp(name, "localhost") == 0 || 157 strcmp(name, "ip6-localhost") == 0 || 158 strcmp(name, "ip6-loopback") == 0) << name; 159 } 160 161 TEST(netdb, getnameinfo_ip6_localhost) { 162 sockaddr_in6 addr; 163 char host[NI_MAXHOST]; 164 memset(&addr, 0, sizeof(sockaddr_in6)); 165 addr.sin6_family = AF_INET6; 166 addr.sin6_addr = in6addr_loopback; 167 ASSERT_EQ(0, getnameinfo(reinterpret_cast<sockaddr*>(&addr), sizeof(addr), 168 host, sizeof(host), NULL, 0, 0)); 169 VerifyLocalhostName(host); 170 } 171 172 static void VerifyLocalhost(hostent *hent) { 173 ASSERT_TRUE(hent != NULL); 174 VerifyLocalhostName(hent->h_name); 175 for (size_t i = 0; hent->h_aliases[i] != NULL; ++i) { 176 VerifyLocalhostName(hent->h_aliases[i]); 177 } 178 ASSERT_EQ(hent->h_addrtype, AF_INET); 179 ASSERT_EQ(hent->h_addr[0], 127); 180 ASSERT_EQ(hent->h_addr[1], 0); 181 ASSERT_EQ(hent->h_addr[2], 0); 182 ASSERT_EQ(hent->h_addr[3], 1); 183 } 184 185 TEST(netdb, gethostbyname) { 186 hostent* hp = gethostbyname("localhost"); 187 VerifyLocalhost(hp); 188 } 189 190 TEST(netdb, gethostbyname2) { 191 hostent* hp = gethostbyname2("localhost", AF_INET); 192 VerifyLocalhost(hp); 193 } 194 195 TEST(netdb, gethostbyname_r) { 196 hostent hent; 197 hostent *hp; 198 char buf[512]; 199 int err; 200 int result = gethostbyname_r("localhost", &hent, buf, sizeof(buf), &hp, &err); 201 ASSERT_EQ(0, result); 202 VerifyLocalhost(hp); 203 204 // Change hp->h_addr to test reentrancy. 205 hp->h_addr[0] = 0; 206 207 hostent hent2; 208 hostent *hp2; 209 char buf2[512]; 210 result = gethostbyname_r("localhost", &hent2, buf2, sizeof(buf2), &hp2, &err); 211 ASSERT_EQ(0, result); 212 VerifyLocalhost(hp2); 213 214 ASSERT_EQ(0, hp->h_addr[0]); 215 } 216 217 TEST(netdb, gethostbyname2_r) { 218 hostent hent; 219 hostent *hp; 220 char buf[512]; 221 int err; 222 int result = gethostbyname2_r("localhost", AF_INET, &hent, buf, sizeof(buf), &hp, &err); 223 ASSERT_EQ(0, result); 224 VerifyLocalhost(hp); 225 226 // Change hp->h_addr to test reentrancy. 227 hp->h_addr[0] = 0; 228 229 hostent hent2; 230 hostent *hp2; 231 char buf2[512]; 232 result = gethostbyname2_r("localhost", AF_INET, &hent2, buf2, sizeof(buf2), &hp2, &err); 233 ASSERT_EQ(0, result); 234 VerifyLocalhost(hp2); 235 236 ASSERT_EQ(0, hp->h_addr[0]); 237 } 238 239 TEST(netdb, gethostbyaddr) { 240 in_addr addr = { htonl(0x7f000001) }; 241 hostent *hp = gethostbyaddr(&addr, sizeof(addr), AF_INET); 242 VerifyLocalhost(hp); 243 } 244 245 TEST(netdb, gethostbyaddr_r) { 246 in_addr addr = { htonl(0x7f000001) }; 247 hostent hent; 248 hostent *hp; 249 char buf[512]; 250 int err; 251 int result = gethostbyaddr_r(&addr, sizeof(addr), AF_INET, &hent, buf, sizeof(buf), &hp, &err); 252 ASSERT_EQ(0, result); 253 VerifyLocalhost(hp); 254 255 // Change hp->h_addr to test reentrancy. 256 hp->h_addr[0] = 0; 257 258 hostent hent2; 259 hostent *hp2; 260 char buf2[512]; 261 result = gethostbyaddr_r(&addr, sizeof(addr), AF_INET, &hent2, buf2, sizeof(buf2), &hp2, &err); 262 ASSERT_EQ(0, result); 263 VerifyLocalhost(hp2); 264 265 ASSERT_EQ(0, hp->h_addr[0]); 266 } 267 268 TEST(netdb, gethostbyname_r_ERANGE) { 269 hostent hent; 270 hostent *hp; 271 char buf[4]; // Use too small buffer. 272 int err; 273 int result = gethostbyname_r("localhost", &hent, buf, sizeof(buf), &hp, &err); 274 EXPECT_EQ(NETDB_INTERNAL, err); 275 EXPECT_EQ(ERANGE, result); 276 EXPECT_EQ(NULL, hp); 277 } 278 279 TEST(netdb, gethostbyname2_r_ERANGE) { 280 hostent hent; 281 hostent *hp; 282 char buf[4]; // Use too small buffer. 283 int err; 284 int result = gethostbyname2_r("localhost", AF_INET, &hent, buf, sizeof(buf), &hp, &err); 285 EXPECT_EQ(NETDB_INTERNAL, err); 286 EXPECT_EQ(ERANGE, result); 287 EXPECT_EQ(NULL, hp); 288 } 289 290 TEST(netdb, gethostbyaddr_r_ERANGE) { 291 in_addr addr = { htonl(0x7f000001) }; 292 hostent hent; 293 hostent *hp; 294 char buf[4]; // Use too small buffer. 295 int err; 296 int result = gethostbyaddr_r(&addr, sizeof(addr), AF_INET, &hent, buf, sizeof(buf), &hp, &err); 297 EXPECT_EQ(NETDB_INTERNAL, err); 298 EXPECT_EQ(ERANGE, result); 299 EXPECT_EQ(NULL, hp); 300 } 301 302 TEST(netdb, gethostbyname_r_HOST_NOT_FOUND) { 303 hostent hent; 304 hostent *hp; 305 char buf[BUFSIZ]; 306 int err; 307 int result = gethostbyname_r("does.not.exist.google.com", &hent, buf, sizeof(buf), &hp, &err); 308 EXPECT_EQ(HOST_NOT_FOUND, err); 309 EXPECT_EQ(0, result); 310 EXPECT_EQ(NULL, hp); 311 } 312 313 TEST(netdb, gethostbyname2_r_HOST_NOT_FOUND) { 314 hostent hent; 315 hostent *hp; 316 char buf[BUFSIZ]; 317 int err; 318 int result = gethostbyname2_r("does.not.exist.google.com", AF_INET, &hent, buf, sizeof(buf), &hp, &err); 319 EXPECT_EQ(HOST_NOT_FOUND, err); 320 EXPECT_EQ(0, result); 321 EXPECT_EQ(NULL, hp); 322 } 323 324 TEST(netdb, gethostbyaddr_r_HOST_NOT_FOUND) { 325 in_addr addr = { htonl(0xffffffff) }; 326 hostent hent; 327 hostent *hp; 328 char buf[BUFSIZ]; 329 int err; 330 int result = gethostbyaddr_r(&addr, sizeof(addr), AF_INET, &hent, buf, sizeof(buf), &hp, &err); 331 EXPECT_EQ(HOST_NOT_FOUND, err); 332 EXPECT_EQ(0, result); 333 EXPECT_EQ(NULL, hp); 334 } 335 336 TEST(netdb, getservbyname) { 337 // smtp is TCP-only, so we know we'll get 25/tcp back. 338 servent* s = getservbyname("smtp", nullptr); 339 ASSERT_TRUE(s != nullptr); 340 ASSERT_STREQ("smtp", s->s_name); 341 ASSERT_EQ(25, ntohs(s->s_port)); 342 ASSERT_STREQ("tcp", s->s_proto); 343 344 // We get the same result by explicitly asking for tcp. 345 s = getservbyname("smtp", "tcp"); 346 ASSERT_TRUE(s != nullptr); 347 ASSERT_STREQ("smtp", s->s_name); 348 ASSERT_EQ(25, ntohs(s->s_port)); 349 ASSERT_STREQ("tcp", s->s_proto); 350 351 // And we get a failure if we explicitly ask for udp. 352 s = getservbyname("smtp", "udp"); 353 ASSERT_TRUE(s == nullptr); 354 355 // But there are actually udp services. 356 s = getservbyname("echo", "udp"); 357 ASSERT_TRUE(s != nullptr); 358 ASSERT_STREQ("echo", s->s_name); 359 ASSERT_EQ(7, ntohs(s->s_port)); 360 ASSERT_STREQ("udp", s->s_proto); 361 } 362 363 TEST(netdb, getservbyport) { 364 // smtp is TCP-only, so we know we'll get 25/tcp back. 365 servent* s = getservbyport(htons(25), nullptr); 366 ASSERT_TRUE(s != nullptr); 367 ASSERT_STREQ("smtp", s->s_name); 368 ASSERT_EQ(25, ntohs(s->s_port)); 369 ASSERT_STREQ("tcp", s->s_proto); 370 371 // We get the same result by explicitly asking for tcp. 372 s = getservbyport(htons(25), "tcp"); 373 ASSERT_TRUE(s != nullptr); 374 ASSERT_STREQ("smtp", s->s_name); 375 ASSERT_EQ(25, ntohs(s->s_port)); 376 ASSERT_STREQ("tcp", s->s_proto); 377 378 // And we get a failure if we explicitly ask for udp. 379 s = getservbyport(htons(25), "udp"); 380 ASSERT_TRUE(s == nullptr); 381 382 // But there are actually udp services. 383 s = getservbyport(htons(7), "udp"); 384 ASSERT_TRUE(s != nullptr); 385 ASSERT_STREQ("echo", s->s_name); 386 ASSERT_EQ(7, ntohs(s->s_port)); 387 ASSERT_STREQ("udp", s->s_proto); 388 } 389 390 TEST(netdb, endnetent_getnetent_setnetent) { 391 setnetent(0); 392 setnetent(1); 393 endnetent(); 394 while (getnetent() != nullptr) { 395 } 396 } 397 398 TEST(netdb, getnetbyaddr) { 399 getnetbyaddr(0, 0); 400 } 401 402 TEST(netdb, getnetbyname) { 403 getnetbyname("x"); 404 } 405 406 TEST(netdb, endprotoent_getprotoent_setprotoent) { 407 setprotoent(0); 408 setprotoent(1); 409 endprotoent(); 410 while (getprotoent() != nullptr) { 411 } 412 } 413 414 TEST(netdb, getprotobyname) { 415 getprotobyname("tcp"); 416 } 417 418 TEST(netdb, getprotobynumber) { 419 getprotobynumber(6); 420 } 421 422 TEST(netdb, endservent_getservent_setservent) { 423 setservent(0); 424 setservent(1); 425 endservent(); 426 size_t service_count = 0; 427 while (getservent() != nullptr) { 428 ++service_count; 429 } 430 ASSERT_GT(service_count, 0U); 431 } 432 433 TEST(netdb, getservbyname_getservent_conflicts) { 434 // Calling getservbyname shouldn't affect getservent's iteration order. 435 endservent(); 436 while (getservent() != nullptr) { 437 ASSERT_TRUE(getservbyname("smtp", "tcp") != nullptr); 438 } 439 } 440 441 TEST(netdb, getservbyport_getservent_conflicts) { 442 // Calling getservbyport shouldn't affect getservent's iteration order. 443 endservent(); 444 while (getservent() != nullptr) { 445 ASSERT_TRUE(getservbyport(htons(25), "tcp") != nullptr); 446 } 447 } 448 449 TEST(netdb, endservent_resets) { 450 endservent(); 451 std::string first_service(getservent()->s_name); 452 endservent(); 453 ASSERT_EQ(first_service, std::string(getservent()->s_name)); 454 } 455 456 TEST(netdb, setservent_resets) { 457 endservent(); 458 std::string first_service(getservent()->s_name); 459 setservent(0); 460 ASSERT_EQ(first_service, std::string(getservent()->s_name)); 461 } 462 463 TEST(netdb, endhostent_gethostent_sethostent) { 464 sethostent(0); 465 sethostent(1); 466 endhostent(); 467 size_t host_count = 0; 468 while (gethostent() != nullptr) { 469 ++host_count; 470 } 471 ASSERT_GT(host_count, 0U); 472 } 473 474 TEST(netdb, endhostent_resets) { 475 endhostent(); 476 std::string first_host(gethostent()->h_name); 477 endhostent(); 478 ASSERT_EQ(first_host, std::string(gethostent()->h_name)); 479 } 480 481 TEST(netdb, sethostent_resets) { 482 endhostent(); 483 std::string first_host(gethostent()->h_name); 484 sethostent(0); 485 ASSERT_EQ(first_host, std::string(gethostent()->h_name)); 486 } 487
