source: bootcd/isolinux/syslinux-6.03/gpxe/src/net/udp/dns.c

/*
 * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
 *
 * Portions copyright (C) 2004 Anselm M. Hoffmeister
 * <stockholm@users.sourceforge.net>.
 *
 * This program 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 of the
 * License, or any later version.
 *
 * This program 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 this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

FILE_LICENCE ( GPL2_OR_LATER );

#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <byteswap.h>
#include <gpxe/refcnt.h>
#include <gpxe/xfer.h>
#include <gpxe/open.h>
#include <gpxe/resolv.h>
#include <gpxe/retry.h>
#include <gpxe/tcpip.h>
#include <gpxe/settings.h>
#include <gpxe/features.h>
#include <gpxe/dns.h>

/** @file
 *
 * DNS protocol
 *
 */

FEATURE ( FEATURE_PROTOCOL, "DNS", DHCP_EB_FEATURE_DNS, 1 );

/** The DNS server */
static struct sockaddr_tcpip nameserver = {
        .st_port = htons ( DNS_PORT ),
};

/** The local domain */
static char *localdomain;

/** A DNS request */
struct dns_request {
        /** Reference counter */
        struct refcnt refcnt;
        /** Name resolution interface */
        struct resolv_interface resolv;
        /** Data transfer interface */
        struct xfer_interface socket;
        /** Retry timer */
        struct retry_timer timer;

        /** Socket address to fill in with resolved address */
        struct sockaddr sa;
        /** Current query packet */
        struct dns_query query;
        /** Location of query info structure within current packet
         *
         * The query info structure is located immediately after the
         * compressed name.
         */
        struct dns_query_info *qinfo;
        /** Recursion counter */
        unsigned int recursion;
};

/**
 * Mark DNS request as complete
 *
 * @v dns               DNS request
 * @v rc                Return status code
 */
static void dns_done ( struct dns_request *dns, int rc ) {

        /* Stop the retry timer */
        stop_timer ( &dns->timer );

        /* Close data transfer interface */
        xfer_nullify ( &dns->socket );
        xfer_close ( &dns->socket, rc );

        /* Mark name resolution as complete */
        resolv_done ( &dns->resolv, &dns->sa, rc );
}

/**
 * Compare DNS reply name against the query name from the original request
 *
 * @v dns               DNS request
 * @v reply             DNS reply
 * @v rname             Reply name
 * @ret zero            Names match
 * @ret non-zero        Names do not match
 */
static int dns_name_cmp ( struct dns_request *dns,
                          const struct dns_header *reply, 
                          const char *rname ) {
        const char *qname = dns->query.payload;
        int i;

        while ( 1 ) {
                /* Obtain next section of rname */
                while ( ( *rname ) & 0xc0 ) {
                        rname = ( ( ( char * ) reply ) +
                                  ( ntohs( *((uint16_t *)rname) ) & ~0xc000 ));
                }
                /* Check that lengths match */
                if ( *rname != *qname )
                        return -1;
                /* If length is zero, we have reached the end */
                if ( ! *qname )
                        return 0;
                /* Check that data matches */
                for ( i = *qname + 1; i > 0 ; i-- ) {
                        if ( *(rname++) != *(qname++) )
                                return -1;
                }
        }
}

/**
 * Skip over a (possibly compressed) DNS name
 *
 * @v name              DNS name
 * @ret name            Next DNS name
 */
static const char * dns_skip_name ( const char *name ) {
        while ( 1 ) {
                if ( ! *name ) {
                        /* End of name */
                        return ( name + 1);
                }
                if ( *name & 0xc0 ) {
                        /* Start of a compressed name */
                        return ( name + 2 );
                }
                /* Uncompressed name portion */
                name += *name + 1;
        }
}

/**
 * Find an RR in a reply packet corresponding to our query
 *
 * @v dns               DNS request
 * @v reply             DNS reply
 * @ret rr              DNS RR, or NULL if not found
 */
static union dns_rr_info * dns_find_rr ( struct dns_request *dns,
                                         const struct dns_header *reply ) {
        int i, cmp;
        const char *p = ( ( char * ) reply ) + sizeof ( struct dns_header );
        union dns_rr_info *rr_info;

        /* Skip over the questions section */
        for ( i = ntohs ( reply->qdcount ) ; i > 0 ; i-- ) {
                p = dns_skip_name ( p ) + sizeof ( struct dns_query_info );
        }

        /* Process the answers section */
        for ( i = ntohs ( reply->ancount ) ; i > 0 ; i-- ) {
                cmp = dns_name_cmp ( dns, reply, p );
                p = dns_skip_name ( p );
                rr_info = ( ( union dns_rr_info * ) p );
                if ( cmp == 0 )
                        return rr_info;
                p += ( sizeof ( rr_info->common ) +
                       ntohs ( rr_info->common.rdlength ) );
        }

        return NULL;
}

