Debian Codegraph @

tests/test_getaddrinfo.c

raw
1 #include "config.h"
2
3 #include <stdarg.h>
4 #include <stddef.h>
5 #include <stdint.h>
6 #include <setjmp.h>
7 #include <cmocka.h>
8
9 #include <errno.h>
10 #include <stdio.h>
11 #include <string.h>
12 #include <stdlib.h>
13 #include <unistd.h>
14
15 #include <sys/socket.h>
16 #include <netinet/in.h>
17 #include <arpa/inet.h>
18 #include <netdb.h>
19
20 static void test_nwrap_getaddrinfo(void **state)
21 {
22 struct addrinfo hints;
23 struct addrinfo *res = NULL;
24 union {
25 struct sockaddr *sa;
26 struct sockaddr_in *in;
27 struct sockaddr_in6 *in6;
28 } addr;
29 char ip6[INET6_ADDRSTRLEN];
30 char *ip;
31 int rc;
32
33 (void) state; /* unused */
34
35 /* IPv4 */
36 memset(&hints, 0, sizeof(struct addrinfo));
37 hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */
38 hints.ai_socktype = SOCK_DGRAM; /* Datagram socket */
39 hints.ai_flags = AI_PASSIVE; /* For wildcard IP address */
40 hints.ai_protocol = 0; /* Any protocol */
41 hints.ai_canonname = NULL;
42 hints.ai_addr = NULL;
43 hints.ai_next = NULL;
44
45 rc = getaddrinfo("127.0.0.11", NULL, &hints, &res);
46 assert_int_equal(rc, 0);
47 assert_non_null(res);
48
49 assert_non_null(res->ai_canonname);
50 assert_string_equal(res->ai_canonname, "magrathea.galaxy.site");
51
52 assert_int_equal(res->ai_family, AF_INET);
53
54 addr.sa = res->ai_addr;
55
56 assert_int_equal(addr.in->sin_family, AF_INET);
57 ip = inet_ntoa(addr.in->sin_addr);
58
59 assert_string_equal(ip, "127.0.0.11");
60
61 freeaddrinfo(res);
62 res = NULL;
63
64 memset(&hints, 0, sizeof(struct addrinfo));
65 hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */
66 hints.ai_socktype = SOCK_DGRAM; /* Datagram socket */
67 hints.ai_flags = AI_PASSIVE; /* For wildcard IP address */
68 hints.ai_protocol = 0; /* Any protocol */
69 hints.ai_canonname = NULL;
70 hints.ai_addr = NULL;
71 hints.ai_next = NULL;
72
73 rc = getaddrinfo("::13", NULL, &hints, &res);
74 assert_non_null(res);
75 assert_int_equal(rc, 0);
76
77 assert_non_null(res->ai_canonname);
78 assert_string_equal(res->ai_canonname, "beteigeuze.galaxy.site");
79
80 assert_int_equal(res->ai_family, AF_INET6);
81
82 addr.sa = res->ai_addr;
83
84 assert_int_equal(addr.in6->sin6_family, AF_INET6);
85 inet_ntop(AF_INET6, (void *)&addr.in6->sin6_addr, ip6, sizeof(ip6));
86
87 assert_string_equal(ip6, "::13");
88
89 freeaddrinfo(res);
90 }
91
92 /*
93 * The purpose of this test is to verify that reloading of the hosts
94 * file (triggered by a timestamp change) correctly frees and re-creates
95 * the internal data structures, so we do not end up using invalid memory.
96 */
97 static void test_nwrap_getaddrinfo_reload(void **state)
98 {
99 struct addrinfo hints;
100 struct addrinfo *res = NULL;
101 const char *env;
102 char touch_cmd[1024];
103 int rc;
104
105 (void) state; /* unused */
106
107 /* IPv4 */
108 memset(&hints, 0, sizeof(struct addrinfo));
109 hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */
110 hints.ai_socktype = SOCK_DGRAM; /* Datagram socket */
111 hints.ai_flags = AI_PASSIVE; /* For wildcard IP address */
112 hints.ai_protocol = 0; /* Any protocol */
113 hints.ai_canonname = NULL;
114 hints.ai_addr = NULL;
115 hints.ai_next = NULL;
116
117 rc = getaddrinfo("127.0.0.11", NULL, &hints, &res);
118 assert_int_equal(rc, 0);
119 assert_non_null(res);
120
121 freeaddrinfo(res);
122 res = NULL;
123
124 env = getenv("NSS_WRAPPER_HOSTS");
125 assert_non_null(env);
126
127 snprintf(touch_cmd, sizeof(touch_cmd), "touch %s", env);
128
129 rc = system(touch_cmd);
130 assert_return_code(rc, errno);
131
132 rc = getaddrinfo("127.0.0.11", NULL, &hints, &res);
133 assert_int_equal(rc, 0);
134 assert_non_null(res);
135
136
137 freeaddrinfo(res);
138 }
139
140 static void test_nwrap_getaddrinfo_samba(void **state)
141 {
142 struct addrinfo hints;
143 struct addrinfo *res = NULL;
144 int rc;
145
146 (void) state; /* unused */
147
148 /* IPv4 */
149 memset(&hints, 0, sizeof(struct addrinfo));
150 hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */
151 hints.ai_socktype = SOCK_STREAM; /* Stream socket */
152 hints.ai_flags = 0; /* For wildcard IP address */
153 hints.ai_protocol = IPPROTO_TCP; /* Any protocol */
154 hints.ai_canonname = NULL;
155 hints.ai_addr = NULL;
156 hints.ai_next = NULL;
157
158 rc = getaddrinfo("127.0.0.21", NULL, &hints, &res);
159 assert_int_equal(rc, 0);
160 assert_non_null(res);
161 freeaddrinfo(res);
162 res = NULL;
163
164 rc = getaddrinfo("samba.example.com", NULL, &hints, &res);
165 assert_int_equal(rc, 0);
166 assert_non_null(res);
167 freeaddrinfo(res);
168 res = NULL;
169
170 rc = getaddrinfo("localdc", NULL, &hints, &res);
171 assert_int_equal(rc, 0);
172 assert_non_null(res);
173 freeaddrinfo(res);
174 res = NULL;
175
176 rc = getaddrinfo("localdc.samba.example.com", NULL, &hints, &res);
177 assert_int_equal(rc, 0);
178 assert_non_null(res);
179 freeaddrinfo(res);
180 res = NULL;
181
182 rc = getaddrinfo("fd00:0000:0000:0000:0000:0000:5357:5f15", NULL, &hints, &res);
183 assert_int_equal(rc, 0);
184 assert_non_null(res);
185
186 freeaddrinfo(res);
187 }
188
189 static void test_nwrap_getaddrinfo_any(void **state)
190 {
191 struct addrinfo hints;
192 struct addrinfo *res = NULL;
193 union {
194 struct sockaddr *sa;
195 struct sockaddr_in *in;
196 struct sockaddr_in6 *in6;
197 } addr;
198 char ip6[INET6_ADDRSTRLEN];
199 char *ip;
200 int rc;
201
202 (void) state; /* unused */
203
204 /* IPv4 */
205 memset(&hints, 0, sizeof(struct addrinfo));
206 hints.ai_family = AF_INET;
207 hints.ai_socktype = SOCK_STREAM;
208 hints.ai_flags = AI_NUMERICHOST | AI_NUMERICSERV;
209
210 rc = getaddrinfo("0.0.0.0", "389", &hints, &res);
211 assert_int_equal(rc, 0);
212 assert_non_null(res);
213
214 assert_int_equal(res->ai_family, AF_INET);
215 assert_int_equal(res->ai_socktype, SOCK_STREAM);
216
217 #ifdef HAVE_GETADDRINFO_SETS_CANONNAME_FOR_IPADDRESSES
218 assert_string_equal(res->ai_canonname, "0.0.0.0");
219 #else /* HAVE_GETADDRINFO_SETS_CANONNAME_FOR_IPADDRESSES */
220 assert_null(res->ai_canonname);
221 #endif /* HAVE_GETADDRINFO_SETS_CANONNAME_FOR_IPADDRESSES */
222
223 addr.sa = res->ai_addr;
224
225 assert_int_equal(389, htons(addr.in->sin_port));
226
227 ip = inet_ntoa(addr.in->sin_addr);
228
229 assert_string_equal(ip, "0.0.0.0");
230
231 freeaddrinfo(res);
232 res = NULL;
233
234 /* IPv4 */
235 memset(&hints, 0, sizeof(struct addrinfo));
236 hints.ai_family = AF_INET6;
237 hints.ai_socktype = SOCK_STREAM;
238 hints.ai_flags = AI_NUMERICHOST | AI_NUMERICSERV;
239
240 rc = getaddrinfo("::", "389", &hints, &res);
241 assert_int_equal(rc, 0);
242 assert_non_null(res);
243
244 assert_int_equal(res->ai_family, AF_INET6);
245 assert_int_equal(res->ai_socktype, SOCK_STREAM);
246
247 #ifdef HAVE_GETADDRINFO_SETS_CANONNAME_FOR_IPADDRESSES
248 assert_string_equal(res->ai_canonname, "::");
249 #else /* HAVE_GETADDRINFO_SETS_CANONNAME_FOR_IPADDRESSES */
250 assert_null(res->ai_canonname);
251 #endif /* HAVE_GETADDRINFO_SETS_CANONNAME_FOR_IPADDRESSES */
252
253 addr.sa = res->ai_addr;
254
255 assert_int_equal(389, htons(addr.in6->sin6_port));
256
257 inet_ntop(AF_INET6, (void *)&addr.in6->sin6_addr, ip6, sizeof(ip6));
258
259 assert_string_equal(ip6, "::");
260
261 freeaddrinfo(res);
262 }
263
264 static void test_nwrap_getaddrinfo_local(void **state)
265 {
266 struct addrinfo hints;
267 struct addrinfo *res;
268 union {
269 struct sockaddr *sa;
270 struct sockaddr_in *in;
271 struct sockaddr_in6 *in6;
272 } addr;
273 char *ip;
274 int rc;
275
276 (void) state; /* unused */
277
278 /* IPv4 */
279 memset(&hints, 0, sizeof(struct addrinfo));
280 hints.ai_family = AF_UNSPEC;
281 hints.ai_socktype = SOCK_STREAM;
282 hints.ai_flags = 0;
283
284 rc = getaddrinfo("127.0.0.1", NULL, &hints, &res);
285 assert_int_equal(rc, 0);
286
287 assert_int_equal(res->ai_family, AF_INET);
288 assert_int_equal(res->ai_socktype, SOCK_STREAM);
289
290 #ifdef HAVE_GETADDRINFO_SETS_CANONNAME_FOR_IPADDRESSES
291 assert_string_equal(res->ai_canonname, "127.0.0.1");
292 #else /* HAVE_GETADDRINFO_SETS_CANONNAME_FOR_IPADDRESSES */
293 assert_null(res->ai_canonname);
294 #endif /* HAVE_GETADDRINFO_SETS_CANONNAME_FOR_IPADDRESSES */
295
296 addr.sa = res->ai_addr;
297 ip = inet_ntoa(addr.in->sin_addr);
298
299 assert_string_equal(ip, "127.0.0.1");
300
301 freeaddrinfo(res);
302 }
303
304 static void test_nwrap_getaddrinfo_name(void **state)
305 {
306 struct addrinfo hints;
307 struct addrinfo *res = NULL;
308 union {
309 struct sockaddr *sa;
310 struct sockaddr_in *in;
311 struct sockaddr_in6 *in6;
312 } addr;
313 char *ip;
314 int rc;
315
316 (void) state; /* unused */
317
318 /* IPv4 */
319 memset(&hints, 0, sizeof(struct addrinfo));
320 hints.ai_family = AF_UNSPEC;
321 hints.ai_socktype = SOCK_STREAM;
322 hints.ai_flags = 0;
323
324 rc = getaddrinfo("maximegalon.galaxy.site", NULL, &hints, &res);
325 assert_int_equal(rc, 0);
326 assert_non_null(res);
327
328 assert_non_null(res);
329 assert_int_equal(res->ai_family, AF_INET);
330 assert_int_equal(res->ai_socktype, SOCK_STREAM);
331
332 assert_non_null(res->ai_canonname);
333 assert_string_equal(res->ai_canonname, "maximegalon.galaxy.site");
334
335 addr.sa = res->ai_addr;
336 ip = inet_ntoa(addr.in->sin_addr);
337
338 assert_string_equal(ip, "127.0.0.12");
339
340 freeaddrinfo(res);
341 res = NULL;
342
343 /* IPv4 */
344 memset(&hints, 0, sizeof(struct addrinfo));
345 hints.ai_family = AF_UNSPEC;
346 hints.ai_socktype = SOCK_STREAM;
347 hints.ai_flags = 0;
348
349 rc = getaddrinfo("MAGRATHEA", NULL, &hints, &res);
350 assert_int_equal(rc, 0);
351
352 assert_non_null(res);
353 assert_int_equal(res->ai_family, AF_INET);
354 assert_int_equal(res->ai_socktype, SOCK_STREAM);
355
356 assert_non_null(res->ai_canonname);
357 assert_string_equal(res->ai_canonname, "magrathea.galaxy.site");
358
359 addr.sa = res->ai_addr;
360 ip = inet_ntoa(addr.in->sin_addr);
361
362 assert_string_equal(ip, "127.0.0.11");
363
364 freeaddrinfo(res);
365 }
366
367 static void test_nwrap_getaddrinfo_service(void **state)
368 {
369 struct addrinfo hints;
370 struct addrinfo *res = NULL;
371 union {
372 struct sockaddr *sa;
373 struct sockaddr_in *in;
374 struct sockaddr_in6 *in6;
375 } addr;
376 char *ip;
377 int rc;
378
379 (void) state; /* unused */
380
381 /* IPv4 */
382 memset(&hints, 0, sizeof(struct addrinfo));
383 hints.ai_family = AF_UNSPEC;
384 hints.ai_socktype = SOCK_STREAM;
385 hints.ai_flags = 0;
386
387 rc = getaddrinfo("magrathea", "wurst", &hints, &res);
388 assert_int_equal(rc, EAI_NONAME);
389
390 /* Check ldap port */
391 rc = getaddrinfo("magrathea", "ldap", &hints, &res);
392 assert_int_equal(rc, 0);
393 assert_non_null(res);
394
395 assert_int_equal(res->ai_family, AF_INET);
396 assert_int_equal(res->ai_socktype, SOCK_STREAM);
397
398 assert_non_null(res->ai_canonname);
399 assert_string_equal(res->ai_canonname, "magrathea.galaxy.site");
400
401 assert_non_null(res->ai_addr);
402 addr.sa = res->ai_addr;
403 ip = inet_ntoa(addr.in->sin_addr);
404
405 assert_string_equal(ip, "127.0.0.11");
406
407 assert_int_equal(ntohs(addr.in->sin_port), 389);
408
409 freeaddrinfo(res);
410 }
411
412 static void test_nwrap_getaddrinfo_null(void **state)
413 {
414 struct addrinfo hints;
415 struct addrinfo *res = NULL;
416 union {
417 struct sockaddr *sa;
418 struct sockaddr_in *in;
419 struct sockaddr_in6 *in6;
420 } addr;
421 char ip6[INET6_ADDRSTRLEN];
422 int rc;
423
424 (void) state; /* unused */
425
426 memset(&hints, 0, sizeof(struct addrinfo));
427 hints.ai_family = AF_INET6;
428 hints.ai_socktype = SOCK_DGRAM;
429 hints.ai_protocol = 17;
430 hints.ai_flags = 0;
431
432 rc = getaddrinfo(NULL, NULL, &hints, &res);
433 assert_int_equal(rc, EAI_NONAME);
434
435 /* Check dns service */
436 rc = getaddrinfo(NULL, "domain", &hints, &res);
437 assert_int_equal(rc, 0);
438
439 assert_non_null(res);
440 assert_null(res->ai_canonname);
441
442 assert_int_equal(res->ai_family, AF_INET6);
443 assert_int_equal(res->ai_socktype, SOCK_DGRAM);
444
445 assert_non_null(res->ai_addr);
446 addr.sa = res->ai_addr;
447 inet_ntop(AF_INET6, (void *)&addr.in6->sin6_addr, ip6, sizeof(ip6));
448
449 assert_string_equal(ip6, "::1");
450
451 freeaddrinfo(res);
452 res = NULL;
453
454 /* Check dns service */
455 rc = getaddrinfo("magrathea", "domain", NULL, &res);
456 assert_non_null(res);
457 assert_int_equal(rc, 0);
458
459 assert_non_null(res->ai_canonname);
460
461 freeaddrinfo(res);
462 }
463
464 static void test_nwrap_getaddrinfo_dot(void **state)
465 {
466 struct addrinfo hints = {
467 .ai_family = AF_INET,
468 };
469 struct addrinfo *res = NULL;
470 union {
471 struct sockaddr *sa;
472 struct sockaddr_in *in;
473 struct sockaddr_in6 *in6;
474 } addr;
475 char ip[INET_ADDRSTRLEN];
476 int rc;
477
478 (void) state; /* unused */
479
480 /* Check with a dot at the end */
481 rc = getaddrinfo("magrathea.galaxy.site.", NULL, &hints, &res);
482 assert_int_equal(rc, 0);
483 assert_non_null(res);
484
485 assert_non_null(res->ai_next);
486 assert_int_equal(res->ai_family, AF_INET);
487
488 addr.sa = res->ai_addr;
489 assert_int_equal(addr.in->sin_family, AF_INET);
490 inet_ntop(AF_INET, (void *)&addr.in->sin_addr, ip, sizeof(ip));
491
492 assert_string_equal(ip, "127.0.0.11");
493
494 freeaddrinfo(res);
495 }
496
497 static void test_nwrap_getaddrinfo_ipv6(void **state)
498 {
499 struct addrinfo hints;
500 struct addrinfo *res = NULL;
501 union {
502 struct sockaddr *sa;
503 struct sockaddr_in *in;
504 struct sockaddr_in6 *in6;
505 } addr;
506 char ip6[INET6_ADDRSTRLEN];
507 int rc;
508
509 (void) state; /* unused */
510
511 /*
512 * krikkit.galaxy has an IPv4 and IPv6 address, this should only
513 * return the IPv6 address.
514 */
515 memset(&hints, 0, sizeof(struct addrinfo));
516 hints.ai_family = AF_INET6;
517
518 rc = getaddrinfo("krikkit.galaxy.site", NULL, &hints, &res);
519 assert_int_equal(rc, 0);
520 assert_non_null(res);
521
522 assert_non_null(res->ai_next);
523 assert_int_equal(res->ai_family, AF_INET6);
524
525 addr.sa = res->ai_addr;
526 assert_int_equal(addr.in6->sin6_family, AF_INET6);
527 inet_ntop(AF_INET6, (void *)&addr.in6->sin6_addr, ip6, sizeof(ip6));
528
529 assert_string_equal(ip6, "::14");
530
531 freeaddrinfo(res);
532 }
533
534 static void test_nwrap_getaddrinfo_multiple_mixed(void **state)
535 {
536 struct addrinfo *res, *res_head;
537 struct addrinfo hints;
538 unsigned int ipv6_count = 0;
539 unsigned int ipv4_count = 0;
540 int rc;
541 int p;
542
543 union {
544 struct sockaddr *sa;
545 struct sockaddr_in *in;
546 struct sockaddr_in6 *in6;
547 } r_addr;
548
549 const char *result = NULL;
550 const char *value = NULL;
551
552 /* For inet_ntop call */
553 char buf[4096];
554
555 /* 2 - ipv4 and 3 ipv6 addresses */
556 const char *ipvX_results[] = {"127.1.1.1", "127.0.0.66", "2666::22", "B00B:5::4", "DEAD:BEEF:1:2:3::4", NULL};
557
558 (void) state; /* unused */
559
560 memset(&hints, '\0', sizeof(struct addrinfo));
561 hints.ai_protocol = IPPROTO_TCP;
562 hints.ai_family = AF_UNSPEC;
563 hints.ai_socktype = SOCK_STREAM;
564
565 rc = getaddrinfo("pumpkin.bunny.net", NULL, &hints, &res_head);
566 assert_return_code(rc, 0);
567 assert_non_null(res_head);
568
569 for (res = res_head; res != NULL; res = res->ai_next) {
570 if (res->ai_family == AF_INET) {
571 r_addr.sa = res->ai_addr;
572 assert_non_null(r_addr.sa);
573 ++ipv4_count;
574 result = inet_ntop(AF_INET,
575 &r_addr.in->sin_addr,
576 buf,
577 4096);
578 } else if (res->ai_family == AF_INET6) {
579 r_addr.sa = res->ai_addr;
580 assert_non_null(r_addr.sa);
581 ++ipv6_count;
582 result = inet_ntop(AF_INET6,
583 &r_addr.in6->sin6_addr,
584 buf,
585 4096);
586 } else {
587 /* Unknown family type */
588 assert_int_equal(1,0);
589 }
590
591 /* Important part */
592 assert_non_null(result);
593
594 /* This could be part of cmocka library */
595 for (value = ipvX_results[0], p = 0; value != NULL; value = ipvX_results[++p]) {
596 if (strcasecmp(value, result) == 0) {
597 break;
598 }
599 }
600 assert_non_null(value);
601 }
602
603 assert_int_equal(ipv6_count, 3);
604 assert_int_equal(ipv4_count, 2);
605
606 freeaddrinfo(res_head);
607 }
608
609 static void test_nwrap_getaddrinfo_flags_ai_numericserv(void **state)
610 {
611 struct addrinfo hints;
612 struct addrinfo *res;
613 int rc;
614
615 (void) state; /* unused */
616
617 memset(&hints, 0, sizeof(struct addrinfo));
618 hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */
619 hints.ai_socktype = SOCK_DGRAM; /* Datagram socket */
620 hints.ai_flags = AI_PASSIVE | AI_NUMERICSERV; /* For wildcard IP address */
621 hints.ai_protocol = 0; /* Any protocol */
622 hints.ai_canonname = NULL;
623
624 /*
625 * Calls with NULL name are handled by libc,
626 * even if nss_wrapper is enabled
627 */
628
629 rc = getaddrinfo(NULL, "echo", &hints, &res);
630 #ifdef HAVE_GETADDRINFO_USES_EAI_SERVICE
631 assert_int_equal(rc, EAI_SERVICE);
632 #else /* HAVE_GETADDRINFO_USES_EAI_SERVICE */
633 assert_int_equal(rc, EAI_NONAME);
634 #endif /* HAVE_GETADDRINFO_USES_EAI_SERVICE */
635
636 rc = getaddrinfo(NULL, "80", &hints, &res);
637 assert_int_equal(rc, 0);
638 freeaddrinfo(res);
639 res = NULL;
640
641 /* Crippled input */
642 rc = getaddrinfo(NULL, "80a1", &hints, &res);
643 #ifdef HAVE_GETADDRINFO_USES_EAI_SERVICE
644 assert_int_equal(rc, EAI_SERVICE);
645 #else /* HAVE_GETADDRINFO_USES_EAI_SERVICE */
646 assert_int_equal(rc, EAI_NONAME);
647 #endif /* HAVE_GETADDRINFO_USES_EAI_SERVICE */
648
649 /*
650 * Calls with non-NULL name are handled by nwrap
651 */
652
653 rc = getaddrinfo("magrathea.galaxy.site", "echo", &hints, &res);
654 assert_int_equal(rc, EAI_NONAME);
655
656 rc = getaddrinfo("magrathea.galaxy.site", "80", &hints, &res);
657 assert_int_equal(rc, 0);
658 freeaddrinfo(res);
659 res = NULL;
660
661 /* Crippled input */
662 rc = getaddrinfo("magrathea.galaxy.site", "80a1", &hints, &res);
663 assert_int_equal(rc, EAI_NONAME);
664 }
665
666 static void test_nwrap_getaddrinfo_flags_ai_numerichost(void **state)
667 {
668 struct addrinfo hints;
669 struct addrinfo *res;
670 int rc;
671
672 (void) state; /* unused */
673
674 memset(&hints, 0, sizeof(struct addrinfo));
675 hints.ai_socktype = SOCK_DGRAM; /* Datagram socket */
676 hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST; /* For wildcard IP address */
677 hints.ai_protocol = 0; /* Any protocol */
678 hints.ai_canonname = NULL;
679
680 /* IPv4 or IPv6 */
681
682 hints.ai_family = AF_UNSPEC;
683
684 rc = getaddrinfo("127.0.0.11", NULL, &hints, &res);
685 assert_int_equal(rc, 0);
686 freeaddrinfo(res);
687
688 rc = getaddrinfo("::1", NULL, &hints, &res);
689 assert_int_equal(rc, 0);
690 freeaddrinfo(res);
691
692 rc = getaddrinfo(NULL, "echo", &hints, &res);
693 assert_int_equal(rc, 0);
694 freeaddrinfo(res);
695
696 rc = getaddrinfo("magrathea.galaxy.site", NULL, &hints, &res);
697 assert_int_equal(rc, EAI_NONAME);
698
699 rc = getaddrinfo("", NULL, &hints, &res);
700 assert_int_equal(rc, EAI_NONAME);
701
702 rc = getaddrinfo("fail.me", "echo", &hints, &res);
703 assert_int_equal(rc, EAI_NONAME);
704
705 /* IPv4 */
706
707 hints.ai_family = AF_INET;
708
709 rc = getaddrinfo("127.0.0.11", NULL, &hints, &res);
710 assert_int_equal(rc, 0);
711 freeaddrinfo(res);
712
713 rc = getaddrinfo("::1", NULL, &hints, &res);
714 #ifdef EAI_ADDRFAMILY
715 assert_int_equal(rc, EAI_ADDRFAMILY);
716 #else
717 assert_int_equal(rc, EAI_FAMILY);
718 #endif
719
720 rc = getaddrinfo(NULL, "echo", &hints, &res);
721 assert_int_equal(rc, 0);
722 freeaddrinfo(res);
723
724 rc = getaddrinfo("magrathea.galaxy.site", NULL, &hints, &res);
725 assert_int_equal(rc, EAI_NONAME);
726
727 rc = getaddrinfo("", NULL, &hints, &res);
728 assert_int_equal(rc, EAI_NONAME);
729
730 rc = getaddrinfo("fail.me", "echo", &hints, &res);
731 assert_int_equal(rc, EAI_NONAME);
732
733
734 /* IPv6 */
735
736 hints.ai_family = AF_INET6;
737
738 rc = getaddrinfo("127.0.0.11", NULL, &hints, &res);
739 #ifdef EAI_ADDRFAMILY
740 assert_int_equal(rc, EAI_ADDRFAMILY);
741 #else
742 assert_int_equal(rc, EAI_FAMILY);
743 #endif
744
745 rc = getaddrinfo("::1", NULL, &hints, &res);
746 assert_int_equal(rc, 0);
747 freeaddrinfo(res);
748
749 rc = getaddrinfo(NULL, "echo", &hints, &res);
750 assert_int_equal(rc, 0);
751 freeaddrinfo(res);
752
753 rc = getaddrinfo("magrathea.galaxy.site", NULL, &hints, &res);
754 assert_int_equal(rc, EAI_NONAME);
755
756 rc = getaddrinfo("", NULL, &hints, &res);
757 assert_int_equal(rc, EAI_NONAME);
758
759 rc = getaddrinfo("fail.me", "echo", &hints, &res);
760 assert_int_equal(rc, EAI_NONAME);
761 }
762
763 int main(void) {
764 int rc;
765
766 const struct CMUnitTest tests[] = {
767 cmocka_unit_test(test_nwrap_getaddrinfo),
768 cmocka_unit_test(test_nwrap_getaddrinfo_reload),
769 cmocka_unit_test(test_nwrap_getaddrinfo_any),
770 cmocka_unit_test(test_nwrap_getaddrinfo_local),
771 cmocka_unit_test(test_nwrap_getaddrinfo_name),
772 cmocka_unit_test(test_nwrap_getaddrinfo_service),
773 cmocka_unit_test(test_nwrap_getaddrinfo_null),
774 cmocka_unit_test(test_nwrap_getaddrinfo_dot),
775 cmocka_unit_test(test_nwrap_getaddrinfo_ipv6),
776 cmocka_unit_test(test_nwrap_getaddrinfo_multiple_mixed),
777 cmocka_unit_test(test_nwrap_getaddrinfo_flags_ai_numericserv),
778 cmocka_unit_test(test_nwrap_getaddrinfo_flags_ai_numerichost),
779 cmocka_unit_test(test_nwrap_getaddrinfo_samba),
780 };
781
782 rc = cmocka_run_group_tests(tests, NULL, NULL);
783
784 return rc;
785 }