Subversion Repositories openrisc_me

#ifndef CYGONCE_NS_DNS_DNS_IMPL_H

#define CYGONCE_NS_DNS_DNS_IMPL_H

//=============================================================================

//

//      dns_impl.inl

//

//      DNS client code implementation.

//

//=============================================================================

//####ECOSGPLCOPYRIGHTBEGIN####

// -------------------------------------------

// This file is part of eCos, the Embedded Configurable Operating System.

// Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.

//

// eCos is free software; you can redistribute it and/or modify it under

// the terms of the GNU General Public License as published by the Free

// Software Foundation; either version 2 or (at your option) any later version.

//

// eCos is distributed in the hope that it will be useful, but WITHOUT ANY

// WARRANTY; without even the implied warranty of MERCHANTABILITY or

// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

// for more details.

//

// You should have received a copy of the GNU General Public License along

// with eCos; if not, write to the Free Software Foundation, Inc.,

// 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.

//

// As a special exception, if other files instantiate templates or use macros

// or inline functions from this file, or you compile this file and link it

// with other works to produce a work based on this file, this file does not

// by itself cause the resulting work to be covered by the GNU General Public

// License. However the source code for this file must still be made available

// in accordance with section (3) of the GNU General Public License.

//

// This exception does not invalidate any other reasons why a work based on

// this file might be covered by the GNU General Public License.

//

// Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.

// at http://sources.redhat.com/ecos/ecos-license/

// -------------------------------------------

//####ECOSGPLCOPYRIGHTEND####

//=============================================================================

//#####DESCRIPTIONBEGIN####

//

// Author(s):   andrew.lunn

// Contributors:andrew.lunn, jskov

// Date:        2001-09-18

// Description: The code is kept in this separate file to allow it to be

//              used from RedBoot.

//

//####DESCRIPTIONEND####

//

//=============================================================================

#include 

/* Validate a hostname is legal as defined in RFC 1035 */

static int

valid_hostname(const char *hostname)

{

    const char * label;

    const char * label_end;

    if (!hostname) {

        return false;

    }

    label = hostname;

    while (*label) {

        if (!isalpha(*label))

            return false;

        label_end = strchr(label, (int)'.') - 1;

        if (label_end == (char *)-1) {

            label_end = strchr(label, (int)'\0') - 1;

        }

        while (label != label_end) {

            if (!isalnum(*label) && (*label != '-')) {

                return false;

            }

            label++;

        }

        label = label_end+1;            /* Move onto the . or the null. */

        if (*label == '.') {            /* Move over the . if there is one */

            label++;

        }

    }

    return true;

}

/* Build a qname structure. The structure consists of pairs of

    where  is eg ma in tux.ma.tech.ascom.ch. len is

   the length of the label. */

static int

build_qname(char *ptr, const char *hostname)

{

    const char *label = hostname;

    char *end_label;

    int total_len = 0;

    int len;

    while (*label) {

        end_label = strchr(label, (int)'.') - 1;

        if (end_label == (char *)-1) {

            end_label = strchr(label, (int)'\0') - 1;

        }

        len = end_label - label + 1;

        if (len > 63) {

            return -1;

        }

        *ptr++ = (char) len;            /* Put the length of the label */

        memcpy(ptr, label, len);        /* and now the label */

        ptr += len;

        total_len += len +1;

        label = end_label+1;            /* Move onto the . or the null. */

        if (*label == '.') {            /* Move over the . if there is one */

            label++;

        }

    }

    *ptr = 0;                           /* Add the last length of zero

                                           to mark the end */

    return (total_len+1);

}

/* Given a pointer to a qname, find the length of the qname. This is

   the number of bytes needed to represent the qname, not the length

   of the name. A qname is terminated by either a 00, or a pointer

   into another qname. This pointer has the top two bits set. */

static int

qname_len(unsigned char * qname)

{

    unsigned char * ptr = qname;

    while ((*ptr != 0) && ((*ptr & 0xc0) != 0xc0)) {

        ptr += *ptr + 1;

    }

    /* Pointers are two bytes */

    if ((*ptr & 0xc0) == 0xc0) {

        ptr++;

    }

    ptr++;                              /* Skip over the trailing byte */

    return (ptr - qname);

}

/* Build a real name from a qname. Alloc the memory needed and return

   it. Return NULL on error */

char *

real_name(char *msg, unsigned char *qname)