/**
 * Append DHCP domain name if available and name is not fully qualified
 *
 * @v string            Name as a NUL-terminated string
 * @ret fqdn            Fully-qualified domain name, malloc'd copy
 *
 * The caller must free fqdn which is allocated even if the name is already
 * fully qualified.
 */
static char * dns_qualify_name ( const char *string ) {
        char *fqdn;

        /* Leave unchanged if already fully-qualified or no local domain */
        if ( ( ! localdomain ) || ( strchr ( string, '.' ) != 0 ) )
                return strdup ( string );

        /* Append local domain to name */
        asprintf ( &fqdn, "%s.%s", string, localdomain );
        return fqdn;
}

/**
 * Convert a standard NUL-terminated string to a DNS name
 *
 * @v string            Name as a NUL-terminated string
 * @v buf               Buffer in which to place DNS name
 * @ret next            Byte following constructed DNS name
 *
 * DNS names consist of "<length>element" pairs.
 */
static char * dns_make_name ( const char *string, char *buf ) {
        char *length_byte = buf++;
        char c;

        while ( ( c = *(string++) ) ) {
                if ( c == '.' ) {
                        *length_byte = buf - length_byte - 1;
                        length_byte = buf;
                }
                *(buf++) = c;
        }
        *length_byte = buf - length_byte - 1;
        *(buf++) = '\0';
        return buf;
}

/**
 * Convert an uncompressed DNS name to a NUL-terminated string
 *
 * @v name              DNS name
 * @ret string          NUL-terminated string
 *
 * Produce a printable version of a DNS name.  Used only for debugging.
 */
static inline char * dns_unmake_name ( char *name ) {
        char *p;
        unsigned int len;

        p = name;
        while ( ( len = *p ) ) {
                *(p++) = '.';
                p += len;
        }

        return name + 1;
}

/**
 * Decompress a DNS name
 *
 * @v reply             DNS replay
 * @v name              DNS name
 * @v buf               Buffer into which to decompress DNS name
 * @ret next            Byte following decompressed DNS name
 */
static char * dns_decompress_name ( const struct dns_header *reply,
                                    const char *name, char *buf ) {
        int i, len;

        do {
                /* Obtain next section of name */
                while ( ( *name ) & 0xc0 ) {
                        name = ( ( char * ) reply +
                                 ( ntohs ( *((uint16_t *)name) ) & ~0xc000 ) );
                }
                /* Copy data */
                len = *name;
                for ( i = len + 1 ; i > 0 ; i-- ) {
                        *(buf++) = *(name++);
                }
        } while ( len );
        return buf;
}

/**
 * Send next packet in DNS request
 *
 * @v dns               DNS request
 */
static int dns_send_packet ( struct dns_request *dns ) {
        static unsigned int qid = 0;
        size_t qlen;

        /* Increment query ID */
        dns->query.dns.id = htons ( ++qid );

        DBGC ( dns, "DNS %p sending query ID %d\n", dns, qid );

        /* Start retransmission timer */
        start_timer ( &dns->timer );

        /* Send the data */
        qlen = ( ( ( void * ) dns->qinfo ) - ( ( void * ) &dns->query )
                 + sizeof ( dns->qinfo ) );
        return xfer_deliver_raw ( &dns->socket, &dns->query, qlen );
}

/**
 * Handle DNS retransmission timer expiry
 *
 * @v timer             Retry timer
 * @v fail              Failure indicator
 */
static void dns_timer_expired ( struct retry_timer *timer, int fail ) {
        struct dns_request *dns =
                container_of ( timer, struct dns_request, timer );

        if ( fail ) {
                dns_done ( dns, -ETIMEDOUT );
        } else {
                dns_send_packet ( dns );
        }
}

/**
 * Receive new data
 *
 * @v socket            UDP socket
 * @v data              DNS reply
 * @v len               Length of DNS reply
 * @ret rc              Return status code
 */
