dns.c File Reference

DNS protocol. More...

#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/refcnt.h>
#include <ipxe/iobuf.h>
#include <ipxe/xfer.h>
#include <ipxe/open.h>
#include <ipxe/resolv.h>
#include <ipxe/retry.h>
#include <ipxe/tcpip.h>
#include <ipxe/settings.h>
#include <ipxe/features.h>
#include <ipxe/job.h>
#include <ipxe/dhcp.h>
#include <ipxe/dhcpv6.h>
#include <ipxe/dns.h>

Go to the source code of this file.

Data Structures
struct	dns_server
	A DNS server list. More...
struct	dns_request
	A DNS request. More...

Macros
#define	ENXIO_NO_RECORD   __einfo_error ( EINFO_ENXIO_NO_RECORD )
#define	EINFO_ENXIO_NO_RECORD   __einfo_uniqify ( EINFO_ENXIO, 0x01, "DNS name does not exist" )
#define	ENXIO_NO_NAMESERVER   __einfo_error ( EINFO_ENXIO_NO_NAMESERVER )
#define	EINFO_ENXIO_NO_NAMESERVER   __einfo_uniqify ( EINFO_ENXIO, 0x02, "No DNS servers available" )

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
	FEATURE (FEATURE_PROTOCOL, "DNS", DHCP_EB_FEATURE_DNS, 1)
int	dns_encode (const char *string, struct dns_name *name)
	Encode a DNS name using RFC1035 encoding.
static int	dns_label (struct dns_name *name, size_t offset)
	Find start of valid label within an RFC1035-encoded DNS name.
int	dns_decode (struct dns_name *name, char *data, size_t len)
	Decode RFC1035-encoded DNS name.
int	dns_compare (struct dns_name *first, struct dns_name *second)
	Compare DNS names for equality.
int	dns_copy (struct dns_name *src, struct dns_name *dst)
	Copy a DNS name.
int	dns_skip (struct dns_name *name)
	Skip RFC1035-encoded DNS name.
static int	dns_skip_search (struct dns_name *name)
	Skip RFC1035-encoded DNS name in search list.
static const char *	dns_name (struct dns_name *name)
	Transcribe DNS name (for debugging).
static const char *	dns_type (uint16_t type)
	Name a DNS query type (for debugging).
static void	dns_done (struct dns_request *dns, int rc)
	Mark DNS request as complete.
static void	dns_resolved (struct dns_request *dns)
	Mark DNS request as resolved and complete.
static int	dns_question (struct dns_request *dns)
	Construct DNS question.
static int	dns_send_packet (struct dns_request *dns)
	Send DNS query.
static void	dns_timer_expired (struct retry_timer *timer, int fail)
	Handle DNS (re)transmission timer expiry.
static int	dns_xfer_deliver (struct dns_request *dns, struct io_buffer *iobuf, struct xfer_metadata *meta __unused)
	Receive new data.
static void	dns_xfer_close (struct dns_request *dns, int rc)
	Receive new data.
static int	dns_progress (struct dns_request *dns, struct job_progress *progress)
	Report job progress.
static int	dns_resolv (struct interface *resolv, const char *name, struct sockaddr *sa)
	Resolve name using DNS.
struct resolver dns_resolver	__resolver (RESOLV_NORMAL)
	DNS name resolver.
static int	format_dnssl_setting (const struct setting_type *type __unused, const void *raw, size_t raw_len, char *buf, size_t len)
	Format DNS search list setting.
const struct setting dns_setting	__setting (SETTING_IP4_EXTRA, dns)
	IPv4 DNS server setting.
const struct setting dns6_setting	__setting (SETTING_IP6_EXTRA, dns6)
	IPv6 DNS server setting.
const struct setting dnssl_setting	__setting (SETTING_IP_EXTRA, dnssl)
	DNS search list.
static void	apply_dns_servers (void)
	Apply DNS server addresses.
static void	apply_dns_search (void)
	Apply DNS search list.
static int	apply_dns_settings (void)
	Apply DNS settings.

Variables
static struct dns_server	dns4
	IPv4 DNS server list.
static struct dns_server	dns6
	IPv6 DNS server list.
static unsigned int	dns_count
	Total number of DNS servers.
static struct dns_name	dns_search
	The DNS search list.
static struct interface_operation	dns_socket_operations []
	DNS socket interface operations.
static struct interface_descriptor	dns_socket_desc
	DNS socket interface descriptor.
static struct interface_operation	dns_resolv_op []
	DNS resolver interface operations.
static struct interface_descriptor	dns_resolv_desc
	DNS resolver interface descriptor.
const struct setting_type setting_type_dnssl	__setting_type
	A DNS search list setting type.
struct settings_applicator dns_applicator	__settings_applicator
	DNS settings applicator.

Detailed Description

DNS protocol.

Definition in file dns.c.

Macro Definition Documentation

ENXIO_NO_RECORD

#define ENXIO_NO_RECORD   __einfo_error ( EINFO_ENXIO_NO_RECORD )

Definition at line 60 of file dns.c.

EINFO_ENXIO_NO_RECORD

#define EINFO_ENXIO_NO_RECORD   __einfo_uniqify ( EINFO_ENXIO, 0x01, "DNS name does not exist" )

Definition at line 61 of file dns.c.

#define EINFO_ENXIO_NO_RECORD \
        __einfo_uniqify ( EINFO_ENXIO, 0x01, "DNS name does not exist" )

ENXIO_NO_NAMESERVER

#define ENXIO_NO_NAMESERVER   __einfo_error ( EINFO_ENXIO_NO_NAMESERVER )

Definition at line 63 of file dns.c.

Referenced by dns_resolv().

EINFO_ENXIO_NO_NAMESERVER

#define EINFO_ENXIO_NO_NAMESERVER   __einfo_uniqify ( EINFO_ENXIO, 0x02, "No DNS servers available" )

Definition at line 64 of file dns.c.

#define EINFO_ENXIO_NO_NAMESERVER \
        __einfo_uniqify ( EINFO_ENXIO, 0x02, "No DNS servers available" )

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

FEATURE()

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

