dns1.c

来自「eCos操作系统源码」· C语言 代码 · 共 934 行 · 第 1/3 页

    sa4.sin_family=AF_INET;
    sa4.sin_len = sizeof(sa4);
    
    // Lookup the IPv4 FQDN hostname 
    error = getaddrinfo(name, NULL, &hints, &res);
    
    if (error == EAI_NONE) {
        getnameinfo(res->ai_addr, res->ai_addrlen, 
                    buff, sizeof(buff),
                    NULL,0,NI_NUMERICHOST);
        diag_sprintf(buffer,"Lookup %s: Result <%s is %s %s>", 
                     name,
                     res->ai_canonname, 
                     familytoa(res->ai_family),
                     buff);
        CYG_TEST_INFO(buffer);
        CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa4, 
                                        (void*)res->ai_addr,
                                        sizeof(sa4))) &&
                           (res->ai_family == AF_INET),
                           "IPv4 FQDN hostname address");
        CYG_TEST_PASS_FAIL((0 == strcmp(name, res->ai_canonname)), 
                           "IPv4 FQDN hostname name");
        CYG_TEST_PASS_FAIL((NULL == res->ai_next),
                           "IPv4 FQDN hostname one result");
        freeaddrinfo(res);
    } else {
        diag_sprintf(buffer,"IPv4 FQDN hostname: error %s", 
                     gai_strerror(error));
        CYG_TEST_FAIL(buffer);
    }
    
    // Lookup the IPv4 FQDN cname 
    error = getaddrinfo(cname, NULL, &hints, &res);
    
    if (error == EAI_NONE) {
        getnameinfo(res->ai_addr, res->ai_addrlen, 
                    buff, sizeof(buff),
                    NULL,0,NI_NUMERICHOST);
        diag_sprintf(buffer,"Lookup %s: Result <%s is %s %s>", 
                     cname,
                     res->ai_canonname, 
                     familytoa(res->ai_family),
                     buff);
        CYG_TEST_INFO(buffer);
        CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa4, 
                                        (void*)res->ai_addr,
                                        sizeof(sa4))) &&
                           (res->ai_family == AF_INET),
                           "IPv4 FQDN cname address");
        CYG_TEST_PASS_FAIL((0 == strcmp(name, res->ai_canonname)), 
                           "IPv4 FQDN cname name");
        CYG_TEST_PASS_FAIL((NULL == res->ai_next),
                           "IPv4 FQDN cname one result");
        freeaddrinfo(res);
    } else {
        diag_sprintf(buffer,"IPv4 FQDN cname: error %s", gai_strerror(error));
        CYG_TEST_FAIL(buffer);
    }
    
    // Lookup the IP address as a string.  This does not require a DNS
    // lookup. Just turn the value into binary
    hints.ai_flags = AI_NUMERICHOST;
    error = getaddrinfo(info->ip_addr_v4, NULL, &hints, &res);
    
    if (error == EAI_NONE) {
        getnameinfo(res->ai_addr, res->ai_addrlen, 
                    buff, sizeof(buff),
                    NULL,0,NI_NUMERICHOST);
        diag_sprintf(buffer,"Lookup %s: Result <%s %s>", 
                     info->ip_addr_v4,
                     familytoa(res->ai_family),
                     buff);
        CYG_TEST_INFO(buffer);
        CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa4, 
                                        (void*)res->ai_addr,
                                        sizeof(sa4))) &&
                           (res->ai_family == AF_INET),
                           "IPv4 IP address");
        CYG_TEST_PASS_FAIL((NULL == res->ai_canonname), 
                           "IPv4 IP address name");
        CYG_TEST_PASS_FAIL((NULL == res->ai_next),
                           "IPv4 IP address one result");        
        // Don't free results - use for next test.
    } else {
        diag_sprintf(buffer,"IPv4 IP address: error %s", gai_strerror(error));
        CYG_TEST_FAIL(buffer);
    }

    // Reverse lookup the IPv4 address, expect the FQDN hostname
    error = getnameinfo(res->ai_addr,res->ai_addrlen,
                       host, hostlen, NULL, 0, 0);
    if (error == EAI_NONE) {
        diag_sprintf(buffer, "IPv4 Reverse lookup FDQN %s: Result %s",
                    info->ip_addr_v4,
                    host);
        CYG_TEST_INFO(buffer);
        CYG_TEST_PASS_FAIL((0 == strcmp(name, host)), 
                           "IPv4 Reverse lookup FQDN");
    } else {
        diag_sprintf(buffer,"IPv4 Reverse lookup FQDN: error %s", 
                     gai_strerror(error));
        CYG_TEST_FAIL(buffer);
    }
    // Reverse lookup the IPv4 address, expect just the hostname part
    error = getnameinfo(res->ai_addr,res->ai_addrlen,
                       host, hostlen, NULL, 0, NI_NOFQDN);
    if (error == EAI_NONE) {
        diag_sprintf(buffer, "IPv4 Reverse lookup hostname part %s: Result %s",
                    info->ip_addr_v4,
                    host);
        CYG_TEST_INFO(buffer);
        CYG_TEST_PASS_FAIL((0 == strcmp(info->hostname_v4, host)), 
                           "IPv4 Reverse lookup hostname part");
    } else {
        diag_sprintf(buffer,"IPv4 Reverse lookup hostname part: error %s", 
                     gai_strerror(error));
        CYG_TEST_FAIL(buffer);
    }
    freeaddrinfo(res);

    // Setup a domainname. We now don't have to use fully qualified
    // domain names
    setdomainname(info->domain_name, strlen(info->domain_name));
    getdomainname(dn, sizeof(dn));
    CYG_TEST_PASS_FAIL(0 == strcmp(info->domain_name, dn), 
                       "{get|set}domainname");
    
    // Lookup the IPv4 FQDN hostname to make sure it still works
    hints.ai_flags = AI_CANONNAME;
    error = getaddrinfo(name, NULL, &hints, &res);
    
    if (error == EAI_NONE) {
        getnameinfo(res->ai_addr, res->ai_addrlen, 
                    buff, sizeof(buff),
                    NULL,0,NI_NUMERICHOST);
        diag_sprintf(buffer,"Lookup %s: Result <%s is %s %s>", 
                     name,
                     res->ai_canonname, 
                     familytoa(res->ai_family),
                     buff);
        CYG_TEST_INFO(buffer);
        CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa4, 
                                        (void*)res->ai_addr,
                                        sizeof(sa4))) &&
                           (res->ai_family == AF_INET),
                           "IPv4 FQDN hostname address");
        CYG_TEST_PASS_FAIL((0 == strcmp(name, res->ai_canonname)), 
                           "IPv4 FQDN hostname name");
        CYG_TEST_PASS_FAIL((NULL == res->ai_next),
                           "IPv4 FQDN hostname one result");
        freeaddrinfo(res);
    } else {
        diag_sprintf(buffer,"IPv4 FQDN hostname: error %s", 
                     gai_strerror(error));
        CYG_TEST_FAIL(buffer);
    }
    
    // Now the host name without the domain name 
    error = getaddrinfo(info->hostname_v4, NULL, &hints, &res);
    
    if (error == EAI_NONE) {
        getnameinfo(res->ai_addr, res->ai_addrlen, 
                    buff, sizeof(buff),
                    NULL,0,NI_NUMERICHOST);
        diag_sprintf(buffer,"Lookup %s: Result <%s is %s %s>", 
                     info->hostname_v4,
                     res->ai_canonname, 
                     familytoa(res->ai_family),
                     buff);
        CYG_TEST_INFO(buffer);
        CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa4, 
                                        (void*)res->ai_addr,
                                        sizeof(sa4))) &&
                           (res->ai_family == AF_INET),
                           "IPv4 hostname address");
        CYG_TEST_PASS_FAIL((0 == strcmp(name, res->ai_canonname)), 
                           "IPv4 hostname name");
        CYG_TEST_PASS_FAIL((NULL == res->ai_next),
                           "IPv4 hostname one result");        
        freeaddrinfo(res);
    } else {
        diag_sprintf(buffer,"IPv4 hostname: error %s", 
                     gai_strerror(error));
        CYG_TEST_FAIL(buffer);
    }