{

    unsigned char * ptr = qname;

    char * name;

    char * label;

    int len = 0;

    int offset;

    /* First pass works out the length of the name */

    while (*ptr != 0) {

        if ((*ptr & 0xc0) == 0xc0) {

            /* pointer to somewhere else. Follow the pointer */

            offset = ((*ptr & 0x3f) << 8) | *(ptr+1);

            ptr = msg + offset;

        } else {

            len += *ptr + 1;

            ptr += *ptr + 1;

        }

    }

    /* Now allocate the memory needed and copy the host name into it */

    name = alloc_string(len+1);

    if (name) {

        label = name;

        ptr = qname;

        while (*ptr != 0) {

            if ((*ptr & 0xc0) == 0xc0) {

                /* pointer to somewhere else. Follow the pointer */

                offset = ((*ptr & 0x3f) << 8) | *(ptr+1);

                ptr = msg + offset;

            } else {

                len = *ptr;

                memcpy(label, (ptr+1), len);

                label += len;

                *label++ = '.';

                ptr += *ptr + 1;

            }

        }

        *label = '\0';

    }

    return name;

}

/* Build a query message which can be sent to the server. If something

   goes wrong return -1, otherwise the length of the query message */

static int

build_query(char * msg, const char * hostname, short rr_type)

{

    struct dns_header *dns_hdr;

    char *ptr;

    int len;

    /* Fill out the header */

    dns_hdr = (struct dns_header *) msg;

    dns_hdr->id = htons(id++);

    dns_hdr->rd = true;

    dns_hdr->opcode = DNS_QUERY;

    dns_hdr->qdcount = htons(1);

    /* Now the question we want to ask */

    ptr = (char *)&dns_hdr[1];

    len = build_qname(ptr, hostname);

    if (len < 0) {

        h_errno = NO_RECOVERY;

        return -1;

    }

    ptr += len;

    /* Set the type and class fields */

    *ptr++ = (rr_type >> 8) & 0xff;

    *ptr++ = rr_type & 0xff;

    *ptr++ = (DNS_CLASS_IN >> 8) & 0xff;

    *ptr++ = DNS_CLASS_IN & 0xff;

    len = ptr - msg;

    return len;

}

/* Check if the hostname is actually of dot format. If so convert it

   and return host entity structure. If not, return NULL. */

static struct hostent *

dot_hostname(const char *hostname)

{

    struct hostent *hent = NULL;

    struct in_addr addr;

    if (inet_aton(hostname, &addr)) {

        hent = alloc_hent();

        if (hent) {

            memcpy(hent->h_addr_list[0], &addr, sizeof(struct in_addr));

            hent->h_addrtype = AF_INET;

            hent->h_length = sizeof(struct in_addr);

            hent->h_name = alloc_string(strlen(hostname)+1);

            if (!hent->h_name) {

                free_hent(hent);

                return NULL;

            }

            strcpy(hent->h_name, hostname);

        }

    }

    return hent;

}

/* Decode the answer from the server. Returns NULL if failed, or

   a hostent structure containing different data depending on the

   query type:

    DNS_TYPE_A:

      h_name:         a pointer to the hostname

      h_addr_list[0]: a pointer to in_addr structure

    DNS_TYPE_PTR:

      h_name:         a pointer to the hostname

      h_addr_list[0]: a pointer to an empty in_addr structure. Caller

                      must fill out!

*/

static struct hostent *

parse_answer(char * msg, short rr_type)

{

    static struct hostent *hent;

    struct dns_header *dns_hdr;

    struct resource_record rr, *rr_p = NULL;

    char *qname = NULL;

    char *ptr;

    dns_hdr = (struct dns_header *)msg;

    if (DNS_REPLY_NAME_ERROR == dns_hdr->rcode) {

        h_errno = HOST_NOT_FOUND;

        return NULL;

    }

    if ((dns_hdr->qr != 1) ||

        (dns_hdr->opcode != DNS_QUERY) ||

        (dns_hdr->rcode != DNS_REPLY_NOERR)) {

        h_errno = NO_RECOVERY;

        return NULL;

    }

    dns_hdr->ancount = ntohs(dns_hdr->ancount);

    dns_hdr->qdcount = ntohs(dns_hdr->qdcount);

    ptr = (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--;

        }

    }

    /* Skip over the answers resource records to find an answer of the

       correct type. */

    while (dns_hdr->ancount) {

        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))) {

            break;

        }

        ptr += sizeof(struct resource_record) - sizeof(rr.rdata) + ntohs(rr.rdlength);

        dns_hdr->ancount--;

    }

    /* If we found one. decode it */

    if (dns_hdr->ancount > 0) {

        hent = alloc_hent();

        if (!hent)

            return NULL;

        switch (rr_type) {

        case DNS_TYPE_A:

            hent->h_name = real_name(msg, qname);

            if (!hent->h_name) {

                free_hent(hent);

                return NULL;

            }

            memcpy(hent->h_addr_list[0], rr_p->rdata, sizeof(struct in_addr));

            hent->h_addrtype = AF_INET;

            hent->h_length = sizeof(struct in_addr);

            return hent;

        case DNS_TYPE_PTR:

            hent->h_name = real_name(msg, rr_p->rdata);

            if (!hent->h_name) {

                free_hent(hent);

                return NULL;

            }

            hent->h_addrtype = AF_INET;

            hent->h_length = sizeof(struct in_addr);

            return hent;

        default:

            free_hent(hent);

        }

    }

    h_errno = NO_DATA;

    return NULL;

}