References DHCP_EB_FEATURE_DNS, and FEATURE_PROTOCOL.

dns_encode()

int dns_encode	(	const char *	string,
		struct dns_name *	name )

Encode a DNS name using RFC1035 encoding.

Parameters

string	DNS name as a string
name	DNS name to fill in

Return values

len	Length of DNS name, or negative error

Definition at line 101 of file dns.c.

                                                             {
        uint8_t *start = ( name->data + name->offset );
        uint8_t *end = ( name->data + name->len );
        uint8_t *dst = start;
        size_t len = 0;
        char c;
 
        /* Encode name */
        while ( ( c = *(string++) ) ) {
 
                /* Handle '.' separators */
                if ( c == '.' ) {
 
                        /* Reject consecutive '.' */
                        if ( ( len == 0 ) && ( dst != start ) )
                                return -EINVAL;
 
                        /* Terminate if this is the trailing '.' */
                        if ( *string == '\0' )
                                break;
 
                        /* Reject initial non-terminating '.' */
                        if ( len == 0 )
                                return -EINVAL;
 
                        /* Reset length */
                        len = 0;
 
                } else {
 
                        /* Increment length */
                        len++;
 
                        /* Check for overflow */
                        if ( len > DNS_MAX_LABEL_LEN )
                                return -EINVAL;
                }
 
                /* Copy byte, update length */
                if ( ++dst < end ) {
                        *dst = c;
                        dst[-len] = len;
                }
        }
 
        /* Add terminating root marker */
        if ( len )
                dst++;
        if ( dst < end )
                *dst = '\0';
        dst++;
 
        return ( dst - start );
}

References DNS_MAX_LABEL_LEN, EINVAL, end, len, name, and start.

Referenced by apply_dns_search(), dns_encode_fail_okx(), dns_encode_okx(), and dns_resolv().

dns_label()

int dns_label ( struct dns_name * name, size_t offset )

static

Find start of valid label within an RFC1035-encoded DNS name.

Parameters

name	DNS name
offset	Current offset

Return values

offset

Offset of label, or negative error

Definition at line 163 of file dns.c.

                                                              {
        const uint8_t *byte;
        const uint16_t *word;
        size_t len;
        size_t ptr;
 
        while ( 1 ) {
 
                /* Fail if we have overrun the DNS name */
                if ( ( offset + sizeof ( *byte) ) > name->len )
                        return -EINVAL;
                byte = ( name->data + offset );
 
                /* Follow compression pointer, if applicable */
                if ( DNS_IS_COMPRESSED ( *byte ) ) {
 
                        /* Fail if we have overrun the DNS name */
                        if ( ( offset + sizeof ( *word ) ) > name->len )
                                return -EINVAL;
                        word = ( name->data + offset );
 
                        /* Extract pointer to new offset */
                        ptr = DNS_COMPRESSED_OFFSET ( ntohs ( *word ) );
 
                        /* Fail if pointer does not point backwards.
                         * (This guarantees termination of the
                         * function.)
                         */
                        if ( ptr >= offset )
                                return -EINVAL;
 
                        /* Continue from new offset */
                        offset = ptr;
                        continue;
                }
 
                /* Fail if we have overrun the DNS name */
                len = *byte;
                if ( ( offset + sizeof ( *byte ) + len ) > name->len )
                        return -EINVAL;
 
                /* We have a valid label */
                return offset;
        }
}

References DNS_COMPRESSED_OFFSET, DNS_IS_COMPRESSED, EINVAL, len, name, ntohs, and offset.

Referenced by dns_compare(), dns_copy(), dns_decode(), and dns_skip().

dns_decode()

int dns_decode	(	struct dns_name *	name,
		char *	data,
		size_t	len )

Decode RFC1035-encoded DNS name.

Parameters

name	DNS name
data	Output buffer
len	Length of output buffer

Return values

len	Length of decoded DNS name, or negative error

Definition at line 217 of file dns.c.

                                                                 {
        unsigned int recursion_limit = name->len; /* Generous upper bound */
        int offset = name->offset;
        const uint8_t *label;
        size_t decoded_len = 0;
        size_t label_len;
        size_t copy_len;
 
        while ( recursion_limit-- ) {
 
                /* Find valid DNS label */
                offset = dns_label ( name, offset );
                if ( offset < 0 )
                        return offset;
 
                /* Terminate if we have reached the root */
                label = ( name->data + offset );
                label_len = *(label++);
                if ( label_len == 0 ) {
                        if ( decoded_len < len )
                                *data = '\0';
                        return decoded_len;
                }
 
                /* Prepend '.' if applicable */
                if ( decoded_len && ( decoded_len++ < len ) )
                        *(data++) = '.';
 
                /* Copy label to output buffer */
                copy_len = ( ( decoded_len < len ) ? ( len - decoded_len ) : 0);
                if ( copy_len > label_len )
                        copy_len = label_len;
                memcpy ( data, label, copy_len );
                data += copy_len;
                decoded_len += label_len;
 
                /* Move to next label */
                offset += ( sizeof ( *label ) + label_len );
        }
 
        /* Recursion limit exceeded */
        return -EINVAL;
}

References data, dns_label(), EINVAL, len, memcpy(), name, and offset.

Referenced by dns_decode_fail_okx(), dns_decode_okx(), dns_list_okx(), dns_name(), dns_progress(), and format_dnssl_setting().

dns_compare()

int dns_compare	(	struct dns_name *	first,
		struct dns_name *	second )

Compare DNS names for equality.

Parameters

first	First DNS name
second	Second DNS name

Return values

rc	Return status code