#ifdef CYGPKG_NET_INET6
    // Check we have the needed information for the IPv6 tests
    if (!info->hostname_v6 || !info->cname_v6 || !info->ip_addr_v6) {
        return;
    }

    setdomainname(NULL,0);
    
    strcpy(name,info->hostname_v6);
    strcat(name,".");
    strcat(name,info->domain_name);
    strcpy(cname,info->cname_v6);
    strcat(cname,".");
    strcat(cname,info->domain_name);
    
    memset(&sa6,0,sizeof(sa6));
    sa6.sin6_family = AF_INET6;
    sa6.sin6_len = sizeof(sa6);
    inet_pton(AF_INET6, info->ip_addr_v6, (void *)&sa6.sin6_addr);

    // Lookup the IPv6 FQDN hostname 
    error = getaddrinfo(name, NULL, &hints, &res);
    
    if (error == EAI_NONE) {
        getnameinfo(res->ai_addr, res->ai_addrlen, 
                    buff, sizeof(buff),
                    NULL,0,NI_NUMERICHOST);
        diag_sprintf(buffer,"Lookup %s: Result <%s is %s %s>", 
                     name,
                     res->ai_canonname, 
                     familytoa(res->ai_family),
                     buff);
        CYG_TEST_INFO(buffer);
        CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa6, 
                                        (void*)res->ai_addr,
                                        sizeof(sa6))) &&
                           (res->ai_family == AF_INET6),
                           "IPv6 FQDN hostname address");
        CYG_TEST_PASS_FAIL((0 == strcmp(name, res->ai_canonname)), 
                           "IPv6 FQDN hostname name");
        CYG_TEST_PASS_FAIL((NULL == res->ai_next),
                           "IPv6 FQDN hostname one result");
        freeaddrinfo(res);
    } else {
        diag_sprintf(buffer,"IPv6 FQDN hostname: error %s", 
                     gai_strerror(error));
        CYG_TEST_FAIL(buffer);
    }

    // Lookup the IPv6 FQDN cname 
    error = getaddrinfo(cname, NULL, &hints, &res);
    
    if (error == EAI_NONE) {
        getnameinfo(res->ai_addr, res->ai_addrlen, 
                    buff, sizeof(buff),
                    NULL,0,NI_NUMERICHOST);
        diag_sprintf(buffer,"Lookup %s: Result <%s is %s %s>", 
                     cname,
                     res->ai_canonname, 
                     familytoa(res->ai_family),
                     buff);
        CYG_TEST_INFO(buffer);
        CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa6, 
                                        (void*)res->ai_addr,
                                        sizeof(sa6))) &&
                           (res->ai_family == AF_INET6),
                           "IPv6 FQDN cname address");
        CYG_TEST_PASS_FAIL((0 == strcmp(name, res->ai_canonname)), 
                           "IPv6 FQDN cname name");
        CYG_TEST_PASS_FAIL((NULL == res->ai_next),
                           "IPv6 FQDN cname one result");
        freeaddrinfo(res);
    } else {
        diag_sprintf(buffer,"IPv6 FQDN cname: error %s", 
                     gai_strerror(error));
        CYG_TEST_FAIL(buffer);
    }

    // Lookup the IP address as a string.  This does not require a DNS
    // lookup. Just turn the value into binary
    hints.ai_flags = AI_NUMERICHOST;
    error = getaddrinfo(info->ip_addr_v6, NULL, &hints, &res);

    if (error == EAI_NONE) {
        getnameinfo(res->ai_addr, res->ai_addrlen, 
                    buff, sizeof(buff),
                    NULL,0,NI_NUMERICHOST);
        diag_sprintf(buffer,"Lookup %s: Result <%s %s>", 
                     info->ip_addr_v6,
                     familytoa(res->ai_family),
                     buff);
        CYG_TEST_INFO(buffer);
        CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa6, 
                                        (void*)res->ai_addr,
                                        sizeof(sa6))) &&
                           (res->ai_family == AF_INET6),
                           "IPv6 IP address");
        CYG_TEST_PASS_FAIL((NULL == res->ai_canonname), 
                           "IPv6 IP address name");
        CYG_TEST_PASS_FAIL((NULL == res->ai_next),
                           "IPv6 IP address one result");
        // Don't free the result, use it in the next tests
    } else {
        diag_sprintf(buffer,"IPv6 IP address: error %s", gai_strerror(error));
        CYG_TEST_FAIL(buffer);
    }

    // Reverse lookup the IPv6 address, expect the FQDN hostname
    error = getnameinfo(res->ai_addr,res->ai_addrlen,
                       host, hostlen, NULL, 0, 0);
    if (error == EAI_NONE) {
        diag_sprintf(buffer, "IPv6 Reverse lookup FDQN %s: Result %s",
                    info->ip_addr_v6,
                    host);
        CYG_TEST_INFO(buffer);
        CYG_TEST_PASS_FAIL((0 == strcmp(name, host)), 
                           "IPv6 Reverse lookup FQDN");
    } else {
        diag_sprintf(buffer,"IPv6 Reverse lookup FQDN: error %s", 
                     gai_strerror(error));
        CYG_TEST_FAIL(buffer);
    }
    // Reverse lookup the IPv6 address, expect just the hostname part
    error = getnameinfo(res->ai_addr,res->ai_addrlen,
                       host, hostlen, NULL, 0, NI_NOFQDN);
    if (error == EAI_NONE) {