netdb_test.cpp revision bb7d9fb5d438c7477c404f97e07e145d49335947 
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
28TEST(netdb, freeaddrinfo_NULL) {
29  freeaddrinfo(NULL);
30}
31
32TEST(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
41TEST(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
49TEST(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
71TEST(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
80TEST(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
102TEST(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
114TEST(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
143TEST(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
154static 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
161TEST(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
172static 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
185TEST(netdb, gethostbyname) {
186  hostent* hp = gethostbyname("localhost");
187  VerifyLocalhost(hp);
188}
189
190TEST(netdb, gethostbyname2) {
191  hostent* hp = gethostbyname2("localhost", AF_INET);
192  VerifyLocalhost(hp);
193}
194
195TEST(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
217TEST(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
239TEST(netdb, gethostbyaddr) {
240  in_addr addr = { htonl(0x7f000001) };
241  hostent *hp = gethostbyaddr(&addr, sizeof(addr), AF_INET);
242  VerifyLocalhost(hp);
243}
244
245TEST(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
268TEST(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
279TEST(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
290TEST(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
302TEST(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
313TEST(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
324TEST(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
336TEST(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
363TEST(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
390TEST(netdb, endnetent_getnetent_setnetent) {
391  setnetent(0);
392  setnetent(1);
393  endnetent();
394  while (getnetent() != nullptr) {
395  }
396}
397
398TEST(netdb, getnetbyaddr) {
399  getnetbyaddr(0, 0);
400}
401
402TEST(netdb, getnetbyname) {
403  getnetbyname("x");
404}
405
406TEST(netdb, endprotoent_getprotoent_setprotoent) {
407  setprotoent(0);
408  setprotoent(1);
409  endprotoent();
410  while (getprotoent() != nullptr) {
411  }
412}
413
414TEST(netdb, getprotobyname) {
415  getprotobyname("tcp");
416}
417
418TEST(netdb, getprotobynumber) {
419  getprotobynumber(6);
420}
421
422TEST(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
433TEST(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
441TEST(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
449TEST(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
456TEST(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
463TEST(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
474TEST(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
481TEST(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