/* Given an address, find out the hostname. */

struct hostent *

gethostbyaddr(const char *addr, int len, int type)

{

    unsigned char msg[MAXDNSMSGSIZE];

    char hostname[40];

    struct hostent * hent;

    CYG_REPORT_FUNCNAMETYPE( "gethostbyaddr", "returning %08x" );

    CYG_REPORT_FUNCARG3( "addr=%08x, len=%d, type=%d", addr, len, type );

    if ( !addr || 0 == len) {

        CYG_REPORT_RETVAL( NULL );

        return NULL;

    }

    CYG_CHECK_DATA_PTR( addr, "addr is not a valid pointer!" );

    /* Has the socket to the DNS server been opened? */

    if (s < 0) {

        CYG_REPORT_RETVAL( NULL );

        return NULL;

    }

    /* See if there is an answer to an old query. If so free the memory

       it uses. */

    free_stored_hent();

    /* Only IPv4 addresses accepted */

    if ((type != AF_INET) || (len != sizeof(struct in_addr))) {

        CYG_REPORT_RETVAL( NULL );

        return NULL;

    }

    cyg_drv_mutex_lock(&dns_mutex);

    /* Build the 'hostname' we want to lookup. */

    sprintf(hostname, "%d.%d.%d.%d.IN-ADDR.ARPA.",

            (unsigned char)addr[3],

            (unsigned char)addr[2],

            (unsigned char)addr[1],

            (unsigned char)addr[0]);

    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( NULL );

        return NULL;

    }

    /* 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( NULL );

        return NULL;

    }

    /* Fill in the missing address */

    hent = parse_answer(msg, DNS_TYPE_PTR);

    if (hent) {

        memcpy(hent->h_addr_list[0], addr, sizeof(struct in_addr));

        store_hent(hent);

    }

    cyg_drv_mutex_unlock(&dns_mutex);

    CYG_REPORT_RETVAL( hent );

    return hent;

}

/* Given a hostname find out the IP address */

struct hostent *

gethostbyname(const char * hostname)

