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 ASSERT_EQ(ERANGE, result); 275 ASSERT_EQ(NULL, hp); 276 } 277 278 TEST(netdb, gethostbyname2_r_ERANGE) { 279 hostent hent; 280 hostent *hp; 281 char buf[4]; // Use too small buffer. 282 int err; 283 int result = gethostbyname2_r("localhost", AF_INET, &hent, buf, sizeof(buf), &hp, &err); 284 ASSERT_EQ(ERANGE, result); 285 ASSERT_EQ(NULL, hp); 286 } 287 288 TEST(netdb, gethostbyaddr_r_ERANGE) { 289 in_addr addr = { htonl(0x7f000001) }; 290 hostent hent; 291 hostent *hp; 292 char buf[4]; // Use too small buffer. 293 int err; 294 int result = gethostbyaddr_r(&addr, sizeof(addr), AF_INET, &hent, buf, sizeof(buf), &hp, &err); 295 ASSERT_EQ(ERANGE, result); 296 ASSERT_EQ(NULL, hp); 297 } 298 299 TEST(netdb, getservbyname) { 300 // smtp is TCP-only, so we know we'll get 25/tcp back. 301 servent* s = getservbyname("smtp", NULL); 302 ASSERT_TRUE(s != NULL); 303 ASSERT_EQ(25, ntohs(s->s_port)); 304 ASSERT_STREQ("tcp", s->s_proto); 305 306 // We get the same result by explicitly asking for tcp. 307 s = getservbyname("smtp", "tcp"); 308 ASSERT_TRUE(s != NULL); 309 ASSERT_EQ(25, ntohs(s->s_port)); 310 ASSERT_STREQ("tcp", s->s_proto); 311 312 // And we get a failure if we explicitly ask for udp. 313 s = getservbyname("smtp", "udp"); 314 ASSERT_TRUE(s == NULL); 315 316 // But there are actually udp services. 317 s = getservbyname("echo", "udp"); 318 ASSERT_TRUE(s != NULL); 319 ASSERT_EQ(7, ntohs(s->s_port)); 320 ASSERT_STREQ("udp", s->s_proto); 321 } 322