static int dns_xfer_deliver_raw ( struct xfer_interface *socket,
                                  const void *data, size_t len ) {
        struct dns_request *dns =
                container_of ( socket, struct dns_request, socket );
        const struct dns_header *reply = data;
        union dns_rr_info *rr_info;
        struct sockaddr_in *sin;
        unsigned int qtype = dns->qinfo->qtype;

        /* Sanity check */
        if ( len < sizeof ( *reply ) ) {
                DBGC ( dns, "DNS %p received underlength packet length %zd\n",
                       dns, len );
                return -EINVAL;
        }

        /* Check reply ID matches query ID */
        if ( reply->id != dns->query.dns.id ) {
                DBGC ( dns, "DNS %p received unexpected reply ID %d "
                       "(wanted %d)\n", dns, ntohs ( reply->id ),
                       ntohs ( dns->query.dns.id ) );
                return -EINVAL;
        }

        DBGC ( dns, "DNS %p received reply ID %d\n", dns, ntohs ( reply->id ));

        /* Stop the retry timer.  After this point, each code path
         * must either restart the timer by calling dns_send_packet(),
         * or mark the DNS operation as complete by calling
         * dns_done()
         */
        stop_timer ( &dns->timer );

        /* Search through response for useful answers.  Do this
         * multiple times, to take advantage of useful nameservers
         * which send us e.g. the CNAME *and* the A record for the
         * pointed-to name.
         */
        while ( ( rr_info = dns_find_rr ( dns, reply ) ) ) {
                switch ( rr_info->common.type ) {

                case htons ( DNS_TYPE_A ):

                        /* Found the target A record */
                        DBGC ( dns, "DNS %p found address %s\n",
                               dns, inet_ntoa ( rr_info->a.in_addr ) );
                        sin = ( struct sockaddr_in * ) &dns->sa;
                        sin->sin_family = AF_INET;
                        sin->sin_addr = rr_info->a.in_addr;

                        /* Mark operation as complete */
                        dns_done ( dns, 0 );
                        return 0;

                case htons ( DNS_TYPE_CNAME ):

                        /* Found a CNAME record; update query and recurse */
                        DBGC ( dns, "DNS %p found CNAME\n", dns );
                        dns->qinfo = ( void * ) dns_decompress_name ( reply,
                                                         rr_info->cname.cname,
                                                         dns->query.payload );
                        dns->qinfo->qtype = htons ( DNS_TYPE_A );
                        dns->qinfo->qclass = htons ( DNS_CLASS_IN );
                        
                        /* Terminate the operation if we recurse too far */
                        if ( ++dns->recursion > DNS_MAX_CNAME_RECURSION ) {
                                DBGC ( dns, "DNS %p recursion exceeded\n",
                                       dns );
                                dns_done ( dns, -ELOOP );
                                return 0;
                        }
                        break;

                default:
                        DBGC ( dns, "DNS %p got unknown record type %d\n",
                               dns, ntohs ( rr_info->common.type ) );
                        break;
                }
        }
        
        /* Determine what to do next based on the type of query we
         * issued and the reponse we received
         */
        switch ( qtype ) {

        case htons ( DNS_TYPE_A ):
                /* We asked for an A record and got nothing;
                 * try the CNAME.
                 */
                DBGC ( dns, "DNS %p found no A record; trying CNAME\n", dns );
                dns->qinfo->qtype = htons ( DNS_TYPE_CNAME );
                dns_send_packet ( dns );
                return 0;

        case htons ( DNS_TYPE_CNAME ):
                /* We asked for a CNAME record.  If we got a response
                 * (i.e. if the next A query is already set up), then
                 * issue it, otherwise abort.
                 */
                if ( dns->qinfo->qtype == htons ( DNS_TYPE_A ) ) {
                        dns_send_packet ( dns );
                        return 0;
                } else {
                        DBGC ( dns, "DNS %p found no CNAME record\n", dns );
                        dns_done ( dns, -ENXIO );
                        return 0;
                }

        default:
                assert ( 0 );
                dns_done ( dns, -EINVAL );
                return 0;
        }
}

/**
 * Receive new data
 *
 * @v socket            UDP socket
 * @v rc                Reason for close
 */
static void dns_xfer_close ( struct xfer_interface *socket, int rc ) {
        struct dns_request *dns =
                container_of ( socket, struct dns_request, socket );

        if ( ! rc )
                rc = -ECONNABORTED;

        dns_done ( dns, rc );
}

/** DNS socket operations */
static struct xfer_interface_operations dns_socket_operations = {
        .close          = dns_xfer_close,
        .vredirect      = xfer_vreopen,
        .window         = unlimited_xfer_window,
        .alloc_iob      = default_xfer_alloc_iob,
        .deliver_iob    = xfer_deliver_as_raw,
        .deliver_raw    = dns_xfer_deliver_raw,
};