Definition at line 268 of file dns.c.

                                                                    {
        unsigned int recursion_limit = first->len; /* Generous upper bound */
        int first_offset = first->offset;
        int second_offset = second->offset;
        const uint8_t *first_label;
        const uint8_t *second_label;
        size_t label_len;
        size_t len;
 
        while ( recursion_limit-- ) {
 
                /* Find valid DNS labels */
                first_offset = dns_label ( first, first_offset );
                if ( first_offset < 0 )
                        return first_offset;
                second_offset = dns_label ( second, second_offset );
                if ( second_offset < 0 )
                        return second_offset;
 
                /* Compare label lengths */
                first_label = ( first->data + first_offset );
                second_label = ( second->data + second_offset );
                label_len = *(first_label++);
                if ( label_len != *(second_label++) )
                        return -ENOENT;
                len = ( sizeof ( *first_label ) + label_len );
 
                /* Terminate if we have reached the root */
                if ( label_len == 0 )
                        return 0;
 
                /* Compare label contents (case-insensitively) */
                while ( label_len-- ) {
                        if ( tolower ( *(first_label++) ) !=
                             tolower ( *(second_label++) ) )
                                return -ENOENT;
                }
 
                /* Move to next labels */
                first_offset += len;
                second_offset += len;
        }
 
        /* Recursion limit exceeded */
        return -EINVAL;
}

References dns_name::data, dns_label(), EINVAL, ENOENT, first, len, dns_name::offset, and tolower().

Referenced by dns_compare_fail_okx(), dns_compare_okx(), and dns_xfer_deliver().

dns_copy()

int dns_copy	(	struct dns_name *	src,
		struct dns_name *	dst )

Copy a DNS name.

Parameters

src	Source DNS name
dst	Destination DNS name

Return values

len	Length of copied DNS name, or negative error

Definition at line 322 of file dns.c.

                                                            {
        unsigned int recursion_limit = src->len; /* Generous upper bound */
        int src_offset = src->offset;
        size_t dst_offset = dst->offset;
        const uint8_t *label;
        size_t label_len;
        size_t copy_len;
        size_t len;
 
        while ( recursion_limit-- ) {
 
                /* Find valid DNS label */
                src_offset = dns_label ( src, src_offset );
                if ( src_offset < 0 )
                        return src_offset;
 
                /* Copy as an uncompressed label */
                label = ( src->data + src_offset );
                label_len = *label;
                len = ( sizeof ( *label ) + label_len );
                copy_len = ( ( dst_offset < dst->len ) ?
                             ( dst->len - dst_offset ) : 0 );
                if ( copy_len > len )
                        copy_len = len;
                memcpy ( ( dst->data + dst_offset ), label, copy_len );
                src_offset += len;
                dst_offset += len;
 
                /* Terminate if we have reached the root */
                if ( label_len == 0 )
                        return ( dst_offset - dst->offset );
        }
 
        /* Recursion limit exceeded */
        return -EINVAL;
}

References dns_name::data, dns_label(), EINVAL, dns_name::len, len, memcpy(), dns_name::offset, and src.

Referenced by dns_copy_fail_okx(), dns_copy_okx(), dns_question(), and dns_xfer_deliver().

dns_skip()

int dns_skip

(

struct dns_name *

name

)

Skip RFC1035-encoded DNS name.

Parameters

name

DNS name

Return values

offset

Offset to next name, or negative error

Definition at line 365 of file dns.c.

                                       {
        unsigned int recursion_limit = name->len; /* Generous upper bound */
        int offset = name->offset;
        int prev_offset;
        const uint8_t *label;
        size_t label_len;
 
        while ( recursion_limit-- ) {
 
                /* Find valid DNS label */
                prev_offset = offset;
                offset = dns_label ( name, prev_offset );
                if ( offset < 0 )
                        return offset;
 
                /* Terminate if we have reached a compression pointer */
                if ( offset != prev_offset )
                        return ( prev_offset + sizeof ( uint16_t ) );
 
                /* Skip this label */
                label = ( name->data + offset );
                label_len = *label;
                offset += ( sizeof ( *label ) + label_len );
 
                /* Terminate if we have reached the root */
                if ( label_len == 0 )
                        return offset;
        }
 
        /* Recursion limit exceeded */
        return -EINVAL;
}

References dns_label(), EINVAL, name, and offset.

Referenced by dns_list_okx(), dns_skip_search(), and dns_xfer_deliver().

dns_skip_search()

int dns_skip_search ( struct dns_name * name )

static

Skip RFC1035-encoded DNS name in search list.

Parameters

name

DNS name

Return values

offset

Offset to next non-empty name, or negative error

Definition at line 404 of file dns.c.

                                                     {
        int offset;
 
        /* Find next name */
        offset = dns_skip ( name );
        if ( offset < 0 )
                return offset;
 
        /* Skip over any subsequent empty names (e.g. due to padding
         * bytes used in the NDP DNSSL option).
         */
        while ( ( offset < ( ( int ) name->len ) ) &&
                ( *( ( uint8_t * ) ( name->data + offset ) ) == 0 ) ) {
                offset++;
        }
 
        return offset;
}

References dns_skip(), name, and offset.

Referenced by apply_dns_settings(), and format_dnssl_setting().

dns_name()

const char * dns_name ( struct dns_name * name )

static

Transcribe DNS name (for debugging).

Parameters

name

DNS name

Return values

string

Transcribed DNS name

Definition at line 429 of file dns.c.

                                                       {
        static char buf[256];
        int len;
 
        len = dns_decode ( name, buf, ( sizeof ( buf ) - 1 /* NUL */ ) );
        return ( ( len < 0 ) ? "<INVALID>" : buf );
}

References dns_decode(), len, and name.

dns_type()

const char * dns_type ( uint16_t type )

static

Name a DNS query type (for debugging).

Parameters

type	Query type (in network byte order)

Return values

name

Type name

Definition at line 443 of file dns.c.

                                               {
        switch ( type ) {
        case htons ( DNS_TYPE_A ):      return "A";
        case htons ( DNS_TYPE_AAAA ):   return "AAAA";
        case htons ( DNS_TYPE_CNAME ):  return "CNAME";
        default:                        return "<UNKNOWN>";
        }
}

References DNS_TYPE_A, DNS_TYPE_AAAA, DNS_TYPE_CNAME, htons, and type.

Referenced by dns_question(), and dns_send_packet().

dns_done()

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 509 of file dns.c.

                                                         {
 
        /* Stop the retry timer */
        stop_timer ( &dns->timer );
 
        /* Shut down interfaces */
        intf_shutdown ( &dns->socket, rc );
        intf_shutdown ( &dns->resolv, rc );
}