{

    unsigned char msg[MAXDNSMSGSIZE];

    char name[256];

    struct hostent *hent;

    int len;

    CYG_REPORT_FUNCNAMETYPE( "gethostbyname", "returning %08x" );

    CYG_REPORT_FUNCARG1( "hostname=%08x", hostname );

    if ( !hostname ) {

        CYG_REPORT_RETVAL( NULL );

        return NULL;

    }

    CYG_CHECK_DATA_PTR( hostname, "hostname is not a valid pointer!" );

    /* Has the socket to the DNS server been opened? */

    if (s < 0) {

        CYG_REPORT_RETVAL( NULL );

        return NULL;

    }

    /* See if there is an answer to an old query. If so free the memory

       it uses */

    free_stored_hent();

    if (!valid_hostname(hostname)) {

        /* It could be a dot address */

        hent = dot_hostname(hostname);

        store_hent(hent);

        CYG_REPORT_RETVAL( hent );

        return hent;

    }

    cyg_drv_mutex_lock(&dns_mutex);

    /* First try the name as passed in */

    memset(msg, 0, sizeof(msg));

    len = build_query(msg, hostname, DNS_TYPE_A);

    if (len < 0) {

        cyg_drv_mutex_unlock(&dns_mutex);

        CYG_REPORT_RETVAL( NULL );

        return NULL;

    }

    /* Send the query and wait for an answer */

    len = send_recv(msg, len, sizeof(msg));

    if (len < 0) {

        cyg_drv_mutex_unlock(&dns_mutex);

        CYG_REPORT_RETVAL( NULL );

        return NULL;

    }

    /* Decode the answer */

    hent = parse_answer(msg, DNS_TYPE_A);

    if (hent) {

        cyg_drv_mutex_unlock(&dns_mutex);

        store_hent(hent);

        CYG_REPORT_RETVAL( hent );

        return hent;

    }

    /* If no match, try appending the domainname if we have one */

    if (domainname) {

        if ((strlen(hostname) + strlen(domainname)) > 254) {

            h_errno = NO_RECOVERY;

            cyg_drv_mutex_unlock(&dns_mutex);

            CYG_REPORT_RETVAL( NULL );

            return NULL;

        }

        strcpy(name, hostname);

        strcat(name, ".");

        strcat(name, domainname);

        memset(msg, 0, sizeof(msg));

        len = build_query(msg, name, DNS_TYPE_A);

        if (len < 0) {

            cyg_drv_mutex_unlock(&dns_mutex);

            CYG_REPORT_RETVAL( NULL );

            return NULL;

        }

        /* Send the query and wait for an answer */

        len = send_recv(msg, len, sizeof(msg));

        if (len < 0) {

            cyg_drv_mutex_unlock(&dns_mutex);

            CYG_REPORT_RETVAL( NULL );

            return NULL;

        }

        /* Decode the answer */

        hent = parse_answer(msg, DNS_TYPE_A);

    }

    cyg_drv_mutex_unlock(&dns_mutex);

    store_hent(hent);

    CYG_REPORT_RETVAL( hent );

    return hent;

}

/* Set the domain names, as used by the DNS server */

int

setdomainname(const char *name, size_t len)

{

    char * ptr;

    CYG_REPORT_FUNCNAMETYPE( "setdomainname", "returning %d" );

    CYG_REPORT_FUNCARG2( "name=%08x, len=%d", name, len );

    if ((len < 0) || (len > 255)) {

        h_errno = NO_RECOVERY;

        CYG_REPORT_RETVAL( -1 );

        return -1;

    }

    if (len != 0) {

        CYG_CHECK_DATA_PTR( name, "name is not a valid pointer!" );

        ptr = alloc_string(len+1);

        if (!ptr) {

            CYG_REPORT_RETVAL( -1 );

            return -1;

        }

        memcpy(ptr, name, len);

        ptr[len]=0;

    } else {

        ptr = NULL;

    }

    if (domainname) {

        free_string(domainname);

    }

    domainname = ptr;

    CYG_REPORT_RETVAL( 0 );

    return 0;

}

/* Return the domain name as used by the DNS server */

int

getdomainname(char *name, size_t len)

{

    CYG_REPORT_FUNCNAMETYPE( "getdomainname", "returning %d" );

    CYG_REPORT_FUNCARG2( "name=%08x, len=%d", name, len );

    if ( !name || 0 == len) {

        CYG_REPORT_RETVAL( -1 );

        return -1;

    }

    CYG_CHECK_DATA_PTR( name, "name is not a valid pointer!" );

    /* No domainname set, return a 0 */

    if (!domainname) {

        if (len == 0) {

            h_errno = HOST_NOT_FOUND;

            CYG_REPORT_RETVAL( -1 );

            return -1;

        }

        name[0]='\0';

    } else {

        if ((strlen(domainname) + 1) > len) {

            h_errno = NO_RECOVERY;

            CYG_REPORT_RETVAL( -1 );

            return -1;

        }

        strncpy(name, domainname, len);

    }

    CYG_REPORT_RETVAL( 0 );

    return 0;

}

int h_errno = DNS_SUCCESS;

const char*

hstrerror(int err)

{

    CYG_REPORT_FUNCNAMETYPE( "hstrerror", "returning %08x" );

    CYG_REPORT_FUNCARG1( "err=%d", err );

    switch (err) {

    case DNS_SUCCESS:

        return "No error";

    case HOST_NOT_FOUND:

        return "No such host is known";

    case TRY_AGAIN:

        return "Timeout";

    case NO_RECOVERY:

        return "Server failure or invalid input";

    case NO_DATA:

        return "No data for type";

    default:

        return "Uknown error";

    }

}

//-----------------------------------------------------------------------------

#endif // CYGONCE_NS_DNS_DNS_IMPL_H

// End of dns_impl.h