/**
 * Resolve name using DNS
 *
 * @v resolv            Name resolution interface
 * @v name              Name to resolve
 * @v sa                Socket address to fill in
 * @ret rc              Return status code
 */
static int dns_resolv ( struct resolv_interface *resolv,
                        const char *name, struct sockaddr *sa ) {
        struct dns_request *dns;
        char *fqdn;
        int rc;

        /* Fail immediately if no DNS servers */
        if ( ! nameserver.st_family ) {
                DBG ( "DNS not attempting to resolve \"%s\": "
                      "no DNS servers\n", name );
                rc = -ENXIO;
                goto err_no_nameserver;
        }

        /* Ensure fully-qualified domain name if DHCP option was given */
        fqdn = dns_qualify_name ( name );
        if ( ! fqdn ) {
                rc = -ENOMEM;
                goto err_qualify_name;
        }

        /* Allocate DNS structure */
        dns = zalloc ( sizeof ( *dns ) );
        if ( ! dns ) {
                rc = -ENOMEM;
                goto err_alloc_dns;
        }
        resolv_init ( &dns->resolv, &null_resolv_ops, &dns->refcnt );
        xfer_init ( &dns->socket, &dns_socket_operations, &dns->refcnt );
        dns->timer.expired = dns_timer_expired;
        memcpy ( &dns->sa, sa, sizeof ( dns->sa ) );

        /* Create query */
        dns->query.dns.flags = htons ( DNS_FLAG_QUERY | DNS_FLAG_OPCODE_QUERY |
                                       DNS_FLAG_RD );
        dns->query.dns.qdcount = htons ( 1 );
        dns->qinfo = ( void * ) dns_make_name ( fqdn, dns->query.payload );
        dns->qinfo->qtype = htons ( DNS_TYPE_A );
        dns->qinfo->qclass = htons ( DNS_CLASS_IN );

        /* Open UDP connection */
        if ( ( rc = xfer_open_socket ( &dns->socket, SOCK_DGRAM,
                                       ( struct sockaddr * ) &nameserver,
                                       NULL ) ) != 0 ) {
                DBGC ( dns, "DNS %p could not open socket: %s\n",
                       dns, strerror ( rc ) );
                goto err_open_socket;
        }

        /* Send first DNS packet */
        dns_send_packet ( dns );

        /* Attach parent interface, mortalise self, and return */
        resolv_plug_plug ( &dns->resolv, resolv );
        ref_put ( &dns->refcnt );
        free ( fqdn );
        return 0;       

 err_open_socket:
 err_alloc_dns:
        ref_put ( &dns->refcnt );
 err_qualify_name:
        free ( fqdn );
 err_no_nameserver:
        return rc;
}

/** DNS name resolver */
struct resolver dns_resolver __resolver ( RESOLV_NORMAL ) = {
        .name = "DNS",
        .resolv = dns_resolv,
};

/******************************************************************************
 *
 * Settings
 *
 ******************************************************************************
 */

/** DNS server setting */
struct setting dns_setting __setting = {
        .name = "dns",
        .description = "DNS server",
        .tag = DHCP_DNS_SERVERS,
        .type = &setting_type_ipv4,
};

/** Domain name setting */
struct setting domain_setting __setting = {
        .name = "domain",
        .description = "Local domain",
        .tag = DHCP_DOMAIN_NAME,
        .type = &setting_type_string,
};

/**
 * Apply DNS settings
 *
 * @ret rc              Return status code
 */
static int apply_dns_settings ( void ) {
        struct sockaddr_in *sin_nameserver =
                ( struct sockaddr_in * ) &nameserver;
        int len;

        if ( ( len = fetch_ipv4_setting ( NULL, &dns_setting,
                                          &sin_nameserver->sin_addr ) ) >= 0 ){
                sin_nameserver->sin_family = AF_INET;
                DBG ( "DNS using nameserver %s\n",
                      inet_ntoa ( sin_nameserver->sin_addr ) );
        }

        /* Get local domain DHCP option */
        if ( ( len = fetch_string_setting_copy ( NULL, &domain_setting,
                                                 &localdomain ) ) >= 0 )
                DBG ( "DNS local domain %s\n", localdomain );

        return 0;
}

/** DNS settings applicator */
struct settings_applicator dns_applicator __settings_applicator = {
        .apply = apply_dns_settings,
};