dns.c File Reference

DNS protocol. More...

#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>

Go to the source code of this file.

Data Structures
struct	dns_request
	A DNS request. More...
Functions
	FILE_LICENCE (GPL2_OR_LATER)
	FEATURE (FEATURE_PROTOCOL,"DNS", DHCP_EB_FEATURE_DNS, 1)
static void	dns_done (struct dns_request *dns, int rc)
	Mark DNS request as complete.
static int	dns_name_cmp (struct dns_request *dns, const struct dns_header *reply, const char *rname)
	Compare DNS reply name against the query name from the original request.
static const char *	dns_skip_name (const char *name)
	Skip over a (possibly compressed) DNS name.
static union dns_rr_info *	dns_find_rr (struct dns_request *dns, const struct dns_header *reply)
	Find an RR in a reply packet corresponding to our query.
static char *	dns_qualify_name (const char *string)
	Append DHCP domain name if available and name is not fully qualified.
static char *	dns_make_name (const char *string, char *buf)
	Convert a standard NUL-terminated string to a DNS name.
static char *	dns_unmake_name (char *name)
	Convert an uncompressed DNS name to a NUL-terminated string.
static char *	dns_decompress_name (const struct dns_header *reply, const char *name, char *buf)
	Decompress a DNS name.
static int	dns_send_packet (struct dns_request *dns)
	Send next packet in DNS request.
static void	dns_timer_expired (struct retry_timer *timer, int fail)
	Handle DNS retransmission timer expiry.
static int	dns_xfer_deliver_raw (struct xfer_interface *socket, const void *data, size_t len)
	Receive new data.
static void	dns_xfer_close (struct xfer_interface *socket, int rc)
	Receive new data.
static int	dns_resolv (struct resolv_interface *resolv, const char *name, struct sockaddr *sa)
	Resolve name using DNS.
struct resolver dns_resolver	__resolver (RESOLV_NORMAL)
	DNS name resolver.
static int	apply_dns_settings (void)
	Apply DNS settings.
Variables
static struct sockaddr_tcpip	nameserver
	The DNS server.
static char *	localdomain
	The local domain.
static struct xfer_interface_operations	dns_socket_operations
	DNS socket operations.
struct setting dns_setting	__setting
	DNS server setting.
struct settings_applicator dns_applicator	__settings_applicator
	DNS settings applicator.

---

Detailed Description

DNS protocol.

Definition in file dns.c.

---

Function Documentation

FILE_LICENCE

(

GPL2_OR_LATER

)

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

static void dns_done	(	struct dns_request *	dns,
		int	rc
	)			[static]

Mark DNS request as complete.

Parameters:

	dns	DNS request
	rc	Return status code

Definition at line 87 of file dns.c.

References dns_request::resolv, resolv_done(), dns_request::sa, dns_request::socket, stop_timer(), dns_request::timer, and xfer_close().

Referenced by dns_timer_expired(), dns_xfer_close(), and dns_xfer_deliver_raw().

                                                         {

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

static int dns_name_cmp	(	struct dns_request *	dns,
		const struct dns_header *	reply,
		const char *	rname
	)			[static]

Compare DNS reply name against the query name from the original request.

Parameters:

	dns	DNS request
	reply	DNS reply
	rname	Reply name

Return values:

	zero	Names match
	non-zero	Names do not match

Definition at line 109 of file dns.c.

References ntohs, dns_query::payload, and dns_request::query.

Referenced by dns_find_rr().

                                              {
        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;
                }
        }
}

static const char* dns_skip_name

(

const char *

name

)

[static]

Skip over a (possibly compressed) DNS name.

Parameters:

name

DNS name

Return values:

name

Next DNS name

Definition at line 141 of file dns.c.

Referenced by dns_find_rr().

                                                       {
        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;
        }
}

static union dns_rr_info* dns_find_rr	(	struct dns_request *	dns,
		const struct dns_header *	reply
	)			[static, write]

Find an RR in a reply packet corresponding to our query.

Parameters:

	dns	DNS request
	reply	DNS reply

Return values:

rr

DNS RR, or NULL if not found

Definition at line 163 of file dns.c.

References dns_header::ancount, dns_rr_info::common, dns_name_cmp(), dns_skip_name(), ntohs, NULL, dns_header::qdcount, and dns_rr_info_common::rdlength.

Referenced by dns_xfer_deliver_raw().

                                                                          {
        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;
}

static char* dns_qualify_name

(

const char *

string

)

[static]

Append DHCP domain name if available and name is not fully qualified.

Parameters:

string

Name as a NUL-terminated string

Return values:

fqdn

Fully-qualified domain name, malloc'd copy

The caller must free fqdn which is allocated even if the name is already fully qualified.

Definition at line 197 of file dns.c.

References asprintf(), localdomain, strchr(), and strdup().

Referenced by dns_resolv().

                                                      {
        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;
}

static char* dns_make_name	(	const char *	string,
		char *	buf
	)			[static]

Convert a standard NUL-terminated string to a DNS name.

Parameters:

	string	Name as a NUL-terminated string
	buf	Buffer in which to place DNS name

Return values:

next

Byte following constructed DNS name

DNS names consist of "<length>element" pairs.

Definition at line 218 of file dns.c.

Referenced by dns_resolv().

                                                              {
        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;
}

static char* dns_unmake_name

(

char *

name

)

[inline, static]

Convert an uncompressed DNS name to a NUL-terminated string.

Parameters:

name

DNS name

Return values:

string

NUL-terminated string

Produce a printable version of a DNS name. Used only for debugging.