References intf_shutdown(), rc, dns_request::resolv, dns_request::socket, stop_timer(), and dns_request::timer.

Referenced by dns_resolved(), dns_timer_expired(), dns_xfer_close(), and dns_xfer_deliver().

dns_resolved()

void dns_resolved ( struct dns_request * dns )

static

Mark DNS request as resolved and complete.

Parameters

dns	DNS request
rc	Return status code

Definition at line 525 of file dns.c.

                                                     {
 
        DBGC ( dns, "DNS %p found address %s\n",
               dns, sock_ntoa ( &dns->address.sa ) );
 
        /* Return resolved address */
        resolv_done ( &dns->resolv, &dns->address.sa );
 
        /* Mark operation as complete */
        dns_done ( dns, 0 );
}

References dns_request::address, DBGC, dns_done(), dns_request::resolv, resolv_done(), dns_request::sa, and sock_ntoa().

Referenced by dns_xfer_deliver().

dns_question()

int dns_question ( struct dns_request * dns )

static

Construct DNS question.

Parameters

dns	DNS request

Return values

rc	Return status code

Definition at line 543 of file dns.c.

                                                    {
        static struct dns_name search_root = {
                .data = "",
                .len = 1,
        };
        struct dns_name *search = &dns->search;
        int len;
        size_t offset;
 
        /* Use root suffix if search list is empty */
        if ( search->offset == search->len )
                search = &search_root;
 
        /* Overwrite current suffix */
        dns->name.offset = dns->offset;
        len = dns_copy ( search, &dns->name );
        if ( len < 0 )
                return len;
 
        /* Sanity check */
        offset = ( dns->name.offset + len );
        if ( offset > dns->name.len ) {
                DBGC ( dns, "DNS %p name is too long\n", dns );
                return -EINVAL;
        }
 
        /* Construct question */
        dns->question = ( ( ( void * ) &dns->buf ) + offset );
        dns->question->qtype = dns->qtype;
        dns->question->qclass = htons ( DNS_CLASS_IN );
 
        /* Store length */
        dns->len = ( offset + sizeof ( *(dns->question) ) );
 
        /* Restore name */
        dns->name.offset = offsetof ( typeof ( dns->buf ), name );
 
        /* Reset query ID */
        dns->buf.query.id = 0;
 
        DBGC2 ( dns, "DNS %p question is %s type %s\n", dns,
                dns_name ( &dns->name ), dns_type ( dns->question->qtype ) );
 
        return 0;
}

References dns_request::buf, DBGC, DBGC2, DNS_CLASS_IN, dns_copy(), dns_type(), EINVAL, htons, dns_header::id, dns_name::len, dns_request::len, len, dns_request::name, name, dns_name::offset, dns_request::offset, offset, offsetof, dns_question::qclass, dns_question::qtype, dns_request::qtype, dns_request::query, dns_request::question, dns_request::search, and typeof().

dns_send_packet()

int dns_send_packet ( struct dns_request * dns )

static

Send DNS query.

Parameters

dns	DNS request

Return values

rc	Return status code

Definition at line 595 of file dns.c.

                                                       {
        struct dns_header *query = &dns->buf.query;
        struct xfer_metadata meta;
        unsigned int index;
 
        /* Start retransmission timer */
        start_timer ( &dns->timer );
 
        /* Construct DNS server address */
        memset ( &dns->nameserver, 0, sizeof ( dns->nameserver ) );
        dns->nameserver.st.st_port = htons ( DNS_PORT );
        if ( ! dns_count ) {
                DBGC ( dns, "DNS %p lost DNS servers mid query\n", dns );
                return -EINVAL;
        }
        index = ( dns->index % dns_count );
        if ( index < dns6.count ) {
                dns->nameserver.sin6.sin6_family = AF_INET6;
                memcpy ( &dns->nameserver.sin6.sin6_addr, &dns6.in6[index],
                         sizeof ( dns->nameserver.sin6.sin6_addr ) );
        } else {
                dns->nameserver.sin.sin_family = AF_INET;
                dns->nameserver.sin.sin_addr = dns4.in[index - dns6.count];
        }
 
        /* Construct metadata */
        memset ( &meta, 0, sizeof ( meta ) );
        meta.dest = &dns->nameserver.sa;
 
        /* Generate query identifier if applicable */
        if ( ! query->id )
                query->id = random();
 
        /* Send query */
        DBGC ( dns, "DNS %p sending %s query ID %#04x for %s type %s\n", dns,
               sock_ntoa ( &dns->nameserver.sa ), ntohs ( query->id ),
               dns_name ( &dns->name ), dns_type ( dns->question->qtype ) );
 
        /* Send the data */
        return xfer_deliver_raw_meta ( &dns->socket, query, dns->len, &meta );
}

References AF_INET, AF_INET6, dns_request::buf, DBGC, dns4, dns6, dns_count, DNS_PORT, dns_type(), EINVAL, htons, dns_header::id, dns_request::index, index, dns_request::len, memcpy(), memset(), meta, dns_request::name, dns_request::nameserver, ntohs, dns_question::qtype, dns_request::query, dns_request::question, random(), dns_request::sa, dns_request::sin, dns_request::sin6, sockaddr_in6::sin6_addr, sockaddr_in6::sin6_family, sockaddr_in::sin_addr, sockaddr_in::sin_family, sock_ntoa(), dns_request::socket, dns_request::st, sockaddr_tcpip::st_port, start_timer(), dns_request::timer, and xfer_deliver_raw_meta().

Referenced by dns_timer_expired().

dns_timer_expired()

void dns_timer_expired ( struct retry_timer * timer, int fail )

static

Handle DNS (re)transmission timer expiry.

Parameters

timer	Retry timer
fail	Failure indicator

Definition at line 643 of file dns.c.

                                                                      {
        struct dns_request *dns =
                container_of ( timer, struct dns_request, timer );
 
        /* Terminate DNS request on failure */
        if ( fail ) {
                dns_done ( dns, -ETIMEDOUT );
                return;
        }
 
        /* Move to next DNS server if this is a retransmission */
        if ( dns->buf.query.id )
                dns->index++;
 
        /* Send DNS query */
        dns_send_packet ( dns );
}

