1 //==========================================================================
5 // Simple test of DNS client support
7 //==========================================================================
8 //####ECOSGPLCOPYRIGHTBEGIN####
9 // -------------------------------------------
10 // This file is part of eCos, the Embedded Configurable Operating System.
11 // Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
12 // Copyright (C) 2003 Andrew Lunn
14 // eCos is free software; you can redistribute it and/or modify it under
15 // the terms of the GNU General Public License as published by the Free
16 // Software Foundation; either version 2 or (at your option) any later version.
18 // eCos is distributed in the hope that it will be useful, but WITHOUT ANY
19 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
20 // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
23 // You should have received a copy of the GNU General Public License along
24 // with eCos; if not, write to the Free Software Foundation, Inc.,
25 // 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
27 // As a special exception, if other files instantiate templates or use macros
28 // or inline functions from this file, or you compile this file and link it
29 // with other works to produce a work based on this file, this file does not
30 // by itself cause the resulting work to be covered by the GNU General Public
31 // License. However the source code for this file must still be made available
32 // in accordance with section (3) of the GNU General Public License.
34 // This exception does not invalidate any other reasons why a work based on
35 // this file might be covered by the GNU General Public License.
37 // Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
38 // at http://sources.redhat.com/ecos/ecos-license/
39 // -------------------------------------------
40 //####ECOSGPLCOPYRIGHTEND####
41 //==========================================================================
42 //#####DESCRIPTIONBEGIN####
44 // Author(s): andrew.lunn
45 // Contributors: andrew.lunn, jskov
48 // Description: Test DNS functions. Note that the structure below that
49 // control what addresses the test uses. These must be
50 // changed to match the particular testing network in which
51 // the test is to be run.
53 //####DESCRIPTIONEND####
55 //==========================================================================
56 #include <pkgconf/ns_dns.h>
61 #include <arpa/inet.h>
63 #include <cyg/infra/testcase.h>
65 #define STACK_SIZE (CYGNUM_HAL_STACK_SIZE_TYPICAL + 0x1000)
66 static char stack[STACK_SIZE];
67 static cyg_thread thread_data;
68 static cyg_handle_t thread_handle;
82 char * ip_addr_v46_v4;
83 char * ip_addr_v46_v6;
86 struct test_info_s test_info[] = {
87 #if CYGPKG_NS_DNS_TESTS_ELSIS
104 #ifdef CYGPKG_NS_DNS_TESTS_LUNN
107 "3ffe:bc0:8000::839",
123 char * familytoa(int family) {
128 #ifdef CYGPKG_NET_INET6
137 void dns_test(struct test_info_s *info) {
139 struct hostent *hent;
145 size_t hostlen = 128;
147 struct addrinfo * res;
148 struct addrinfo hints;
149 struct sockaddr_in sa4;
150 #ifdef CYGPKG_NET_INET6
151 struct sockaddr_in6 sa6;
152 struct addrinfo *ai4, *ai6;
156 if (inet_pton(AF_INET, info->dns_server_v4, (void *)&addr) < 0) {
157 CYG_TEST_FAIL_FINISH("Error with DNS server address");
159 cyg_dns_res_init(&addr);
161 setdomainname(NULL,0);
163 inet_aton(info->ip_addr_v4, &addr);
164 strcpy(name,info->hostname_v4);
166 strcat(name,info->domain_name);
167 strcpy(cname,info->cname_v4);
169 strcat(cname,info->domain_name);
171 // Lookup the IPv4 FQDN hostname
172 hent = gethostbyname(name);
174 diag_sprintf(buffer,"Lookup %s: Result <%s is %s>",
177 inet_ntoa(*(struct in_addr *)hent->h_addr));
178 CYG_TEST_INFO(buffer);
179 CYG_TEST_PASS_FAIL((0 == memcmp((void*)&addr,
180 (void*)(hent->h_addr),
181 sizeof(struct in_addr))),
182 "IPv4 FQDN hostname address");
183 CYG_TEST_PASS_FAIL((0 == strcmp(name, hent->h_name)),
184 "IPv4 FQDN hostname name");
186 diag_sprintf(buffer,"IPv4 FQDN hostname: error %s",
188 CYG_TEST_FAIL(buffer);
191 // Lookup the IPv4 FQDN cname
192 hent = gethostbyname(cname);
194 diag_sprintf(buffer,"Lookup %s: Result <%s is %s>",
197 inet_ntoa(*(struct in_addr *)hent->h_addr));
198 CYG_TEST_INFO(buffer);
199 CYG_TEST_PASS_FAIL((0 == memcmp((void*)&addr,
200 (void*)(hent->h_addr),
201 sizeof(struct in_addr))),
202 "IPv4 FQDN cname address");
203 CYG_TEST_PASS_FAIL((0 == strcmp(name, hent->h_name)),
204 "IPv4 FQDN hostname name");
206 diag_sprintf(buffer,"IPv4 FQDN cname: error %s", hstrerror(h_errno));
207 CYG_TEST_FAIL(buffer);
210 // Lookup the IP address as a string. This does not require a DNS
211 // lookup. Just turn the value into binary
212 hent = gethostbyname(info->ip_addr_v4);
214 diag_sprintf(buffer,"Lookup %s: Result <%s is %s>",
217 inet_ntoa(*(struct in_addr *)hent->h_addr));
218 CYG_TEST_INFO(buffer);
219 CYG_TEST_PASS_FAIL((0 == memcmp((void*)&addr,
220 (void*)(hent->h_addr),
221 sizeof(struct in_addr))),
223 CYG_TEST_PASS_FAIL((0 == strcmp(info->ip_addr_v4, hent->h_name)),
224 "IPv4 IP address name");
227 diag_sprintf(buffer,"IPv4 IP address: error %s", hstrerror(h_errno));
228 CYG_TEST_FAIL(buffer);
231 // Reverse lookup the IPv4 address, expect the FQDN hostname
232 hent = gethostbyaddr((char *)&addr, sizeof(struct in_addr), AF_INET);
234 inet_ntop(AF_INET,(void *)&addr, buff, sizeof(buff));
235 diag_sprintf(buffer,"Reverse lookup %s: Result <%s is %s>",
238 inet_ntoa(*(struct in_addr *)hent->h_addr));
239 CYG_TEST_INFO(buffer);
240 CYG_TEST_PASS_FAIL((0 == memcmp((void*)&addr,
241 (void*)(hent->h_addr),
242 sizeof(struct in_addr))),
243 "Reverse lookup IPv4 IP address");
245 CYG_TEST_PASS_FAIL((0 == strcmp(name, hent->h_name)),
246 "Reverse lookup IPv4 IP address name");
248 diag_sprintf(buffer,"Reverse lookup IPv4 IP address: error %s",
250 CYG_TEST_FAIL(buffer);
253 // Setup a domainname. We now don't have to use fully qualified
255 setdomainname(info->domain_name, strlen(info->domain_name));
256 getdomainname(dn, sizeof(dn));
257 CYG_TEST_PASS_FAIL(0 == strcmp(info->domain_name, dn),
258 "{get|set}domainname");
260 // Make sure FQDN still work
261 strcpy(name,info->hostname_v4);
263 strcat(name,info->domain_name);
265 hent = gethostbyname(name);
267 diag_sprintf(buffer,"Lookup %s: Result <%s is %s>",
270 inet_ntoa(*(struct in_addr *)hent->h_addr));
271 CYG_TEST_INFO(buffer);
272 CYG_TEST_PASS_FAIL((0 == memcmp((void*)&addr,
273 (void*)(hent->h_addr),
274 sizeof(struct in_addr))),
275 "IPv4 FQDN hostname address");
276 CYG_TEST_PASS_FAIL((0 == strcmp(name, hent->h_name)),
277 "IPv4 FQDN hostname name");
279 diag_sprintf(buffer,"IPv4 FQDN hostname: error %s",
281 CYG_TEST_FAIL(buffer);
284 // Now just the hostname
285 hent = gethostbyname(info->hostname_v4);
287 diag_sprintf(buffer,"Lookup %s: Result <%s is %s>",
290 inet_ntoa(*(struct in_addr *)hent->h_addr));
291 CYG_TEST_INFO(buffer);
292 CYG_TEST_PASS_FAIL((0 == memcmp((void*)&addr,
293 (void*)(hent->h_addr),
294 sizeof(struct in_addr))),
295 "IPv4 hostname address");
296 CYG_TEST_PASS_FAIL((0 == strcmp(name, hent->h_name)),
297 "IPv4 hostname name");
299 diag_sprintf(buffer,"IPv4 hostname: error %s", hstrerror(h_errno));
300 CYG_TEST_FAIL(buffer);
303 // Run the same tests as above, but this time use getaddrinfo and
305 setdomainname(NULL,0);
307 memset(&hints,0,sizeof(hints));
308 hints.ai_flags = AI_CANONNAME;
309 memset(&sa4,0,sizeof(sa4));
310 memcpy(&sa4.sin_addr, &addr, sizeof(addr));
311 sa4.sin_family=AF_INET;
312 sa4.sin_len = sizeof(sa4);
314 // Lookup the IPv4 FQDN hostname
315 error = getaddrinfo(name, NULL, &hints, &res);
317 if (error == EAI_NONE) {
318 getnameinfo(res->ai_addr, res->ai_addrlen,
320 NULL,0,NI_NUMERICHOST);
321 diag_sprintf(buffer,"Lookup %s: Result <%s is %s %s>",
324 familytoa(res->ai_family),
326 CYG_TEST_INFO(buffer);
327 CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa4,
330 (res->ai_family == AF_INET),
331 "IPv4 FQDN hostname address");
332 CYG_TEST_PASS_FAIL((0 == strcmp(name, res->ai_canonname)),
333 "IPv4 FQDN hostname name");
334 CYG_TEST_PASS_FAIL((NULL == res->ai_next),
335 "IPv4 FQDN hostname one result");
338 diag_sprintf(buffer,"IPv4 FQDN hostname: error %s",
339 gai_strerror(error));
340 CYG_TEST_FAIL(buffer);
343 // Lookup the IPv4 FQDN cname
344 error = getaddrinfo(cname, NULL, &hints, &res);
346 if (error == EAI_NONE) {
347 getnameinfo(res->ai_addr, res->ai_addrlen,
349 NULL,0,NI_NUMERICHOST);
350 diag_sprintf(buffer,"Lookup %s: Result <%s is %s %s>",
353 familytoa(res->ai_family),
355 CYG_TEST_INFO(buffer);
356 CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa4,
359 (res->ai_family == AF_INET),
360 "IPv4 FQDN cname address");
361 CYG_TEST_PASS_FAIL((0 == strcmp(name, res->ai_canonname)),
362 "IPv4 FQDN cname name");
363 CYG_TEST_PASS_FAIL((NULL == res->ai_next),
364 "IPv4 FQDN cname one result");
367 diag_sprintf(buffer,"IPv4 FQDN cname: error %s", gai_strerror(error));
368 CYG_TEST_FAIL(buffer);
371 // Lookup the IP address as a string. This does not require a DNS
372 // lookup. Just turn the value into binary
373 hints.ai_flags = AI_NUMERICHOST;
374 error = getaddrinfo(info->ip_addr_v4, NULL, &hints, &res);
376 if (error == EAI_NONE) {
377 getnameinfo(res->ai_addr, res->ai_addrlen,
379 NULL,0,NI_NUMERICHOST);
380 diag_sprintf(buffer,"Lookup %s: Result <%s %s>",
382 familytoa(res->ai_family),
384 CYG_TEST_INFO(buffer);
385 CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa4,
388 (res->ai_family == AF_INET),
390 CYG_TEST_PASS_FAIL((NULL == res->ai_canonname),
391 "IPv4 IP address name");
392 CYG_TEST_PASS_FAIL((NULL == res->ai_next),
393 "IPv4 IP address one result");
394 // Don't free results - use for next test.
396 diag_sprintf(buffer,"IPv4 IP address: error %s", gai_strerror(error));
397 CYG_TEST_FAIL(buffer);
400 // Reverse lookup the IPv4 address, expect the FQDN hostname
401 error = getnameinfo(res->ai_addr,res->ai_addrlen,
402 host, hostlen, NULL, 0, 0);
403 if (error == EAI_NONE) {
404 diag_sprintf(buffer, "IPv4 Reverse lookup FDQN %s: Result %s",
407 CYG_TEST_INFO(buffer);
408 CYG_TEST_PASS_FAIL((0 == strcmp(name, host)),
409 "IPv4 Reverse lookup FQDN");
411 diag_sprintf(buffer,"IPv4 Reverse lookup FQDN: error %s",
412 gai_strerror(error));
413 CYG_TEST_FAIL(buffer);
415 // Reverse lookup the IPv4 address, expect just the hostname part
416 error = getnameinfo(res->ai_addr,res->ai_addrlen,
417 host, hostlen, NULL, 0, NI_NOFQDN);
418 if (error == EAI_NONE) {
419 diag_sprintf(buffer, "IPv4 Reverse lookup hostname part %s: Result %s",
422 CYG_TEST_INFO(buffer);
423 CYG_TEST_PASS_FAIL((0 == strcmp(info->hostname_v4, host)),
424 "IPv4 Reverse lookup hostname part");
426 diag_sprintf(buffer,"IPv4 Reverse lookup hostname part: error %s",
427 gai_strerror(error));
428 CYG_TEST_FAIL(buffer);
432 // Setup a domainname. We now don't have to use fully qualified
434 setdomainname(info->domain_name, strlen(info->domain_name));
435 getdomainname(dn, sizeof(dn));
436 CYG_TEST_PASS_FAIL(0 == strcmp(info->domain_name, dn),
437 "{get|set}domainname");
439 // Lookup the IPv4 FQDN hostname to make sure it still works
440 hints.ai_flags = AI_CANONNAME;
441 error = getaddrinfo(name, NULL, &hints, &res);
443 if (error == EAI_NONE) {
444 getnameinfo(res->ai_addr, res->ai_addrlen,
446 NULL,0,NI_NUMERICHOST);
447 diag_sprintf(buffer,"Lookup %s: Result <%s is %s %s>",
450 familytoa(res->ai_family),
452 CYG_TEST_INFO(buffer);
453 CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa4,
456 (res->ai_family == AF_INET),
457 "IPv4 FQDN hostname address");
458 CYG_TEST_PASS_FAIL((0 == strcmp(name, res->ai_canonname)),
459 "IPv4 FQDN hostname name");
460 CYG_TEST_PASS_FAIL((NULL == res->ai_next),
461 "IPv4 FQDN hostname one result");
464 diag_sprintf(buffer,"IPv4 FQDN hostname: error %s",
465 gai_strerror(error));
466 CYG_TEST_FAIL(buffer);
469 // Now the host name without the domain name
470 error = getaddrinfo(info->hostname_v4, NULL, &hints, &res);
472 if (error == EAI_NONE) {
473 getnameinfo(res->ai_addr, res->ai_addrlen,
475 NULL,0,NI_NUMERICHOST);
476 diag_sprintf(buffer,"Lookup %s: Result <%s is %s %s>",
479 familytoa(res->ai_family),
481 CYG_TEST_INFO(buffer);
482 CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa4,
485 (res->ai_family == AF_INET),
486 "IPv4 hostname address");
487 CYG_TEST_PASS_FAIL((0 == strcmp(name, res->ai_canonname)),
488 "IPv4 hostname name");
489 CYG_TEST_PASS_FAIL((NULL == res->ai_next),
490 "IPv4 hostname one result");
493 diag_sprintf(buffer,"IPv4 hostname: error %s",
494 gai_strerror(error));
495 CYG_TEST_FAIL(buffer);
497 #ifdef CYGPKG_NET_INET6
498 // Check we have the needed information for the IPv6 tests
499 if (!info->hostname_v6 || !info->cname_v6 || !info->ip_addr_v6) {
503 setdomainname(NULL,0);
505 strcpy(name,info->hostname_v6);
507 strcat(name,info->domain_name);
508 strcpy(cname,info->cname_v6);
510 strcat(cname,info->domain_name);
512 memset(&sa6,0,sizeof(sa6));
513 sa6.sin6_family = AF_INET6;
514 sa6.sin6_len = sizeof(sa6);
515 inet_pton(AF_INET6, info->ip_addr_v6, (void *)&sa6.sin6_addr);
517 // Lookup the IPv6 FQDN hostname
518 error = getaddrinfo(name, NULL, &hints, &res);
520 if (error == EAI_NONE) {
521 getnameinfo(res->ai_addr, res->ai_addrlen,
523 NULL,0,NI_NUMERICHOST);
524 diag_sprintf(buffer,"Lookup %s: Result <%s is %s %s>",
527 familytoa(res->ai_family),
529 CYG_TEST_INFO(buffer);
530 CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa6,
533 (res->ai_family == AF_INET6),
534 "IPv6 FQDN hostname address");
535 CYG_TEST_PASS_FAIL((0 == strcmp(name, res->ai_canonname)),
536 "IPv6 FQDN hostname name");
537 CYG_TEST_PASS_FAIL((NULL == res->ai_next),
538 "IPv6 FQDN hostname one result");
541 diag_sprintf(buffer,"IPv6 FQDN hostname: error %s",
542 gai_strerror(error));
543 CYG_TEST_FAIL(buffer);
546 // Lookup the IPv6 FQDN cname
547 error = getaddrinfo(cname, NULL, &hints, &res);
549 if (error == EAI_NONE) {
550 getnameinfo(res->ai_addr, res->ai_addrlen,
552 NULL,0,NI_NUMERICHOST);
553 diag_sprintf(buffer,"Lookup %s: Result <%s is %s %s>",
556 familytoa(res->ai_family),
558 CYG_TEST_INFO(buffer);
559 CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa6,
562 (res->ai_family == AF_INET6),
563 "IPv6 FQDN cname address");
564 CYG_TEST_PASS_FAIL((0 == strcmp(name, res->ai_canonname)),
565 "IPv6 FQDN cname name");
566 CYG_TEST_PASS_FAIL((NULL == res->ai_next),
567 "IPv6 FQDN cname one result");
570 diag_sprintf(buffer,"IPv6 FQDN cname: error %s",
571 gai_strerror(error));
572 CYG_TEST_FAIL(buffer);
575 // Lookup the IP address as a string. This does not require a DNS
576 // lookup. Just turn the value into binary
577 hints.ai_flags = AI_NUMERICHOST;
578 error = getaddrinfo(info->ip_addr_v6, NULL, &hints, &res);
580 if (error == EAI_NONE) {
581 getnameinfo(res->ai_addr, res->ai_addrlen,
583 NULL,0,NI_NUMERICHOST);
584 diag_sprintf(buffer,"Lookup %s: Result <%s %s>",
586 familytoa(res->ai_family),
588 CYG_TEST_INFO(buffer);
589 CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa6,
592 (res->ai_family == AF_INET6),
594 CYG_TEST_PASS_FAIL((NULL == res->ai_canonname),
595 "IPv6 IP address name");
596 CYG_TEST_PASS_FAIL((NULL == res->ai_next),
597 "IPv6 IP address one result");
598 // Don't free the result, use it in the next tests
600 diag_sprintf(buffer,"IPv6 IP address: error %s", gai_strerror(error));
601 CYG_TEST_FAIL(buffer);
604 // Reverse lookup the IPv6 address, expect the FQDN hostname
605 error = getnameinfo(res->ai_addr,res->ai_addrlen,
606 host, hostlen, NULL, 0, 0);
607 if (error == EAI_NONE) {
608 diag_sprintf(buffer, "IPv6 Reverse lookup FDQN %s: Result %s",
611 CYG_TEST_INFO(buffer);
612 CYG_TEST_PASS_FAIL((0 == strcmp(name, host)),
613 "IPv6 Reverse lookup FQDN");
615 diag_sprintf(buffer,"IPv6 Reverse lookup FQDN: error %s",
616 gai_strerror(error));
617 CYG_TEST_FAIL(buffer);
619 // Reverse lookup the IPv6 address, expect just the hostname part
620 error = getnameinfo(res->ai_addr,res->ai_addrlen,
621 host, hostlen, NULL, 0, NI_NOFQDN);
622 if (error == EAI_NONE) {
623 diag_sprintf(buffer, "IPv6 Reverse lookup hostname part %s: Result %s",
626 CYG_TEST_INFO(buffer);
627 CYG_TEST_PASS_FAIL((0 == strcmp(info->hostname_v6, host)),
628 "IPv6 Reverse lookup hostname part");
630 diag_sprintf(buffer,"IPv6 Reverse lookup hostname part: error %s",
631 gai_strerror(error));
632 CYG_TEST_FAIL(buffer);
636 // Setup a domainname. We now don't have to use fully qualified
638 setdomainname(info->domain_name, strlen(info->domain_name));
639 getdomainname(dn, sizeof(dn));
640 CYG_TEST_PASS_FAIL(0 == strcmp(info->domain_name, dn),
641 "{get|set}domainname");
643 // Lookup the IPv6 FQDN hostname to make sure it still works
644 hints.ai_flags = AI_CANONNAME;
645 error = getaddrinfo(name, NULL, &hints, &res);
647 if (error == EAI_NONE) {
648 getnameinfo(res->ai_addr, res->ai_addrlen,
650 NULL,0,NI_NUMERICHOST);
651 diag_sprintf(buffer,"Lookup %s: Result <%s is %s %s>",
654 familytoa(res->ai_family),
656 CYG_TEST_INFO(buffer);
657 CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa6,
660 (res->ai_family == AF_INET6),
661 "IPv6 FQDN hostname address");
662 CYG_TEST_PASS_FAIL((0 == strcmp(name, res->ai_canonname)),
663 "IPv6 FQDN hostname name");
664 CYG_TEST_PASS_FAIL((NULL == res->ai_next),
665 "IPv6 FQDN hostname one result");
668 diag_sprintf(buffer,"IPv6 FQDN hostname: error %s",
669 gai_strerror(error));
670 CYG_TEST_FAIL(buffer);
673 // Now the host name without the domain name
674 error = getaddrinfo(info->hostname_v6, NULL, &hints, &res);
676 if (error == EAI_NONE) {
677 getnameinfo(res->ai_addr, res->ai_addrlen,
679 NULL,0,NI_NUMERICHOST);
680 diag_sprintf(buffer,"Lookup %s: Result <%s is %s %s>",
683 familytoa(res->ai_family),
685 CYG_TEST_INFO(buffer);
686 CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa6,
689 (res->ai_family == AF_INET6),
690 "IPv6 hostname address");
691 CYG_TEST_PASS_FAIL((0 == strcmp(name, res->ai_canonname)),
692 "IPv6 hostname name");
693 CYG_TEST_PASS_FAIL((NULL == res->ai_next),
694 "IPv6 hostname one result");
697 diag_sprintf(buffer,"IPv6 hostname: error %s",
698 gai_strerror(error));
699 CYG_TEST_FAIL(buffer);
702 // Check if we have the information to do tests which result in two
703 // answers, an AF_INET and an AF_INET6
704 if (!info->hostname_v46 || !info->cname_v46 ||
705 !info->ip_addr_v46_v4 || !info->ip_addr_v46_v6 ) {
708 setdomainname(NULL,0);
710 strcpy(name,info->hostname_v46);
712 strcat(name,info->domain_name);
713 strcpy(cname,info->cname_v46);
715 strcat(cname,info->domain_name);
717 inet_aton(info->ip_addr_v46_v4, &addr);
718 memset(&sa4,0,sizeof(sa4));
719 memcpy(&sa4.sin_addr, &addr, sizeof(addr));
720 sa4.sin_family=AF_INET;
721 sa4.sin_len = sizeof(sa4);
723 memset(&sa6,0,sizeof(sa6));
724 sa6.sin6_family = AF_INET6;
725 sa6.sin6_len = sizeof(sa6);
726 inet_pton(AF_INET6, info->ip_addr_v46_v6, (void *)&sa6.sin6_addr);
728 // Lookup the IPv4 and IPv6 FQDN hostname
729 error = getaddrinfo(name, NULL, &hints, &res);
731 if (error == EAI_NONE) {
732 #ifdef CYGOPT_NS_DNS_FIRST_FAMILY_AF_INET6
735 CYG_TEST_PASS_FAIL((NULL != ai6->ai_next),
736 "IPv6 FQDN hostname not one result");
737 CYG_TEST_PASS_FAIL((NULL == ai4->ai_next),
738 "IPv4 & IPv6 FQDN hostname two results");
742 CYG_TEST_PASS_FAIL((NULL != ai4->ai_next),
743 "IPv6 FQDN hostname not one result");
744 CYG_TEST_PASS_FAIL((NULL == ai6->ai_next),
745 "IPv4 & IPv6 FQDN hostname two results");
747 getnameinfo(ai4->ai_addr, ai4->ai_addrlen,
749 NULL,0,NI_NUMERICHOST);
750 diag_sprintf(buffer,"Lookup %s: Result <%s is %s %s>",
753 familytoa(ai4->ai_family),
755 CYG_TEST_INFO(buffer);
756 CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa4,
759 (ai4->ai_family == AF_INET),
760 "IPv4 & IPv6 FQDN hostname address IPv4");
761 CYG_TEST_PASS_FAIL((0 == strcmp(name, ai4->ai_canonname)),
762 "IPv4 & IPv6 FQDN hostname name");
763 getnameinfo(ai6->ai_addr, ai6->ai_addrlen,
765 NULL,0,NI_NUMERICHOST);
766 diag_sprintf(buffer,"Lookup %s: Result <%s %s>",
768 familytoa(ai6->ai_family),
770 CYG_TEST_INFO(buffer);
771 CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa6,
774 (ai6->ai_family == AF_INET6),
775 "IPv4 & IPv6 FQDN hostname address IPv6");
778 diag_sprintf(buffer,"IPv4 & IPv6 FQDN hostname: error %s",
779 gai_strerror(error));
780 CYG_TEST_FAIL(buffer);
783 // Lookup the IPv4 and IPv6 FQDN cname
784 error = getaddrinfo(cname, NULL, &hints, &res);
786 if (error == EAI_NONE) {
787 #ifdef CYGOPT_NS_DNS_FIRST_FAMILY_AF_INET6
790 CYG_TEST_PASS_FAIL((NULL != ai6->ai_next),
791 "IPv6 FQDN hostname not one result");
792 CYG_TEST_PASS_FAIL((NULL == ai4->ai_next),
793 "IPv4 & IPv6 FQDN hostname two results");
797 CYG_TEST_PASS_FAIL((NULL != ai4->ai_next),
798 "IPv6 FQDN hostname not one result");
799 CYG_TEST_PASS_FAIL((NULL == ai6->ai_next),
800 "IPv4 & IPv6 FQDN hostname two results");
802 getnameinfo(ai4->ai_addr, ai4->ai_addrlen,
804 NULL,0,NI_NUMERICHOST);
805 diag_sprintf(buffer,"Lookup %s: Result <%s is %s %s>",
808 familytoa(ai4->ai_family),
810 CYG_TEST_INFO(buffer);
811 CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa4,
814 (ai4->ai_family == AF_INET),
815 "IPv4 & IPv6 FQDN cname address IPv4");
816 CYG_TEST_PASS_FAIL((0 == strcmp(name, ai4->ai_canonname)),
817 "IPv4 & IPv6 FQDN cname name");
818 getnameinfo(ai6->ai_addr, ai6->ai_addrlen,
820 NULL,0,NI_NUMERICHOST);
821 diag_sprintf(buffer,"Lookup %s: Result <%s %s>",
823 familytoa(ai6->ai_family),
825 CYG_TEST_INFO(buffer);
826 CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa6,
829 (ai6->ai_family == AF_INET6),
830 "IPv4 & IPv6 FQDN cname address IPv6");
833 diag_sprintf(buffer,"IPv4 & IPv6 FQDN cname: error %s",
834 gai_strerror(error));
835 CYG_TEST_FAIL(buffer);
838 if (info->dns_server_v6) {
839 cyg_dns_res_start(info->dns_server_v6);
840 // Lookup the IPv4 and IPv6 FQDN cname
841 error = getaddrinfo(cname, NULL, &hints, &res);
843 if (error == EAI_NONE) {
844 #ifdef CYGOPT_NS_DNS_FIRST_FAMILY_AF_INET6
847 CYG_TEST_PASS_FAIL((NULL != ai6->ai_next),
848 "[IPv6] IPv6 FQDN hostname not one result");
849 CYG_TEST_PASS_FAIL((NULL == ai4->ai_next),
850 "[IPv6] IPv4 & IPv6 FQDN hostname two results");
854 CYG_TEST_PASS_FAIL((NULL != ai4->ai_next),
855 "[IPv6] IPv6 FQDN hostname not one result");
856 CYG_TEST_PASS_FAIL((NULL == ai6->ai_next),
857 "[IPv6] IPv4 & IPv6 FQDN hostname two results");
859 getnameinfo(ai4->ai_addr, ai4->ai_addrlen,
861 NULL,0,NI_NUMERICHOST);
862 diag_sprintf(buffer,"[IPv6] Lookup %s: Result <%s is %s %s>",
865 familytoa(ai4->ai_family),
867 CYG_TEST_INFO(buffer);
868 CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa4,
871 (ai4->ai_family == AF_INET),
872 "[IPv6] IPv4 & IPv6 FQDN cname address IPv4");
873 CYG_TEST_PASS_FAIL((0 == strcmp(name, ai4->ai_canonname)),
874 "[IPv6] IPv4 & IPv6 FQDN cname name");
875 getnameinfo(ai6->ai_addr, ai6->ai_addrlen,
877 NULL,0,NI_NUMERICHOST);
878 diag_sprintf(buffer,"[IPv6] Lookup %s: Result <%s %s>",
880 familytoa(ai6->ai_family),
882 CYG_TEST_INFO(buffer);
883 CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa6,
886 (ai6->ai_family == AF_INET6),
887 "[IPv6] IPv4 & IPv6 FQDN cname address IPv6");
890 diag_sprintf(buffer,"[IPv6] IPv4 & IPv6 FQDN cname: error %s",
891 gai_strerror(error));
892 CYG_TEST_FAIL(buffer);
899 dns_test_thread(cyg_addrword_t p)
905 init_all_network_interfaces();
907 CYG_TEST_INFO("Starting dns1 test");
909 for (i = 0; i < CYG_NELEM(test_info); i++) {
910 dns_test(&test_info[i]);
913 CYG_TEST_FINISH("dns1 test completed");
919 // Create a main thread, so we can run the scheduler and have time 'pass'
920 cyg_thread_create(10, // Priority - just a number
921 dns_test_thread, // entry
922 0, // entry parameter
926 &thread_handle, // Handle
927 &thread_data // Thread data structure
929 cyg_thread_resume(thread_handle); // Start it
930 cyg_scheduler_start();