Definition at line 242 of file dns.c.

                                                    {
        char *p;
        unsigned int len;

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

        return name + 1;
}

static char* dns_decompress_name	(	const struct dns_header *	reply,
		const char *	name,
		char *	buf
	)			[static]

Decompress a DNS name.

Parameters:

	reply	DNS replay
	name	DNS name
	buf	Buffer into which to decompress DNS name

Return values:

next

Byte following decompressed DNS name

Definition at line 263 of file dns.c.

References ntohs.

Referenced by dns_xfer_deliver_raw().

                                                                  {
        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;
}

static int dns_send_packet

(

struct dns_request *

dns

)

[static]

Send next packet in DNS request.

Parameters:

dns

DNS request

Definition at line 287 of file dns.c.

References DBGC, dns_query::dns, htons, dns_header::id, dns_request::qinfo, dns_request::query, dns_request::socket, start_timer(), dns_request::timer, and xfer_deliver_raw().

Referenced by dns_resolv(), dns_timer_expired(), and dns_xfer_deliver_raw().

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

static void dns_timer_expired	(	struct retry_timer *	timer,
		int	fail
	)			[static]

Handle DNS retransmission timer expiry.

Parameters:

	timer	Retry timer
	fail	Failure indicator

Definition at line 311 of file dns.c.

References container_of, dns_done(), dns_send_packet(), and ETIMEDOUT.

Referenced by dns_resolv().

                                                                      {
        struct dns_request *dns =
                container_of ( timer, struct dns_request, timer );

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

static int dns_xfer_deliver_raw	(	struct xfer_interface *	socket,
		const void *	data,
		size_t	len
	)			[static]

Receive new data.

Parameters:

	socket	UDP socket
	data	DNS reply
	len	Length of DNS reply

Return values:

rc

Return status code

Definition at line 330 of file dns.c.

References dns_rr_info::a, AF_INET, assert, dns_rr_info_cname::cname, dns_rr_info::cname, dns_rr_info::common, container_of, DBGC, dns_query::dns, DNS_CLASS_IN, dns_decompress_name(), dns_done(), dns_find_rr(), DNS_MAX_CNAME_RECURSION, dns_send_packet(), DNS_TYPE_A, DNS_TYPE_CNAME, EINVAL, ELOOP, ENXIO, htons, dns_header::id, dns_rr_info_a::in_addr, inet_ntoa(), ntohs, dns_query::payload, dns_query_info::qclass, dns_request::qinfo, dns_query_info::qtype, dns_request::query, dns_request::recursion, dns_request::sa, sockaddr_in::sin_addr, sockaddr_in::sin_family, stop_timer(), dns_request::timer, and dns_rr_info_common::type.

                                                                 {
        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;
        }
}

static void dns_xfer_close	(	struct xfer_interface *	socket,
		int	rc
	)			[static]

Receive new data.

Parameters:

	socket	UDP socket
	rc	Reason for close

Definition at line 451 of file dns.c.

References container_of, dns_done(), and ECONNABORTED.

                                                                     {
        struct dns_request *dns =
                container_of ( socket, struct dns_request, socket );

        if ( ! rc )
                rc = -ECONNABORTED;

        dns_done ( dns, rc );
}

static int dns_resolv	(	struct resolv_interface *	resolv,
		const char *	name,
		struct sockaddr *	sa
	)			[static]

Resolve name using DNS.

Parameters:

	resolv	Name resolution interface
	name	Name to resolve
	sa	Socket address to fill in

Return values:

rc

Return status code

Definition at line 479 of file dns.c.

References DBG, DBGC, dns_query::dns, DNS_CLASS_IN, DNS_FLAG_OPCODE_QUERY, DNS_FLAG_QUERY, DNS_FLAG_RD, dns_make_name(), dns_qualify_name(), dns_send_packet(), dns_timer_expired(), DNS_TYPE_A, ENOMEM, ENXIO, retry_timer::expired, dns_header::flags, free(), htons, memcpy, NULL, null_resolv_ops, dns_query::payload, dns_query_info::qclass, dns_header::qdcount, dns_request::qinfo, dns_query_info::qtype, dns_request::query, ref_put(), dns_request::refcnt, dns_request::resolv, resolv_init(), resolv_plug_plug(), dns_request::sa, SOCK_DGRAM, dns_request::socket, sockaddr_tcpip::st_family, strerror(), dns_request::timer, xfer_init(), xfer_open_socket(), and zalloc().

                                                                {
        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;
}

struct resolver dns_resolver __resolver

(

RESOLV_NORMAL

)

[read]

DNS name resolver.

static int apply_dns_settings

(

void

)

[static]

Apply DNS settings.

Return values:

rc

Return status code

Definition at line 580 of file dns.c.

References AF_INET, DBG, fetch_ipv4_setting(), fetch_string_setting_copy(), inet_ntoa(), localdomain, NULL, sockaddr_in::sin_addr, and sockaddr_in::sin_family.

                                       {
        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;
}

---

Variable Documentation

struct sockaddr_tcpip nameserver [static]

Initial value:

 {
        .st_port = htons ( DNS_PORT ),
}

The DNS server.

Definition at line 49 of file dns.c.

char* localdomain [static]

The local domain.

Definition at line 54 of file dns.c.

Referenced by apply_dns_settings(), and dns_qualify_name().

struct xfer_interface_operations dns_socket_operations [static]

Initial value:

 {
        .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,
}

DNS socket operations.

Definition at line 462 of file dns.c.

struct settings_applicator dns_applicator __settings_applicator

Initial value:

 {
        .apply = apply_dns_settings,
}

DNS settings applicator.

Definition at line 601 of file dns.c.