References dns_request::buf, container_of, dns_done(), dns_send_packet(), ETIMEDOUT, dns_header::id, dns_request::index, and dns_request::query.

Referenced by dns_resolv().

dns_xfer_deliver()

int dns_xfer_deliver ( struct dns_request * dns, struct io_buffer * iobuf, struct xfer_metadata *meta __unused )

static

Receive new data.

Parameters

dns	DNS request
iobuf	I/O buffer
meta	Data transfer metadata

Return values

rc	Return status code

Definition at line 669 of file dns.c.

                                                                    {
        struct dns_header *query = &dns->buf.query;
        unsigned int qtype = dns->question->qtype;
        struct dns_header *response;
        struct dns_name buf;
        union dns_rr *rr;
        int offset;
        size_t answer_offset;
        size_t next_offset;
        size_t rdlength;
        int name_len;
        int rc;
 
        /* Sanity check */
        if ( iob_len ( iobuf ) < sizeof ( *response ) ) {
                DBGC ( dns, "DNS %p received underlength packet length %zd\n",
                       dns, iob_len ( iobuf ) );
                rc = -EINVAL;
                goto done;
        }
        response = iobuf->data;
 
        /* Check response ID matches query ID */
        if ( response->id != query->id ) {
                DBGC ( dns, "DNS %p received unexpected response ID %#04x "
                       "(wanted %d)\n", dns, ntohs ( response->id ),
                       ntohs ( query->id ) );
                rc = -EINVAL;
                goto done;
        }
        DBGC ( dns, "DNS %p received response ID %#04x\n",
               dns, ntohs ( response->id ) );
 
        /* Check that we have exactly one question */
        if ( response->qdcount != htons ( 1 ) ) {
                DBGC ( dns, "DNS %p received response with %d questions\n",
                       dns, ntohs ( response->qdcount ) );
                rc = -EINVAL;
                goto done;
        }
 
        /* Skip question section */
        buf.data = iobuf->data;
        buf.offset = sizeof ( *response );
        buf.len = iob_len ( iobuf );
        offset = dns_skip ( &buf );
        if ( offset < 0 ) {
                rc = offset;
                DBGC ( dns, "DNS %p received response with malformed "
                       "question: %s\n", dns, strerror ( rc ) );
                goto done;
        }
        answer_offset = ( offset + sizeof ( struct dns_question ) );
 
        /* 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.
         */
        for ( buf.offset = answer_offset ; buf.offset != buf.len ;
              buf.offset = next_offset ) {
 
                /* Check for valid name */
                offset = dns_skip ( &buf );
                if ( offset < 0 ) {
                        rc = offset;
                        DBGC ( dns, "DNS %p received response with malformed "
                               "answer: %s\n", dns, strerror ( rc ) );
                        goto done;
                }
 
                /* Check for sufficient space for resource record */
                rr = ( buf.data + offset );
                if ( ( offset + sizeof ( rr->common ) ) > buf.len ) {
                        DBGC ( dns, "DNS %p received response with underlength "
                               "RR\n", dns );
                        rc = -EINVAL;
                        goto done;
                }
                rdlength = ntohs ( rr->common.rdlength );
                next_offset = ( offset + sizeof ( rr->common ) + rdlength );
                if ( next_offset > buf.len ) {
                        DBGC ( dns, "DNS %p received response with underlength "
                               "RR\n", dns );
                        rc = -EINVAL;
                        goto done;
                }
 
                /* Skip non-matching names */
                if ( dns_compare ( &buf, &dns->name ) != 0 ) {
                        DBGC2 ( dns, "DNS %p ignoring response for %s type "
                                "%s\n", dns, dns_name ( &buf ),
                                dns_type ( rr->common.type ) );
                        continue;
                }
 
                /* Handle answer */
                switch ( rr->common.type ) {
 
                case htons ( DNS_TYPE_AAAA ):
 
                        /* Found the target AAAA record */
                        if ( rdlength < sizeof ( dns->address.sin6.sin6_addr )){
                                DBGC ( dns, "DNS %p received response with "
                                       "underlength AAAA\n", dns );
                                rc = -EINVAL;
                                goto done;
                        }
                        dns->address.sin6.sin6_family = AF_INET6;
                        memcpy ( &dns->address.sin6.sin6_addr,
                                 &rr->aaaa.in6_addr,
                                 sizeof ( dns->address.sin6.sin6_addr ) );
                        dns_resolved ( dns );
                        rc = 0;
                        goto done;
 
                case htons ( DNS_TYPE_A ):
 
                        /* Found the target A record */
                        if ( rdlength < sizeof ( dns->address.sin.sin_addr ) ) {
                                DBGC ( dns, "DNS %p received response with "
                                       "underlength A\n", dns );
                                rc = -EINVAL;
                                goto done;
                        }
                        dns->address.sin.sin_family = AF_INET;
                        dns->address.sin.sin_addr = rr->a.in_addr;
                        dns_resolved ( dns );
                        rc = 0;
                        goto done;
 
                case htons ( DNS_TYPE_CNAME ):
 
                        /* Terminate the operation if we recurse too far */
                        if ( ++dns->recursion > DNS_MAX_CNAME_RECURSION ) {
                                DBGC ( dns, "DNS %p recursion exceeded\n",
                                       dns );
                                rc = -ELOOP;
                                dns_done ( dns, rc );
                                goto done;
                        }
 
                        /* Found a CNAME record; update query and recurse */
                        buf.offset = ( offset + sizeof ( rr->cname ) );
                        DBGC ( dns, "DNS %p found CNAME %s\n",
                               dns, dns_name ( &buf ) );
                        dns->search.offset = dns->search.len;
                        name_len = dns_copy ( &buf, &dns->name );
                        if ( name_len < 0 ) {
                                rc = name_len;
                                dns_done ( dns, rc );
                                goto done;
                        }
                        dns->offset = ( offsetof ( typeof ( dns->buf ), name ) +
                                        name_len - 1 /* Strip root label */ );
                        if ( ( rc = dns_question ( dns ) ) != 0 ) {
                                dns_done ( dns, rc );
                                goto done;
                        }
                        next_offset = answer_offset;
                        break;
 
                default:
                        DBGC ( dns, "DNS %p got unknown record type %d\n",
                               dns, ntohs ( rr->common.type ) );
                        break;
                }
        }
 
        /* 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 );
 
        /* Determine what to do next based on the type of query we
         * issued and the response we received
         */
        switch ( qtype ) {
 
        case htons ( DNS_TYPE_AAAA ):
                /* We asked for an AAAA record and got nothing; try
                 * the A.
                 */
                DBGC ( dns, "DNS %p found no AAAA record; trying A\n", dns );
                dns->question->qtype = htons ( DNS_TYPE_A );
                dns_send_packet ( dns );
                rc = 0;
                goto done;
 
        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->question->qtype = htons ( DNS_TYPE_CNAME );
                dns_send_packet ( dns );
                rc = 0;
                goto done;
 
        case htons ( DNS_TYPE_CNAME ):
                /* We asked for a CNAME record.  If we got a response
                 * (i.e. if the next AAAA/A query is already set up),
                 * then issue it.
                 */
                if ( qtype == dns->qtype ) {
                        dns_send_packet ( dns );
                        rc = 0;
                        goto done;
                }
 
                /* If we have already reached the end of the search list,
                 * then terminate lookup.
                 */
                if ( dns->search.offset == dns->search.len ) {
                        DBGC ( dns, "DNS %p found no CNAME record\n", dns );
                        rc = -ENXIO_NO_RECORD;
                        dns_done ( dns, rc );
                        goto done;
                }
 
                /* Move to next entry in search list.  This can never fail,
                 * since we have already used this entry.
                 */
                DBGC ( dns, "DNS %p found no CNAME record; trying next "
                       "suffix\n", dns );
                dns->search.offset = dns_skip_search ( &dns->search );
                if ( ( rc = dns_question ( dns ) ) != 0 ) {
                        dns_done ( dns, rc );
                        goto done;
                }
                dns_send_packet ( dns );
                goto done;
 
        default:
                assert ( 0 );
                rc = -EINVAL;
                dns_done ( dns, rc );
                goto done;
        }
 
 done:
        /* Free I/O buffer */
        free_iob ( iobuf );
        return rc;
}

