addr->sin_len = sizeof(*addr);
            memcpy(&addr->sin_addr, rdata, sizeof(struct in_addr));
            used++;
            break;
        }
#ifdef CYGPKG_NET_INET6
        case AF_INET6: {
            struct sockaddr_in6 * addr = (struct sockaddr_in6 *) &addrs[used];
            addr->sin6_len = sizeof(*addr);
            memcpy(&addr->sin6_addr, rdata, sizeof(struct in6_addr));
            used++;
            break;
        }
#endif
        default:
            used = -EAI_FAMILY;
        }
    }
    return used;
}
      
/* This decodes the answer and puts the results into the addrs
   array. This function can deal with IPv6 AAAA records as well as A
   records. Thus its more complex than the parse_answer function in
   the inline code. This complexity is only needed by getaddrinfo, so
   i decided to leave parse_anser alone. */

static int
decode(unsigned char *msg, short rr_type, int family, 
       struct sockaddr addrs[], int num, int used, char **canon) {
  
    struct dns_header *dns_hdr;
    struct resource_record rr, *rr_p = NULL;
    unsigned char *qname = NULL;
    unsigned char *ptr;
    
    dns_hdr = (struct dns_header *)msg;
    
    if (DNS_REPLY_NAME_ERROR == dns_hdr->rcode) {
        h_errno = HOST_NOT_FOUND;
        return -EAI_NONAME;
    }
    
    if ((dns_hdr->qr != 1) ||
        (dns_hdr->opcode != DNS_QUERY)) {
      return -EAI_FAIL;
    }
    
    if (dns_hdr->rcode != DNS_REPLY_NOERR) {
      return -EAI_NONAME;
    }

    dns_hdr->ancount = ntohs(dns_hdr->ancount);
    dns_hdr->qdcount = ntohs(dns_hdr->qdcount);
    ptr = (unsigned char *)&dns_hdr[1];
    
    /* Skip over the query section */
    if (dns_hdr->qdcount > 0) {
        while (dns_hdr->qdcount) {
            ptr += qname_len(ptr);
            ptr += 4;                   /* skip type & class */
            dns_hdr->qdcount--;
        }
    }  
    
    /* Read the answers resource records to find an answer of the
       correct type. */
    while (dns_hdr->ancount && (used >= 0) && (used < num)) {
        qname = ptr;
        ptr += qname_len(ptr);
        rr_p = (struct resource_record *)ptr;
        memcpy(&rr, ptr, sizeof(rr));
        if ((rr.rr_type == htons(rr_type)) && 
            (rr.class == htons(DNS_CLASS_IN))) {
            used = add_answer(rr_p->rdata, rr_type, family, addrs, num, used);
            if (canon && !*canon) {
                *canon = real_name(msg,qname);
            }
        }
        ptr += sizeof(struct resource_record) - 
            sizeof(rr.rdata) + ntohs(rr.rdlength);
        dns_hdr->ancount--;
    }
    if (used == 0) {
        return -EAI_NONAME;
    }
    return used;
}

/* Do a lookup for a particular type of resource record. */
static int 
do_lookup (const char * hostname, 
           struct sockaddr addrs[], int num, int used, 
           short rr_type, int family, char **canon) {

    unsigned char msg[MAXDNSMSGSIZE];
    int error;
    int len;

    /* First try the name as passed in */
    memset(msg, 0, sizeof(msg));
    len = build_query(msg, hostname, rr_type);
    if (len < 0) {
        return -EAI_FAIL;
    }
    
    /* Send the query and wait for an answer */
    len = send_recv(msg, len, sizeof(msg));
    if (len < 0) {
        return -EAI_FAIL;
    }
    
    /* Decode the answer */
    error = decode(msg, rr_type, family, addrs, num, used, canon);
    return error;
}

