dns1.c

eCos/RedBoot for勤研ARM AnywhereII(4510) 含全部源代码

        diag_sprintf(buffer, "IPv6 Reverse lookup hostname part %s: Result %s",
                    info->ip_addr_v6,
                    host);
        CYG_TEST_INFO(buffer);
        CYG_TEST_PASS_FAIL((0 == strcmp(info->hostname_v6, host)), 
                           "IPv6 Reverse lookup hostname part");
    } else {
        diag_sprintf(buffer,"IPv6 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 IPv6 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 *)&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);
    }

    // Now the host name without the domain name
    error = getaddrinfo(info->hostname_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 is %s %s>", 
                     info->hostname_v6,
                     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 hostname address");
        CYG_TEST_PASS_FAIL((0 == strcmp(name, res->ai_canonname)), 
                           "IPv6 hostname name");
        CYG_TEST_PASS_FAIL((NULL == res->ai_next),
                           "IPv6 hostname one result");
        freeaddrinfo(res);
    } else {
        diag_sprintf(buffer,"IPv6 hostname: error %s", 
                     gai_strerror(error));
        CYG_TEST_FAIL(buffer);
    }

    // Check if we have the information to do tests which result in two
    // answers, an AF_INET and an AF_INET6
    if (!info->hostname_v46 || !info->cname_v46 || 
        !info->ip_addr_v46_v4 || !info->ip_addr_v46_v6 ) {
        return;
    }
    setdomainname(NULL,0);
    
    strcpy(name,info->hostname_v46);
    strcat(name,".");
    strcat(name,info->domain_name);
    strcpy(cname,info->cname_v46);
    strcat(cname,".");
    strcat(cname,info->domain_name);

    inet_aton(info->ip_addr_v46_v4, &addr);
    memset(&sa4,0,sizeof(sa4));
    memcpy(&sa4.sin_addr, &addr, sizeof(addr));
    sa4.sin_family=AF_INET;
    sa4.sin_len = sizeof(sa4);
    
    memset(&sa6,0,sizeof(sa6));
    sa6.sin6_family = AF_INET6;
    sa6.sin6_len = sizeof(sa6);
    inet_pton(AF_INET6, info->ip_addr_v46_v6, (void *)&sa6.sin6_addr);
    
    // Lookup the IPv4 and IPv6 FQDN hostname 
    error = getaddrinfo(name, NULL, &hints, &res);
    
    if (error == EAI_NONE) {
#ifdef CYGOPT_NS_DNS_FIRST_FAMILY_AF_INET6
        ai6 = res;
        ai4 = res->ai_next;
        CYG_TEST_PASS_FAIL((NULL != ai6->ai_next),
                           "IPv6 FQDN hostname not one result");
        CYG_TEST_PASS_FAIL((NULL == ai4->ai_next),
                           "IPv4 & IPv6 FQDN hostname two results");
#else
        ai4 = res;
        ai6 = res->ai_next;
        CYG_TEST_PASS_FAIL((NULL != ai4->ai_next),
                           "IPv6 FQDN hostname not one result");
        CYG_TEST_PASS_FAIL((NULL == ai6->ai_next),
                           "IPv4 & IPv6 FQDN hostname two results");
#endif
        getnameinfo(ai4->ai_addr, ai4->ai_addrlen, 
                    buff, sizeof(buff),
                    NULL,0,NI_NUMERICHOST);
        diag_sprintf(buffer,"Lookup %s: Result <%s is %s %s>", 
                     name,
                     ai4->ai_canonname, 
                     familytoa(ai4->ai_family),
                     buff);
        CYG_TEST_INFO(buffer);
        CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa4, 
                                        (void*)ai4->ai_addr,
                                        sizeof(sa4))) &&
                           (ai4->ai_family == AF_INET),
                           "IPv4 & IPv6 FQDN hostname address IPv4");
        CYG_TEST_PASS_FAIL((0 == strcmp(name, ai4->ai_canonname)), 
                           "IPv4 & IPv6 FQDN hostname name");
        getnameinfo(ai6->ai_addr, ai6->ai_addrlen, 
                    buff, sizeof(buff),
                    NULL,0,NI_NUMERICHOST);
        diag_sprintf(buffer,"Lookup %s: Result <%s %s>", 
                     name,
                     familytoa(ai6->ai_family),
                     buff);
        CYG_TEST_INFO(buffer);
        CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa6, 
                                        (void*)ai6->ai_addr,
                                        sizeof(sa6))) &&
                           (ai6->ai_family == AF_INET6),
                           "IPv4 & IPv6 FQDN hostname address IPv6");
        freeaddrinfo(res);
    } else {
        diag_sprintf(buffer,"IPv4 & IPv6 FQDN hostname: error %s", 
                     gai_strerror(error));
        CYG_TEST_FAIL(buffer);
    }
    
    // Lookup the IPv4 and IPv6 FQDN cname 
    error = getaddrinfo(cname, NULL, &hints, &res);
    
    if (error == EAI_NONE) {
#ifdef CYGOPT_NS_DNS_FIRST_FAMILY_AF_INET6
        ai6 = res;
        ai4 = res->ai_next;
        CYG_TEST_PASS_FAIL((NULL != ai6->ai_next),
                           "IPv6 FQDN hostname not one result");
        CYG_TEST_PASS_FAIL((NULL == ai4->ai_next),
                           "IPv4 & IPv6 FQDN hostname two results");
#else
        ai4 = res;
        ai6 = res->ai_next;
        CYG_TEST_PASS_FAIL((NULL != ai4->ai_next),
                           "IPv6 FQDN hostname not one result");
        CYG_TEST_PASS_FAIL((NULL == ai6->ai_next),
                           "IPv4 & IPv6 FQDN hostname two results");
#endif
        getnameinfo(ai4->ai_addr, ai4->ai_addrlen, 
                    buff, sizeof(buff),
                    NULL,0,NI_NUMERICHOST);
        diag_sprintf(buffer,"Lookup %s: Result <%s is %s %s>", 
                     cname,
                     ai4->ai_canonname, 
                     familytoa(ai4->ai_family),
                     buff);
        CYG_TEST_INFO(buffer);
        CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa4, 
                                        (void*)ai4->ai_addr,
                                        sizeof(sa4))) &&
                           (ai4->ai_family == AF_INET),
                           "IPv4 & IPv6 FQDN cname address IPv4");
        CYG_TEST_PASS_FAIL((0 == strcmp(name, ai4->ai_canonname)), 
                           "IPv4 & IPv6 FQDN cname name");
        getnameinfo(ai6->ai_addr, ai6->ai_addrlen, 
                    buff, sizeof(buff),
                    NULL,0,NI_NUMERICHOST);
        diag_sprintf(buffer,"Lookup %s: Result <%s %s>", 
                     cname,
                     familytoa(ai6->ai_family),
                     buff);
        CYG_TEST_INFO(buffer);
        CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa6, 
                                        (void*)ai6->ai_addr,
                                        sizeof(sa6))) &&
                           (ai6->ai_family == AF_INET6),
                           "IPv4 & IPv6 FQDN cname address IPv6");
        freeaddrinfo(res);
    } else {
        diag_sprintf(buffer,"IPv4 & IPv6 FQDN cname: error %s", 
                     gai_strerror(error));
        CYG_TEST_FAIL(buffer);
    }
    
    if (info->dns_server_v6) {
        cyg_dns_res_start(info->dns_server_v6);
        // Lookup the IPv4 and IPv6 FQDN cname 
        error = getaddrinfo(cname, NULL, &hints, &res);
        
        if (error == EAI_NONE) {
#ifdef CYGOPT_NS_DNS_FIRST_FAMILY_AF_INET6
            ai6 = res;
            ai4 = res->ai_next;
            CYG_TEST_PASS_FAIL((NULL != ai6->ai_next),
                               "[IPv6] IPv6 FQDN hostname not one result");
            CYG_TEST_PASS_FAIL((NULL == ai4->ai_next),
                               "[IPv6] IPv4 & IPv6 FQDN hostname two results");
#else
            ai4 = res;
            ai6 = res->ai_next;
            CYG_TEST_PASS_FAIL((NULL != ai4->ai_next),
                               "[IPv6] IPv6 FQDN hostname not one result");
            CYG_TEST_PASS_FAIL((NULL == ai6->ai_next),
                               "[IPv6] IPv4 & IPv6 FQDN hostname two results");
#endif
            getnameinfo(ai4->ai_addr, ai4->ai_addrlen, 
                        buff, sizeof(buff),
                        NULL,0,NI_NUMERICHOST);
            diag_sprintf(buffer,"[IPv6] Lookup %s: Result <%s is %s %s>", 
                         cname,
                         ai4->ai_canonname, 
                         familytoa(ai4->ai_family),
                         buff);
            CYG_TEST_INFO(buffer);
            CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa4, 
                                            (void*)ai4->ai_addr,
                                            sizeof(sa4))) &&
                               (ai4->ai_family == AF_INET),
                               "[IPv6] IPv4 & IPv6 FQDN cname address IPv4");
            CYG_TEST_PASS_FAIL((0 == strcmp(name, ai4->ai_canonname)), 
                               "[IPv6] IPv4 & IPv6 FQDN cname name");
            getnameinfo(ai6->ai_addr, ai6->ai_addrlen, 
                        buff, sizeof(buff),
                        NULL,0,NI_NUMERICHOST);
            diag_sprintf(buffer,"[IPv6] Lookup %s: Result <%s %s>", 
                         cname,
                         familytoa(ai6->ai_family),
                         buff);
            CYG_TEST_INFO(buffer);
            CYG_TEST_PASS_FAIL((0 == memcmp((void *)&sa6, 
                                            (void*)ai6->ai_addr,
                                            sizeof(sa6))) &&
                               (ai6->ai_family == AF_INET6),
                               "[IPv6] IPv4 & IPv6 FQDN cname address IPv6");
            freeaddrinfo(res);
        } else {
            diag_sprintf(buffer,"[IPv6] IPv4 & IPv6 FQDN cname: error %s", 
                         gai_strerror(error));
            CYG_TEST_FAIL(buffer);
        }
    }
#endif
}

void
dns_test_thread(cyg_addrword_t p)
{
    int i;

    CYG_TEST_INIT();

    init_all_network_interfaces();

    CYG_TEST_INFO("Starting dns1 test");
    
    for (i = 0; i < NELEM(test_info); i++) {
      dns_test(&test_info[i]);
    }
    
    CYG_TEST_FINISH("dns1 test completed");
}

void
cyg_start(void)
{
    // Create a main thread, so we can run the scheduler and have time 'pass'
    cyg_thread_create(10,                // Priority - just a number
                      dns_test_thread,   // entry
                      0,                 // entry parameter
                      "DNS test",        // Name
                      &stack[0],         // Stack
                      STACK_SIZE,        // Size
                      &thread_handle,    // Handle
                      &thread_data       // Thread data structure
            );
    cyg_thread_resume(thread_handle);  // Start it
    cyg_scheduler_start();
}