References __unused, dns_rr::a, dns_rr::aaaa, dns_request::address, AF_INET, AF_INET6, dns_request::buf, dns_rr::cname, dns_rr::common, dns_name::data, io_buffer::data, DBGC, dns_compare(), dns_copy(), dns_done(), DNS_MAX_CNAME_RECURSION, dns_resolved(), dns_skip(), DNS_TYPE_A, DNS_TYPE_CNAME, done, EINVAL, ELOOP, htons, dns_header::id, if(), dns_rr_aaaa::in6_addr, dns_rr_a::in_addr, iob_len(), dns_name::len, memcpy(), meta, dns_request::name, name, ntohs, dns_name::offset, dns_request::offset, offset, offsetof, dns_header::qdcount, dns_question::qtype, dns_request::query, dns_request::question, rc, dns_rr_common::rdlength, dns_request::recursion, dns_request::search, dns_request::sin, dns_request::sin6, sockaddr_in6::sin6_addr, sockaddr_in6::sin6_family, sockaddr_in::sin_addr, sockaddr_in::sin_family, strerror(), switch(), dns_rr_common::type, and typeof().

dns_xfer_close()

void dns_xfer_close ( struct dns_request * dns, int rc )

static

Receive new data.

Parameters

dns	DNS request
rc	Reason for close

Definition at line 925 of file dns.c.

                                                               {
 
        if ( ! rc )
                rc = -ECONNABORTED;
 
        dns_done ( dns, rc );
}

References dns_done(), ECONNABORTED, and rc.

dns_progress()

int dns_progress ( struct dns_request * dns, struct job_progress * progress )

static

Report job progress.

Parameters

dns	DNS request
progress	Progress report to fill in

Return values

ongoing_rc

Ongoing job status code (if known)

Definition at line 940 of file dns.c.

                                                          {
        int len;
 
        /* Show current question as progress message */
        len = dns_decode ( &dns->name, progress->message,
                           ( sizeof ( progress->message ) - 1 /* NUL */ ) );
        if ( len < 0 ) {
                /* Ignore undecodable names */
                progress->message[0] = '\0';
        }
 
        return 0;
}

References dns_decode(), len, job_progress::message, and dns_request::name.

dns_resolv()