static int do_lookups(const char * hostname, 
                      struct sockaddr addrs[], int num, 
                      int family, char ** canon) {
    int error;
#ifdef CYGPKG_NET_INET6
    int error6;
#endif

    switch (family) {
    case AF_INET:
        error = do_lookup(hostname, addrs, num, 0, DNS_TYPE_A, AF_INET, canon);
        break;
#ifdef CYGPKG_NET_INET6
    case AF_INET6:
        error = do_lookup(hostname, addrs, num, 0, DNS_TYPE_AAAA, AF_INET6, canon);
        break;
#endif
    case PF_UNSPEC:
#ifndef CYGPKG_NET_INET6
        error = do_lookup(hostname, addrs, num, 0, DNS_TYPE_A, AF_INET, canon);
#else 
#ifdef CYGOPT_NS_DNS_FIRST_FAMILTY_AF_INET
        error = do_lookup(hostname, addrs, num, 0, DNS_TYPE_A, AF_INET, canon);
        if (error > 0 ) {
            error6 = do_lookup(hostname, addrs, num, error, DNS_TYPE_AAAA, 
                               AF_INET6, canon);
        } else {
            error6 = do_lookup(hostname, addrs, num, 0, DNS_TYPE_AAAA, 
                               AF_INET6, canon);
        }
        if (error6 > 0) {
            error = error6;
        }
#else // CYGOPT_NS_DNS_FIRST_FAMILY_AF_INET
        error6 = do_lookup(hostname, addrs, num, 0, DNS_TYPE_AAAA, 
                           AF_INET6, canon);
        if (error6> 0 ) {
            error = do_lookup(hostname, addrs, num, error6, DNS_TYPE_A, 
                               AF_INET, canon);
        } else {
            error = do_lookup(hostname, addrs, num, 0, DNS_TYPE_A, 
                               AF_INET, canon);
        }
#endif // CYGOPT_NS_DNS_FIRST_FAMILY_AF_INET
#endif // CYGPKG_NET_INET6
        break;
    default:
        error = -EAI_FAMILY;
    }
    return error;
}

/* This implements the interface between getaddrinfo and the dns
   client. hostent is not used here since that only works with IPv4
   addresses, where as this function needs to be protocol
   independent. */
int 
cyg_dns_getaddrinfo(const char * hostname, 
                    struct sockaddr addrs[], int num,
                    int family,
                    char ** canon)
{
    int error;
    char name[256];
    char * dot;

    CYG_REPORT_FUNCNAMETYPE( "cyg_dns_getaddrinfo", "returning %08x" );
    CYG_REPORT_FUNCARG3( "hostname=%08x, addrs=%08x, num=%2d", 
                         hostname, addrs, num );
    
    if ( !hostname || !addrs || !num ) {
        CYG_REPORT_RETVAL( NULL );
        return -EAI_FAIL;
    }
    
    CYG_CHECK_DATA_PTR( hostname, "hostname is not a valid pointer!" );
    CYG_CHECK_DATA_PTR( addrs, "addrs is not a valid pointer!");
    CYG_ASSERT( num > 0, "Invalid number of sockaddr stuctures");
    
    if (!valid_hostname(hostname)) {
        /* it could be a dot address */
        struct sockaddr_in * sa4 = (struct sockaddr_in *)&addrs[0];
        memset(&addrs[0],0,sizeof(struct sockaddr));
        if (inet_pton(AF_INET, hostname, (char *)&sa4->sin_addr.s_addr)) {
            sa4->sin_family = AF_INET;
            sa4->sin_len = sizeof(*sa4);
            CYG_REPORT_RETVAL (1);
            return 1;
        }
#ifdef CYGPKG_NET_INET6
        {
            /* it could be a colon address */
            struct sockaddr_in6 * sa6 = (struct sockaddr_in6 *)&addrs[0];
            memset(&addrs[0],0,sizeof(struct sockaddr));
            if (inet_pton(AF_INET6, hostname, (char *)&sa6->sin6_addr.s6_addr)) {
                sa6->sin6_family = AF_INET6;
                sa6->sin6_len = sizeof(*sa6);
                CYG_REPORT_RETVAL (1);
                return 1;
            }
        }
#endif
        CYG_REPORT_RETVAL (-EAI_NONAME);
        return -EAI_NONAME;
    }
    
    /* Has the socket to the DNS server been opened? */
    if (s < 0) {
        CYG_REPORT_RETVAL( -EAI_FAIL );
        return -EAI_FAIL;
    }
    
    if (domainname) {
        if ((strlen(hostname) + strlen(domainname)) > 254) {
            cyg_drv_mutex_unlock(&dns_mutex);
            CYG_REPORT_RETVAL( -EAI_FAIL );
            return -EAI_FAIL;
        }
        strcpy(name, hostname);
        strcat(name, ".");
        strcat(name, domainname);
    }
    cyg_drv_mutex_lock(&dns_mutex);

    /* If the hostname ends with . it a FQDN. Don't bother adding the
    domainname. If it does not contain a . , try appending with the
    domainname first. If it does have a . , try without a domain name
    first. */

    dot = rindex(hostname,'.');
    if (dot) {
        if (*(dot+1) == '\0') {
            /* FQDN */
            error = do_lookups(hostname, addrs, num, family, canon);
        } else {
          /* Dot somewhere */
          error = do_lookups(hostname, addrs, num, family, canon);
          if (domainname && (error == -EAI_NONAME)) { 
            error = do_lookups(name, addrs, num, family, canon);
          }
        }
    } else {
    /* No Dot. Try adding domainname first */
        error = -EAI_NONAME;
        if (domainname) {
            error = do_lookups(name, addrs, num, family, canon);
        }
        if (error == -EAI_NONAME) {
            error = do_lookups(hostname, addrs, num, family, canon);
        }
    }
    cyg_drv_mutex_unlock(&dns_mutex);
    CYG_REPORT_RETVAL( error );
    return error;
}

