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
TEST(netdb,freeaddrinfo_NULL)28 TEST(netdb, freeaddrinfo_NULL) {
29 freeaddrinfo(nullptr);
30 }
31
TEST(netdb,getaddrinfo_NULL_host)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 = nullptr;
35 ASSERT_EQ(0, getaddrinfo(nullptr, "smtp", nullptr, &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
TEST(netdb,getaddrinfo_NULL_service)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 = nullptr;
44 ASSERT_EQ(0, getaddrinfo("localhost", nullptr, nullptr, &ai));
45 ASSERT_TRUE(ai != nullptr);
46 freeaddrinfo(ai);
47 }
48
TEST(netdb,getaddrinfo_NULL_hints)49 TEST(netdb, getaddrinfo_NULL_hints) {
50 addrinfo* ai = nullptr;
51 ASSERT_EQ(0, getaddrinfo("localhost", "9999", nullptr, &ai));
52
53 bool saw_tcp = false;
54 bool saw_udp = false;
55 for (addrinfo* p = ai; p != nullptr; 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
TEST(netdb,getaddrinfo_service_lookup)71 TEST(netdb, getaddrinfo_service_lookup) {
72 addrinfo* ai = nullptr;
73 ASSERT_EQ(0, getaddrinfo("localhost", "smtp", nullptr, &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
TEST(netdb,getaddrinfo_hints)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 = nullptr;
88 ASSERT_EQ(0, getaddrinfo( "localhost", "9999", &hints, &ai));
89 ASSERT_TRUE(ai != nullptr);
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 != nullptr) {
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
TEST(netdb,getaddrinfo_ip6_localhost)102 TEST(netdb, getaddrinfo_ip6_localhost) {
103 addrinfo* ai = nullptr;
104 ASSERT_EQ(0, getaddrinfo("ip6-localhost", nullptr, nullptr, &ai));
105 ASSERT_TRUE(ai != nullptr);
106 ASSERT_GE(ai->ai_addrlen, static_cast<socklen_t>(sizeof(sockaddr_in6)));
107 ASSERT_TRUE(ai->ai_addr != nullptr);
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
TEST(netdb,getnameinfo_salen)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), nullptr, 0, NI_NUMERICHOST));
126 ASSERT_STREQ("0.0.0.0", tmp);
127 ASSERT_EQ(0, getnameinfo(sa, just_right, tmp, sizeof(tmp), nullptr, 0, NI_NUMERICHOST));
128 ASSERT_STREQ("0.0.0.0", tmp);
129 ASSERT_EQ(EAI_FAMILY, getnameinfo(sa, too_little, tmp, sizeof(tmp), nullptr, 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), nullptr, 0, NI_NUMERICHOST));
137 ASSERT_STREQ("::", tmp);
138 ASSERT_EQ(0, getnameinfo(sa, just_right, tmp, sizeof(tmp), nullptr, 0, NI_NUMERICHOST));
139 ASSERT_STREQ("::", tmp);
140 ASSERT_EQ(EAI_FAMILY, getnameinfo(sa, too_little, tmp, sizeof(tmp), nullptr, 0, NI_NUMERICHOST));
141 }
142
TEST(netdb,getnameinfo_localhost)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), nullptr, 0, 0));
151 ASSERT_STREQ(host, "localhost");
152 }
153
VerifyLocalhostName(const char * name)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
TEST(netdb,getnameinfo_ip6_localhost)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), nullptr, 0, 0));
169 VerifyLocalhostName(host);
170 }
171
VerifyLocalhost(hostent * hent)172 static void VerifyLocalhost(hostent *hent) {
173 ASSERT_TRUE(hent != nullptr);
174 VerifyLocalhostName(hent->h_name);
175 for (size_t i = 0; hent->h_aliases[i] != nullptr; ++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
TEST(netdb,gethostbyname)185 TEST(netdb, gethostbyname) {
186 hostent* hp = gethostbyname("localhost");
187 VerifyLocalhost(hp);
188 }
189
TEST(netdb,gethostbyname2)190 TEST(netdb, gethostbyname2) {
191 hostent* hp = gethostbyname2("localhost", AF_INET);
192 VerifyLocalhost(hp);
193 }
194
TEST(netdb,gethostbyname_r)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
TEST(netdb,gethostbyname2_r)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
TEST(netdb,gethostbyaddr)239 TEST(netdb, gethostbyaddr) {
240 in_addr addr = { htonl(0x7f000001) };
241 hostent *hp = gethostbyaddr(&addr, sizeof(addr), AF_INET);
242 VerifyLocalhost(hp);
243 }
244
TEST(netdb,gethostbyaddr_r)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
TEST(netdb,gethostbyname_r_ERANGE)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(nullptr, hp);
277 }
278
TEST(netdb,gethostbyname2_r_ERANGE)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(nullptr, hp);
288 }
289
TEST(netdb,gethostbyaddr_r_ERANGE)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(nullptr, hp);
300 }
301
TEST(netdb,gethostbyname_r_HOST_NOT_FOUND)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(nullptr, hp);
311 }
312
TEST(netdb,gethostbyname2_r_HOST_NOT_FOUND)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(nullptr, hp);
322 }
323
TEST(netdb,gethostbyaddr_r_HOST_NOT_FOUND)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(nullptr, hp);
334 }
335
TEST(netdb,getservbyname)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
TEST(netdb,getservbyport)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
TEST(netdb,endnetent_getnetent_setnetent)390 TEST(netdb, endnetent_getnetent_setnetent) {
391 setnetent(0);
392 setnetent(1);
393 endnetent();
394 while (getnetent() != nullptr) {
395 }
396 }
397
TEST(netdb,getnetbyaddr)398 TEST(netdb, getnetbyaddr) {
399 getnetbyaddr(0, 0);
400 }
401
TEST(netdb,getnetbyname)402 TEST(netdb, getnetbyname) {
403 getnetbyname("x");
404 }
405
TEST(netdb,endprotoent_getprotoent_setprotoent)406 TEST(netdb, endprotoent_getprotoent_setprotoent) {
407 setprotoent(0);
408 setprotoent(1);
409 endprotoent();
410 while (getprotoent() != nullptr) {
411 }
412 }
413
TEST(netdb,getprotobyname)414 TEST(netdb, getprotobyname) {
415 getprotobyname("tcp");
416 }
417
TEST(netdb,getprotobynumber)418 TEST(netdb, getprotobynumber) {
419 getprotobynumber(6);
420 }
421
TEST(netdb,endservent_getservent_setservent)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
TEST(netdb,getservbyname_getservent_conflicts)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
TEST(netdb,getservbyport_getservent_conflicts)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
TEST(netdb,endservent_resets)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
TEST(netdb,setservent_resets)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
TEST(netdb,endhostent_gethostent_sethostent)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
TEST(netdb,endhostent_resets)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
TEST(netdb,sethostent_resets)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