int dns_resolv ( struct 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 983 of file dns.c.

                                                                {
        struct dns_request *dns;
        struct dns_header *query;
        size_t search_len;
        int name_len;
        int rc;
 
        /* Fail immediately if no DNS servers */
        if ( dns_count == 0 ) {
                DBG ( "DNS not attempting to resolve \"%s\": "
                      "no DNS servers\n", name );
                rc = -ENXIO_NO_NAMESERVER;
                goto err_no_nameserver;
        }
 
        /* Determine whether or not to use search list */
        search_len = ( strchr ( name, '.' ) ? 0 : dns_search.len );
 
        /* Allocate DNS structure */
        dns = zalloc ( sizeof ( *dns ) + search_len );
        if ( ! dns ) {
                rc = -ENOMEM;
                goto err_alloc_dns;
        }
        ref_init ( &dns->refcnt, NULL );
        intf_init ( &dns->resolv, &dns_resolv_desc, &dns->refcnt );
        intf_init ( &dns->socket, &dns_socket_desc, &dns->refcnt );
        timer_init ( &dns->timer, dns_timer_expired, &dns->refcnt );
        memcpy ( &dns->address.sa, sa, sizeof ( dns->address.sa ) );
        dns->search.data = ( ( ( void * ) dns ) + sizeof ( *dns ) );
        dns->search.len = search_len;
        memcpy ( dns->search.data, dns_search.data, search_len );
 
        /* Determine initial query type */
        dns->qtype = ( ( dns6.count != 0 ) ?
                       htons ( DNS_TYPE_AAAA ) : htons ( DNS_TYPE_A ) );
 
        /* Construct query */
        query = &dns->buf.query;
        query->flags = htons ( DNS_FLAG_RD );
        query->qdcount = htons ( 1 );
        dns->name.data = &dns->buf;
        dns->name.offset = offsetof ( typeof ( dns->buf ), name );
        dns->name.len = offsetof ( typeof ( dns->buf ), padding );
        name_len = dns_encode ( name, &dns->name );
        if ( name_len < 0 ) {
                rc = name_len;
                goto err_encode;
        }
        dns->offset = ( offsetof ( typeof ( dns->buf ), name ) +
                        name_len - 1 /* Strip root label */ );
        if ( ( rc = dns_question ( dns ) ) != 0 )
                goto err_question;
 
        /* Open UDP connection */
        if ( ( rc = xfer_open_socket ( &dns->socket, SOCK_DGRAM,
                                       &dns->nameserver.sa, NULL ) ) != 0 ) {
                DBGC ( dns, "DNS %p could not open socket: %s\n",
                       dns, strerror ( rc ) );
                goto err_open_socket;
        }
 
        /* Start timer to trigger first packet */
        start_timer_nodelay ( &dns->timer );
 
        /* Attach parent interface, mortalise self, and return */
        intf_plug_plug ( &dns->resolv, resolv );
        ref_put ( &dns->refcnt );
        return 0;       
 
 err_open_socket:
 err_question:
 err_encode:
        ref_put ( &dns->refcnt );
 err_alloc_dns:
 err_no_nameserver:
        return rc;
}

References dns_request::address, dns_request::buf, dns_name::data, DBG, DBGC, dns6, dns_count, dns_encode(), DNS_FLAG_RD, dns_resolv_desc, dns_search, dns_socket_desc, dns_timer_expired(), DNS_TYPE_A, DNS_TYPE_AAAA, ENOMEM, ENXIO_NO_NAMESERVER, dns_header::flags, htons, intf_init(), intf_plug_plug(), dns_name::len, memcpy(), dns_request::name, name, dns_request::nameserver, NULL, dns_request::offset, offsetof, dns_header::qdcount, dns_request::qtype, dns_request::query, rc, ref_init, ref_put, dns_request::refcnt, dns_request::resolv, resolv(), dns_request::sa, sa, dns_request::search, SOCK_DGRAM, dns_request::socket, start_timer_nodelay(), strchr(), strerror(), dns_request::timer, typeof(), xfer_open_socket(), and zalloc().

Referenced by __resolver().

__resolver()

struct resolver dns_resolver __resolver

(

RESOLV_NORMAL

)

DNS name resolver.

References __resolver, dns_resolv(), and RESOLV_NORMAL.

format_dnssl_setting()

int format_dnssl_setting ( const struct setting_type *type __unused, const void * raw, size_t raw_len, char * buf, size_t len )

static

Format DNS search list setting.

Parameters

type	Setting type
raw	Raw setting value
raw_len	Length of raw setting value
buf	Buffer to contain formatted value
len	Length of buffer

Return values

len	Length of formatted value, or negative error

Definition at line 1086 of file dns.c.

                                                          {
        struct dns_name name = {
                .data = ( ( void * ) raw ),
                .len = raw_len,
        };
        size_t remaining = len;
        size_t total = 0;
        int name_len;
 
        while ( name.offset < raw_len ) {
 
                /* Decode name */
                remaining = ( ( total < len ) ? ( len - total ) : 0 );
                name_len = dns_decode ( &name, ( buf + total ), remaining );
                if ( name_len < 0 )
                        return name_len;
                total += name_len;
 
                /* Move to next name */
                name.offset = dns_skip_search ( &name );
 
                /* Add separator if applicable */
                if ( name.offset != raw_len ) {
                        if ( total < len )
                                buf[total] = ' ';
                        total++;
                }
        }
 
        return total;
}

References __unused, dns_decode(), dns_skip_search(), len, name, raw, raw_len, and type.

__setting() [1/3]

const struct setting dns_setting __setting	(	SETTING_IP4_EXTRA	,
		dns	)

IPv4 DNS server setting.

References __setting, DHCP_DNS_SERVERS, dns_setting, and SETTING_IP4_EXTRA.

__setting() [2/3]

const struct setting dns6_setting __setting	(	SETTING_IP6_EXTRA	,
		dns6	)

IPv6 DNS server setting.

References __setting, DHCPV6_DNS_SERVERS, dhcpv6_scope, dns6, dns6_setting, and SETTING_IP6_EXTRA.

__setting() [3/3]

const struct setting dnssl_setting __setting	(	SETTING_IP_EXTRA	,
		dnssl	)

DNS search list.

References __setting, DHCP_DOMAIN_SEARCH, and SETTING_IP_EXTRA.

apply_dns_servers()

void apply_dns_servers ( void )

static

Apply DNS server addresses.

Definition at line 1155 of file dns.c.

                                       {
        int len;
 
        /* Free existing server addresses */
        free ( dns4.data );
        free ( dns6.data );
        dns4.data = NULL;
        dns6.data = NULL;
        dns4.count = 0;
        dns6.count = 0;
 
        /* Fetch DNS server addresses */
        len = fetch_raw_setting_copy ( NULL, &dns_setting, &dns4.data );
        if ( len >= 0 )
                dns4.count = ( len / sizeof ( dns4.in[0] ) );
        len = fetch_raw_setting_copy ( NULL, &dns6_setting, &dns6.data );
        if ( len >= 0 )
                dns6.count = ( len / sizeof ( dns6.in6[0] ) );
        dns_count = ( dns4.count + dns6.count );
}

References dns4, dns6, dns6_setting, dns_count, dns_setting, fetch_raw_setting_copy(), free, len, and NULL.

Referenced by apply_dns_settings().

apply_dns_search()

void apply_dns_search ( void )

static

Apply DNS search list.

Definition at line 1180 of file dns.c.

                                      {
        char *localdomain;
        int len;
 
        /* Free existing search list */
        free ( dns_search.data );
        memset ( &dns_search, 0, sizeof ( dns_search ) );
 
        /* Fetch DNS search list */
        len = fetch_raw_setting_copy ( NULL, &dnssl_setting, &dns_search.data );
        if ( len >= 0 ) {
                dns_search.len = len;
                return;
        }
 
        /* If no DNS search list exists, try to fetch the local domain */
        fetch_string_setting_copy ( NULL, &domain_setting, &localdomain );
        if ( localdomain ) {
                len = dns_encode ( localdomain, &dns_search );
                if ( len >= 0 ) {
                        dns_search.data = malloc ( len );
                        if ( dns_search.data ) {
                                dns_search.len = len;
                                dns_encode ( localdomain, &dns_search );
                        }
                }
                free ( localdomain );
                return;
        }
}

References dns_encode(), dns_search, fetch_raw_setting_copy(), fetch_string_setting_copy(), free, len, malloc(), memset(), and NULL.

Referenced by apply_dns_settings().

apply_dns_settings()

int apply_dns_settings ( void )

static

Apply DNS settings.

Return values

rc	Return status code

Definition at line 1216 of file dns.c.

                                       {
        void *dbgcol = &dns_count;
 
        /* Fetch DNS server address */
        apply_dns_servers();
        if ( DBG_EXTRA && ( dns_count != 0 ) ) {
                union {
                        struct sockaddr sa;
                        struct sockaddr_in sin;
                        struct sockaddr_in6 sin6;
                } u;
                unsigned int i;
 
                DBGC2 ( dbgcol, "DNS servers:" );
                for ( i = 0 ; i < dns6.count ; i++ ) {
                        u.sin6.sin6_family = AF_INET6;
                        memcpy ( &u.sin6.sin6_addr, &dns6.in6[i],
                                 sizeof ( u.sin6.sin6_addr ) );
                        DBGC2 ( dbgcol, " %s", sock_ntoa ( &u.sa ) );
                }
                for ( i = 0 ; i < dns4.count ; i++ ) {
                        u.sin.sin_family = AF_INET;
                        u.sin.sin_addr = dns4.in[i];
                        DBGC2 ( dbgcol, " %s", sock_ntoa ( &u.sa ) );
                }
                DBGC2 ( dbgcol, "\n" );
        }
 
        /* Fetch DNS search list */
        apply_dns_search();
        if ( DBG_EXTRA && ( dns_search.len != 0 ) ) {
                struct dns_name name;
                int offset;
 
                DBGC2 ( dbgcol, "DNS search list:" );
                memcpy ( &name, &dns_search, sizeof ( name ) );
                while ( name.offset != name.len ) {
                        DBGC2 ( dbgcol, " %s", dns_name ( &name ) );
                        offset = dns_skip_search ( &name );
                        if ( offset < 0 )
                                break;
                        name.offset = offset;
                }
                DBGC2 ( dbgcol, "\n" );
        }
 
        return 0;
}

References AF_INET, AF_INET6, apply_dns_search(), apply_dns_servers(), DBG_EXTRA, DBGC2, dns4, dns6, dns_count, dns_search, dns_skip_search(), memcpy(), name, offset, sa, sin, sin6, sock_ntoa(), and u.

Variable Documentation

dns4

struct dns_server dns4

static

IPv4 DNS server list.

Definition at line 83 of file dns.c.

Referenced by apply_dns_servers(), apply_dns_settings(), and dns_send_packet().

dns6

struct dns_server dns6

static

IPv6 DNS server list.

Definition at line 86 of file dns.c.

Referenced by __setting(), apply_dns_servers(), apply_dns_settings(), dns_resolv(), and dns_send_packet().

dns_count

unsigned int dns_count

static

Total number of DNS servers.

Definition at line 89 of file dns.c.

Referenced by apply_dns_servers(), apply_dns_settings(), dns_resolv(), and dns_send_packet().

dns_search

struct dns_name dns_search

static

The DNS search list.

Definition at line 92 of file dns.c.

Referenced by apply_dns_search(), apply_dns_settings(), and dns_resolv().

dns_socket_operations

struct interface_operation dns_socket_operations[]

static

Initial value:

                                 = {
        INTF_OP ( xfer_deliver, struct dns_request *, dns_xfer_deliver ),
        INTF_OP ( intf_close, struct dns_request *, dns_xfer_close ),
}

DNS socket interface operations.

Definition at line 956 of file dns.c.

                                                          {
        INTF_OP ( xfer_deliver, struct dns_request *, dns_xfer_deliver ),
        INTF_OP ( intf_close, struct dns_request *, dns_xfer_close ),
};

dns_socket_desc

struct interface_descriptor dns_socket_desc

static

Initial value:

                         =
INTF_DESC ( struct dns_request, socket, dns_socket_operations )

DNS socket interface descriptor.

Definition at line 962 of file dns.c.

Referenced by dns_resolv().

dns_resolv_op

struct interface_operation dns_resolv_op[]

static

Initial value:

                                 = {
        INTF_OP ( job_progress, struct dns_request *, dns_progress ),
        INTF_OP ( intf_close, struct dns_request *, dns_done ),
}

DNS resolver interface operations.

Definition at line 966 of file dns.c.

                                                  {
        INTF_OP ( job_progress, struct dns_request *, dns_progress ),
        INTF_OP ( intf_close, struct dns_request *, dns_done ),
};

dns_resolv_desc

struct interface_descriptor dns_resolv_desc

static

Initial value:

                         =
INTF_DESC ( struct dns_request, resolv, dns_resolv_op )

DNS resolver interface descriptor.

Definition at line 972 of file dns.c.

Referenced by dns_resolv().

__setting_type

const struct setting_type setting_type_dnssl __setting_type

Initial value:

                        = {
        .name = "dnssl",
        .format = format_dnssl_setting,
}

A DNS search list setting type.

A string setting type.

Definition at line 1121 of file dns.c.

                                                            {
        .name = "dnssl",
        .format = format_dnssl_setting,
};

__settings_applicator

struct settings_applicator dns_applicator __settings_applicator

Initial value:

                         = {
        .apply = apply_dns_settings,
}

DNS settings applicator.

Definition at line 1266 of file dns.c.

                                                                {
        .apply = apply_dns_settings,
};