/* This implements the interface between getnameinfo and the dns
   client. */
externC int
cyg_dns_getnameinfo(const struct sockaddr * sa, char * host, size_t hostlen) 
{
    char hostname[80];
    unsigned char msg[MAXDNSMSGSIZE];
    struct hostent * hent;
    int len;

    CYG_REPORT_FUNCNAMETYPE( "cyg_dns_getnameinfo", "returning %08x" );
    CYG_REPORT_FUNCARG3( "sa=%08x, host=%08x, hostlen=%3d", 
                         sa, host, hostlen );
    
    CYG_CHECK_DATA_PTR( sa, "sa is not a valid pointer");
    CYG_CHECK_DATA_PTR( host, "host is not a valid data pointer");
    CYG_ASSERT(hostlen >0, "Invalid host length");
    
    /* Has the socket to the DNS server been opened? */
    if (s < 0) {
        CYG_REPORT_RETVAL( -EAI_FAIL );
        return -EAI_FAIL;
    }
    
    cyg_drv_mutex_lock(&dns_mutex);
    
    switch (sa->sa_family) {
    case AF_INET: {
        struct sockaddr_in * sa4 = (struct sockaddr_in *)sa;
        unsigned char * addr = (unsigned char *)&sa4->sin_addr.s_addr;
        sprintf(hostname, "%d.%d.%d.%d.IN-ADDR.ARPA.",
                addr[3],addr[2],addr[1],addr[0]);
        break;
    }
#ifdef CYGPKG_NET_INET6
    case AF_INET6: {
        struct sockaddr_in6 * sa6 = (struct sockaddr_in6 *)sa;
        int i;
        
        for (i=15; i >= 0; i--) {
            sprintf(&hostname[(15*2*2) - (i*2*2)], "%x.%x.",
                    sa6->sin6_addr.s6_addr[i] & 0x0f,
                    (sa6->sin6_addr.s6_addr[i] & 0xf0) >> 4);
        }
        sprintf(&hostname[16*2*2],"IP6.INT");
        break;
    }
#endif
    default:
        cyg_drv_mutex_lock(&dns_mutex);
        CYG_REPORT_RETVAL( -EAI_FAMILY);
        return -EAI_FAMILY;
    }

    memset(msg, 0, sizeof(msg));
  
    /* Build a PTR type request using the hostname */
    len = build_query(msg, hostname, DNS_TYPE_PTR);
    if (len < 0) {
        cyg_drv_mutex_unlock(&dns_mutex);
        CYG_REPORT_RETVAL( -EAI_FAIL );
        return -EAI_FAIL;
    }

    /* Send the request and wait for an answer */
    len = send_recv(msg, len, sizeof(msg));
    if (len < 0) {
        cyg_drv_mutex_unlock(&dns_mutex);
        CYG_REPORT_RETVAL( -EAI_FAIL );
        return -EAI_FAIL;
    }
 
    /* Parse the answer for the host name */
    hent = parse_answer(msg, DNS_TYPE_PTR);
    
    /* If no name is known return an error */
    if (!hent) {
        cyg_drv_mutex_unlock(&dns_mutex);
        CYG_REPORT_RETVAL( -EAI_NONAME );
        return -EAI_NONAME;
    }
    
    /* Otherwise copy it into our results buffer and tidy up */
    strncpy(host, hent->h_name,hostlen);
    free_hent(hent);
    
    cyg_drv_mutex_unlock(&dns_mutex);
    CYG_REPORT_RETVAL( -EAI_NONE );
    return -EAI_NONE;
}