Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	lib/libc/asr/res_send_async.c	Lines:	0	334	0.0 %
Date:	2017-11-07	Branches:	0	177	0.0 %


/*	$OpenBSD: res_send_async.c,v 1.36 2017/03/15 15:54:41 deraadt Exp $	*/
/*
 * Copyright (c) 2012 Eric Faurot <eric@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/uio.h>
#include <netinet/in.h>
#include <arpa/nameser.h>
#include <netdb.h>

#include <asr.h>
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <resolv.h> /* for res_random */
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "asr_private.h"

#define OP_QUERY    (0)

static int res_send_async_run(struct asr_query *, struct asr_result *);
static int sockaddr_connect(const struct sockaddr *, int);
static int udp_send(struct asr_query *);
static int udp_recv(struct asr_query *);
static int tcp_write(struct asr_query *);
static int tcp_read(struct asr_query *);
static int validate_packet(struct asr_query *);
static int setup_query(struct asr_query *, const char *, const char *, int, int);
static int ensure_ibuf(struct asr_query *, size_t);
static int iter_ns(struct asr_query *);

#define AS_NS_SA(p) ((p)->as_ctx->ac_ns[(p)->as.dns.nsidx - 1])


struct asr_query *
res_send_async(const unsigned char *buf, int buflen, void *asr)
{
	struct asr_ctx		*ac;
	struct asr_query	*as;
	struct asr_unpack	 p;
	struct asr_dns_header	 h;
	struct asr_dns_query	 q;

	DPRINT_PACKET("asr: res_send_async()", buf, buflen);

	ac = _asr_use_resolver(asr);
	if ((as = _asr_async_new(ac, ASR_SEND)) == NULL) {
		_asr_ctx_unref(ac);
		return (NULL); /* errno set */
	}
	as->as_run = res_send_async_run;

	as->as_flags |= ASYNC_EXTOBUF;
	as->as.dns.obuf = (unsigned char *)buf;
	as->as.dns.obuflen = buflen;
	as->as.dns.obufsize = buflen;

	_asr_unpack_init(&p, buf, buflen);
	_asr_unpack_header(&p, &h);
	_asr_unpack_query(&p, &q);
	if (p.err) {
		errno = EINVAL;
		goto err;
	}
	as->as.dns.reqid = h.id;
	as->as.dns.type = q.q_type;
	as->as.dns.class = q.q_class;
	as->as.dns.dname = strdup(q.q_dname);
	if (as->as.dns.dname == NULL)
		goto err; /* errno set */

	_asr_ctx_unref(ac);
	return (as);
    err:
	if (as)
		_asr_async_free(as);
	_asr_ctx_unref(ac);
	return (NULL);
}
DEF_WEAK(res_send_async);

/*
 * Unlike res_query(), this version will actually return the packet
 * if it has received a valid one (errno == 0) even if h_errno is
 * not NETDB_SUCCESS. So the packet *must* be freed if necessary.
 */
struct asr_query *
res_query_async(const char *name, int class, int type, void *asr)
{
	struct asr_ctx	 *ac;
	struct asr_query *as;

	DPRINT("asr: res_query_async(\"%s\", %i, %i)\n", name, class, type);

	ac = _asr_use_resolver(asr);
	as = _res_query_async_ctx(name, class, type, ac);
	_asr_ctx_unref(ac);

	return (as);
}
DEF_WEAK(res_query_async);

struct asr_query *
_res_query_async_ctx(const char *name, int class, int type, struct asr_ctx *a_ctx)
{
	struct asr_query	*as;

	DPRINT("asr: res_query_async_ctx(\"%s\", %i, %i)\n", name, class, type);

	if ((as = _asr_async_new(a_ctx, ASR_SEND)) == NULL)
		return (NULL); /* errno set */
	as->as_run = res_send_async_run;

	/* This adds a "." to name if it doesn't already has one.
	 * That's how res_query() behaves (through res_mkquery").
	 */
	if (setup_query(as, name, NULL, class, type) == -1)
		goto err; /* errno set */

	return (as);

    err:
	if (as)
		_asr_async_free(as);

	return (NULL);
}

static int
res_send_async_run(struct asr_query *as, struct asr_result *ar)
{
    next:
	switch (as->as_state) {

	case ASR_STATE_INIT:

		if (as->as_ctx->ac_nscount == 0) {
			ar->ar_errno = ECONNREFUSED;
			async_set_state(as, ASR_STATE_HALT);
			break;
		}

		async_set_state(as, ASR_STATE_NEXT_NS);
		break;

	case ASR_STATE_NEXT_NS:

		if (iter_ns(as) == -1) {
			ar->ar_errno = ETIMEDOUT;
			async_set_state(as, ASR_STATE_HALT);
			break;
		}

		if (as->as_ctx->ac_options & RES_USEVC ||
		    as->as.dns.obuflen > PACKETSZ)
			async_set_state(as, ASR_STATE_TCP_WRITE);
		else
			async_set_state(as, ASR_STATE_UDP_SEND);
		break;

	case ASR_STATE_UDP_SEND:

		if (udp_send(as) == -1) {
			async_set_state(as, ASR_STATE_NEXT_NS);
			break;
		}
		async_set_state(as, ASR_STATE_UDP_RECV);
		ar->ar_cond = ASR_WANT_READ;
		ar->ar_fd = as->as_fd;
		ar->ar_timeout = as->as_timeout;
		return (ASYNC_COND);
		break;

	case ASR_STATE_UDP_RECV:

		if (udp_recv(as) == -1) {
			if (errno == ENOMEM) {
				ar->ar_errno = errno;
				async_set_state(as, ASR_STATE_HALT);
				break;
			}
			if (errno != EOVERFLOW) {
				/* Fail or timeout */
				async_set_state(as, ASR_STATE_NEXT_NS);
				break;
			}
			if (as->as_ctx->ac_options & RES_IGNTC)
				async_set_state(as, ASR_STATE_PACKET);
			else
				async_set_state(as, ASR_STATE_TCP_WRITE);
		} else
			async_set_state(as, ASR_STATE_PACKET);
		break;

	case ASR_STATE_TCP_WRITE:

		switch (tcp_write(as)) {
		case -1: /* fail or timeout */
			async_set_state(as, ASR_STATE_NEXT_NS);
			break;
		case 0:
			async_set_state(as, ASR_STATE_TCP_READ);
			ar->ar_cond = ASR_WANT_READ;
			ar->ar_fd = as->as_fd;
			ar->ar_timeout = as->as_timeout;
			return (ASYNC_COND);
		case 1:
			ar->ar_cond = ASR_WANT_WRITE;
			ar->ar_fd = as->as_fd;
			ar->ar_timeout = as->as_timeout;
			return (ASYNC_COND);
		}
		break;

	case ASR_STATE_TCP_READ:

		switch (tcp_read(as)) {
		case -1: /* Fail or timeout */
			if (errno == ENOMEM) {
				ar->ar_errno = errno;
				async_set_state(as, ASR_STATE_HALT);
			} else
				async_set_state(as, ASR_STATE_NEXT_NS);
			break;
		case 0:
			async_set_state(as, ASR_STATE_PACKET);
			break;
		case 1:
			ar->ar_cond = ASR_WANT_READ;
			ar->ar_fd = as->as_fd;
			ar->ar_timeout = as->as_timeout;
			return (ASYNC_COND);
		}
		break;

	case ASR_STATE_PACKET:

		memmove(&ar->ar_ns, AS_NS_SA(as), AS_NS_SA(as)->sa_len);
		ar->ar_datalen = as->as.dns.ibuflen;
		ar->ar_data = as->as.dns.ibuf;
		as->as.dns.ibuf = NULL;
		ar->ar_errno = 0;
		ar->ar_rcode = as->as.dns.rcode;
		async_set_state(as, ASR_STATE_HALT);
		break;

	case ASR_STATE_HALT:

		if (ar->ar_errno) {
			ar->ar_h_errno = TRY_AGAIN;
			ar->ar_count = 0;
			ar->ar_datalen = -1;
			ar->ar_data = NULL;
		} else if (as->as.dns.ancount) {
			ar->ar_h_errno = NETDB_SUCCESS;
			ar->ar_count = as->as.dns.ancount;
		} else {
			ar->ar_count = 0;
			switch (as->as.dns.rcode) {
			case NXDOMAIN:
				ar->ar_h_errno = HOST_NOT_FOUND;
				break;
			case SERVFAIL:
				ar->ar_h_errno = TRY_AGAIN;
				break;
			case NOERROR:
				ar->ar_h_errno = NO_DATA;
				break;
			default:
				ar->ar_h_errno = NO_RECOVERY;
			}
		}
		return (ASYNC_DONE);

	default:

		ar->ar_errno = EOPNOTSUPP;
		ar->ar_h_errno = NETDB_INTERNAL;
		async_set_state(as, ASR_STATE_HALT);
		break;
	}
	goto next;
}

static int
sockaddr_connect(const struct sockaddr *sa, int socktype)
{
	int errno_save, sock;

	if ((sock = socket(sa->sa_family,
	    socktype | SOCK_NONBLOCK | SOCK_DNS, 0)) == -1)
		goto fail;

	if (connect(sock, sa, sa->sa_len) == -1) {
		/*
		 * In the TCP case, the caller will be asked to poll for
		 * POLLOUT so that we start writing the packet in tcp_write()
		 * when the connection is established, or fail there on error.
		 */
		if (errno == EINPROGRESS)
			return (sock);
		goto fail;
	}

	return (sock);

    fail:

	if (sock != -1) {
		errno_save = errno;
		close(sock);
		errno = errno_save;
	}

	return (-1);
}

/*
 * Prepare the DNS packet for the query type "type", class "class" and domain
 * name created by the concatenation on "name" and "dom".
 * Return 0 on success, set errno and return -1 on error.
 */
static int
setup_query(struct asr_query *as, const char *name, const char *dom,
	int class, int type)
{
	struct asr_pack		p;
	struct asr_dns_header	h;
	char			fqdn[MAXDNAME];
	char			dname[MAXDNAME];

	if (as->as_flags & ASYNC_EXTOBUF) {
		errno = EINVAL;
		DPRINT("attempting to write in user packet");
		return (-1);
	}

	if (_asr_make_fqdn(name, dom, fqdn, sizeof(fqdn)) > sizeof(fqdn)) {
		errno = EINVAL;
		DPRINT("asr_make_fqdn: name too long\n");
		return (-1);
	}

	if (_asr_dname_from_fqdn(fqdn, dname, sizeof(dname)) == -1) {
		errno = EINVAL;
		DPRINT("asr_dname_from_fqdn: invalid\n");
		return (-1);
	}

	if (as->as.dns.obuf == NULL) {
		as->as.dns.obufsize = PACKETSZ;
		as->as.dns.obuf = malloc(as->as.dns.obufsize);
		if (as->as.dns.obuf == NULL)
			return (-1); /* errno set */
	}
	as->as.dns.obuflen = 0;

	memset(&h, 0, sizeof h);
	h.id = res_randomid();
	if (as->as_ctx->ac_options & RES_RECURSE)
		h.flags |= RD_MASK;
	h.qdcount = 1;
	if (as->as_ctx->ac_options & (RES_USE_EDNS0 | RES_USE_DNSSEC))
		h.arcount = 1;

	_asr_pack_init(&p, as->as.dns.obuf, as->as.dns.obufsize);
	_asr_pack_header(&p, &h);
	_asr_pack_query(&p, type, class, dname);
	if (as->as_ctx->ac_options & (RES_USE_EDNS0 | RES_USE_DNSSEC))
		_asr_pack_edns0(&p, MAXPACKETSZ,
		    as->as_ctx->ac_options & RES_USE_DNSSEC);
	if (p.err) {
		DPRINT("error packing query");
		errno = EINVAL;
		return (-1);
	}

	/* Remember the parameters. */
	as->as.dns.reqid = h.id;
	as->as.dns.type = type;
	as->as.dns.class = class;
	if (as->as.dns.dname)
		free(as->as.dns.dname);
	as->as.dns.dname = strdup(dname);
	if (as->as.dns.dname == NULL) {
		DPRINT("strdup");
		return (-1); /* errno set */
	}
	as->as.dns.obuflen = p.offset;

	DPRINT_PACKET("asr_setup_query", as->as.dns.obuf, as->as.dns.obuflen);

	return (0);
}

/*
 * Create a connect UDP socket and send the output packet.
 *
 * Return 0 on success, or -1 on error (errno set).
 */
static int
udp_send(struct asr_query *as)
{
	ssize_t	n;
	int	save_errno;
#ifdef DEBUG
	char		buf[256];
#endif

	DPRINT("asr: [%p] connecting to %s UDP\n", as,
	    _asr_print_sockaddr(AS_NS_SA(as), buf, sizeof buf));

	as->as_fd = sockaddr_connect(AS_NS_SA(as), SOCK_DGRAM);
	if (as->as_fd == -1)
		return (-1); /* errno set */

	n = send(as->as_fd, as->as.dns.obuf, as->as.dns.obuflen, 0);
	if (n == -1) {
		save_errno = errno;
		close(as->as_fd);
		errno = save_errno;
		as->as_fd = -1;
		return (-1);
	}

	return (0);
}

/*
 * Try to receive a valid packet from the current UDP socket.
 *
 * Return 0 if a full packet could be read, or -1 on error (errno set).
 */
static int
udp_recv(struct asr_query *as)
{
	ssize_t		 n;
	int		 save_errno;

	if (ensure_ibuf(as, MAXPACKETSZ) == -1) {
		save_errno = errno;
		close(as->as_fd);
		errno = save_errno;
		as->as_fd = -1;
		return (-1);
	}

	n = recv(as->as_fd, as->as.dns.ibuf, as->as.dns.ibufsize, 0);
	save_errno = errno;
	close(as->as_fd);
	errno = save_errno;
	as->as_fd = -1;
	if (n == -1)
		return (-1);

	as->as.dns.ibuflen = n;

	DPRINT_PACKET("asr_udp_recv()", as->as.dns.ibuf, as->as.dns.ibuflen);

	if (validate_packet(as) == -1)
		return (-1); /* errno set */

	return (0);
}

/*
 * Write the output packet to the TCP socket.
 *
 * Return 0 when all bytes have been sent, 1 there is no buffer space on the
 * socket or it is not connected yet, or -1 on error (errno set).
 */
static int
tcp_write(struct asr_query *as)
{
	struct msghdr	msg;
	struct iovec	iov[2];
	uint16_t	len;
	ssize_t		n;
	size_t		offset;
	int		i;
#ifdef DEBUG
	char		buf[256];
#endif

	/* First try to connect if not already */
	if (as->as_fd == -1) {
		DPRINT("asr: [%p] connecting to %s TCP\n", as,
		    _asr_print_sockaddr(AS_NS_SA(as), buf, sizeof buf));
		as->as_fd = sockaddr_connect(AS_NS_SA(as), SOCK_STREAM);
		if (as->as_fd == -1)
			return (-1); /* errno set */
		as->as.dns.datalen = 0; /* bytes sent */
		return (1);
	}

	i = 0;

	/* Prepend de packet length if not sent already. */
	if (as->as.dns.datalen < sizeof(len)) {
		offset = 0;
		len = htons(as->as.dns.obuflen);
		iov[i].iov_base = (char *)(&len) + as->as.dns.datalen;
		iov[i].iov_len = sizeof(len) - as->as.dns.datalen;
		i++;
	} else
		offset = as->as.dns.datalen - sizeof(len);

	iov[i].iov_base = as->as.dns.obuf + offset;
	iov[i].iov_len = as->as.dns.obuflen - offset;
	i++;

	memset(&msg, 0, sizeof msg);
	msg.msg_iov = iov;
	msg.msg_iovlen = i;

    send_again:
	n = sendmsg(as->as_fd, &msg, MSG_NOSIGNAL);
	if (n == -1) {
		if (errno == EINTR)
			goto send_again;
		goto close; /* errno set */
	}

	as->as.dns.datalen += n;

	if (as->as.dns.datalen == as->as.dns.obuflen + sizeof(len)) {
		/* All sent. Prepare for TCP read */
		as->as.dns.datalen = 0;
		return (0);
	}

	/* More data to write */
	return (1);

close:
	close(as->as_fd);
	as->as_fd = -1;
	return (-1);
}

/*
 * Try to read a valid packet from the current TCP socket.
 *
 * Return 0 if a full packet could be read, 1 if more data is needed and the
 * socket must be read again, or -1 on error (errno set).
 */
static int
tcp_read(struct asr_query *as)
{
	ssize_t		 n;
	size_t		 offset, len;
	char		*pos;
	int		 save_errno, nfds;
	struct pollfd	 pfd;

	/* We must read the packet len first */
	if (as->as.dns.datalen < sizeof(as->as.dns.pktlen)) {

		pos = (char *)(&as->as.dns.pktlen) + as->as.dns.datalen;
		len = sizeof(as->as.dns.pktlen) - as->as.dns.datalen;

		n = read(as->as_fd, pos, len);
		if (n == -1)
			goto close; /* errno set */

		as->as.dns.datalen += n;
		if (as->as.dns.datalen < sizeof(as->as.dns.pktlen))
			return (1); /* need more data */

		as->as.dns.ibuflen = ntohs(as->as.dns.pktlen);
		if (ensure_ibuf(as, as->as.dns.ibuflen) == -1)
			goto close; /* errno set */

		pfd.fd = as->as_fd;
		pfd.events = POLLIN;
	    poll_again:
		nfds = poll(&pfd, 1, 0);
		if (nfds == -1) {
			if (errno == EINTR)
				goto poll_again;
			goto close; /* errno set */
		}
		if (nfds == 0)
			return (1); /* no more data available */
	}

	offset = as->as.dns.datalen - sizeof(as->as.dns.pktlen);
	pos = as->as.dns.ibuf + offset;
	len =  as->as.dns.ibuflen - offset;

    read_again:
	n = read(as->as_fd, pos, len);
	if (n == -1) {
		if (errno == EINTR)
			goto read_again;
		goto close; /* errno set */
	}
	if (n == 0) {
		errno = ECONNRESET;
		goto close;
	}
	as->as.dns.datalen += n;

	/* See if we got all the advertised bytes. */
	if (as->as.dns.datalen != as->as.dns.ibuflen + sizeof(as->as.dns.pktlen))
		return (1);

	DPRINT_PACKET("asr_tcp_read()", as->as.dns.ibuf, as->as.dns.ibuflen);

	if (validate_packet(as) == -1)
		goto close; /* errno set */

	errno = 0;
close:
	save_errno = errno;
	close(as->as_fd);
	errno = save_errno;
	as->as_fd = -1;
	return (errno ? -1 : 0);
}

/*
 * Make sure the input buffer is at least "n" bytes long, and allocate or
 * extend it if necessary. Return 0 on success, or set errno and return -1.
 */
static int
ensure_ibuf(struct asr_query *as, size_t n)
{
	char	*t;

	if (as->as.dns.ibufsize >= n)
		return (0);

	t = recallocarray(as->as.dns.ibuf, as->as.dns.ibufsize, n, 1);
	if (t == NULL)
		return (-1); /* errno set */
	as->as.dns.ibuf = t;
	as->as.dns.ibufsize = n;

	return (0);
}

/*
 * Check if the received packet is valid.
 * Return 0 on success, or set errno and return -1.
 */
static int
validate_packet(struct asr_query *as)
{
	struct asr_unpack	 p;
	struct asr_dns_header	 h;
	struct asr_dns_query	 q;
	struct asr_dns_rr	 rr;
	int			 r;

	_asr_unpack_init(&p, as->as.dns.ibuf, as->as.dns.ibuflen);

	_asr_unpack_header(&p, &h);
	if (p.err)
		goto inval;

	if (h.id != as->as.dns.reqid) {
		DPRINT("incorrect reqid\n");
		goto inval;
	}
	if (h.qdcount != 1)
		goto inval;
	/* Should be zero, we could allow this */
	if ((h.flags & Z_MASK) != 0)
		goto inval;
	/* Actually, it depends on the request but we only use OP_QUERY */
	if (OPCODE(h.flags) != OP_QUERY)
		goto inval;
	/* Must be a response */
	if ((h.flags & QR_MASK) == 0)
		goto inval;

	as->as.dns.rcode = RCODE(h.flags);
	as->as.dns.ancount = h.ancount;

	_asr_unpack_query(&p, &q);
	if (p.err)
		goto inval;

	if (q.q_type != as->as.dns.type ||
	    q.q_class != as->as.dns.class ||
	    strcasecmp(q.q_dname, as->as.dns.dname)) {
		DPRINT("incorrect type/class/dname '%s' != '%s'\n",
		    q.q_dname, as->as.dns.dname);
		goto inval;
	}

	/* Check for truncation */
	if (h.flags & TC_MASK && !(as->as_ctx->ac_options & RES_IGNTC)) {
		DPRINT("truncated\n");
		errno = EOVERFLOW;
		return (-1);
	}

	/* Validate the rest of the packet */
	for (r = h.ancount + h.nscount + h.arcount; r; r--)
		_asr_unpack_rr(&p, &rr);

	/* Report any error found when unpacking the RRs. */
	if (p.err) {
		DPRINT("unpack: %s\n", strerror(p.err));
		errno = p.err;
		return (-1);
	}

	if (p.offset != as->as.dns.ibuflen) {
		DPRINT("trailing garbage\n");
		errno = EMSGSIZE;
		return (-1);
	}

	return (0);

    inval:
	errno = EINVAL;
	return (-1);
}

/*
 * Set the async context nameserver index to the next nameserver, cycling
 * over the list until the maximum retry counter is reached.  Return 0 on
 * success, or -1 if all nameservers were used.
 */
static int
iter_ns(struct asr_query *as)
{
	for (;;) {
		if (as->as.dns.nsloop >= as->as_ctx->ac_nsretries)
			return (-1);

		as->as.dns.nsidx += 1;
		if (as->as.dns.nsidx <= as->as_ctx->ac_nscount)
			break;
		as->as.dns.nsidx = 0;
		as->as.dns.nsloop++;
		DPRINT("asr: iter_ns(): cycle %i\n", as->as.dns.nsloop);
	}

	as->as_timeout = 1000 * (as->as_ctx->ac_nstimeout << as->as.dns.nsloop);
	if (as->as.dns.nsloop > 0)
		as->as_timeout /= as->as_ctx->ac_nscount;
	if (as->as_timeout < 1000)
		as->as_timeout = 1000;

	return (0);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: res_send_async.c,v 1.36 2017/03/15 15:54:41 deraadt Exp $ */
2			/*
3			* Copyright (c) 2012 Eric Faurot <eric@openbsd.org>
4			*
5			* Permission to use, copy, modify, and distribute this software for any
6			* purpose with or without fee is hereby granted, provided that the above
7			* copyright notice and this permission notice appear in all copies.
8			*
9			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16			*/
17
18			#include <sys/types.h>
19			#include <sys/socket.h>
20			#include <sys/uio.h>
21			#include <netinet/in.h>
22			#include <arpa/nameser.h>
23			#include <netdb.h>
24
25			#include <asr.h>
26			#include <errno.h>
27			#include <fcntl.h>
28			#include <poll.h>
29			#include <resolv.h> /* for res_random */
30			#include <stdlib.h>
31			#include <string.h>
32			#include <unistd.h>
33
34			#include "asr_private.h"
35
36			#define OP_QUERY (0)
37
38			static int res_send_async_run(struct asr_query , struct asr_result );
39			static int sockaddr_connect(const struct sockaddr *, int);
40			static int udp_send(struct asr_query *);
41			static int udp_recv(struct asr_query *);
42			static int tcp_write(struct asr_query *);
43			static int tcp_read(struct asr_query *);
44			static int validate_packet(struct asr_query *);
45			static int setup_query(struct asr_query , const char , const char *, int, int);
46			static int ensure_ibuf(struct asr_query *, size_t);
47			static int iter_ns(struct asr_query *);
48
49			#define AS_NS_SA(p) ((p)->as_ctx->ac_ns[(p)->as.dns.nsidx - 1])
50
51
52			struct asr_query *
53			res_send_async(const unsigned char buf, int buflen, void asr)
54			{
55			struct asr_ctx *ac;
56			struct asr_query *as;
57			struct asr_unpack p;
58			struct asr_dns_header h;
59			struct asr_dns_query q;
60
61			DPRINT_PACKET("asr: res_send_async()", buf, buflen);
62
63			ac = _asr_use_resolver(asr);
64			if ((as = _asr_async_new(ac, ASR_SEND)) == NULL) {
65			_asr_ctx_unref(ac);
66			return (NULL); /* errno set */
67			}
68			as->as_run = res_send_async_run;
69
70			as->as_flags \|= ASYNC_EXTOBUF;
71			as->as.dns.obuf = (unsigned char *)buf;
72			as->as.dns.obuflen = buflen;
73			as->as.dns.obufsize = buflen;
74
75			_asr_unpack_init(&p, buf, buflen);
76			_asr_unpack_header(&p, &h);
77			_asr_unpack_query(&p, &q);
78			if (p.err) {
79			errno = EINVAL;
80			goto err;
81			}
82			as->as.dns.reqid = h.id;
83			as->as.dns.type = q.q_type;
84			as->as.dns.class = q.q_class;
85			as->as.dns.dname = strdup(q.q_dname);
86			if (as->as.dns.dname == NULL)
87			goto err; /* errno set */
88
89			_asr_ctx_unref(ac);
90			return (as);
91			err:
92			if (as)
93			_asr_async_free(as);
94			_asr_ctx_unref(ac);
95			return (NULL);
96			}
97			DEF_WEAK(res_send_async);
98
99			/*
100			* Unlike res_query(), this version will actually return the packet
101			* if it has received a valid one (errno == 0) even if h_errno is
102			* not NETDB_SUCCESS. So the packet must be freed if necessary.
103			*/
104			struct asr_query *
105			res_query_async(const char name, int class, int type, void asr)
106			{
107			struct asr_ctx *ac;
108			struct asr_query *as;
109
110			DPRINT("asr: res_query_async(\"%s\", %i, %i)\n", name, class, type);
111
112			ac = _asr_use_resolver(asr);
113			as = _res_query_async_ctx(name, class, type, ac);
114			_asr_ctx_unref(ac);
115
116			return (as);
117			}
118			DEF_WEAK(res_query_async);
119
120			struct asr_query *
121			_res_query_async_ctx(const char name, int class, int type, struct asr_ctx a_ctx)
122			{
123			struct asr_query *as;
124
125			DPRINT("asr: res_query_async_ctx(\"%s\", %i, %i)\n", name, class, type);
126
127			if ((as = _asr_async_new(a_ctx, ASR_SEND)) == NULL)
128			return (NULL); /* errno set */
129			as->as_run = res_send_async_run;
130
131			/* This adds a "." to name if it doesn't already has one.
132			* That's how res_query() behaves (through res_mkquery").
133			*/
134			if (setup_query(as, name, NULL, class, type) == -1)
135			goto err; /* errno set */
136
137			return (as);
138
139			err:
140			if (as)
141			_asr_async_free(as);
142
143			return (NULL);
144			}
145
146			static int
147			res_send_async_run(struct asr_query as, struct asr_result ar)
148			{
149			next:
150			switch (as->as_state) {
151
152			case ASR_STATE_INIT:
153
154			if (as->as_ctx->ac_nscount == 0) {
155			ar->ar_errno = ECONNREFUSED;
156			async_set_state(as, ASR_STATE_HALT);
157			break;
158			}
159
160			async_set_state(as, ASR_STATE_NEXT_NS);
161			break;
162
163			case ASR_STATE_NEXT_NS:
164
165			if (iter_ns(as) == -1) {
166			ar->ar_errno = ETIMEDOUT;
167			async_set_state(as, ASR_STATE_HALT);
168			break;
169			}
170
171			if (as->as_ctx->ac_options & RES_USEVC \|\|
172			as->as.dns.obuflen > PACKETSZ)
173			async_set_state(as, ASR_STATE_TCP_WRITE);
174			else
175			async_set_state(as, ASR_STATE_UDP_SEND);
176			break;
177
178			case ASR_STATE_UDP_SEND:
179
180			if (udp_send(as) == -1) {
181			async_set_state(as, ASR_STATE_NEXT_NS);
182			break;
183			}
184			async_set_state(as, ASR_STATE_UDP_RECV);
185			ar->ar_cond = ASR_WANT_READ;
186			ar->ar_fd = as->as_fd;
187			ar->ar_timeout = as->as_timeout;
188			return (ASYNC_COND);
189			break;
190
191			case ASR_STATE_UDP_RECV:
192
193			if (udp_recv(as) == -1) {
194			if (errno == ENOMEM) {
195			ar->ar_errno = errno;
196			async_set_state(as, ASR_STATE_HALT);
197			break;
198			}
199			if (errno != EOVERFLOW) {
200			/* Fail or timeout */
201			async_set_state(as, ASR_STATE_NEXT_NS);
202			break;
203			}
204			if (as->as_ctx->ac_options & RES_IGNTC)
205			async_set_state(as, ASR_STATE_PACKET);
206			else
207			async_set_state(as, ASR_STATE_TCP_WRITE);
208			} else
209			async_set_state(as, ASR_STATE_PACKET);
210			break;
211
212			case ASR_STATE_TCP_WRITE:
213
214			switch (tcp_write(as)) {
215			case -1: /* fail or timeout */
216			async_set_state(as, ASR_STATE_NEXT_NS);
217			break;
218			case 0:
219			async_set_state(as, ASR_STATE_TCP_READ);
220			ar->ar_cond = ASR_WANT_READ;
221			ar->ar_fd = as->as_fd;
222			ar->ar_timeout = as->as_timeout;
223			return (ASYNC_COND);
224			case 1:
225			ar->ar_cond = ASR_WANT_WRITE;
226			ar->ar_fd = as->as_fd;
227			ar->ar_timeout = as->as_timeout;
228			return (ASYNC_COND);
229			}
230			break;
231
232			case ASR_STATE_TCP_READ:
233
234			switch (tcp_read(as)) {
235			case -1: /* Fail or timeout */
236			if (errno == ENOMEM) {
237			ar->ar_errno = errno;
238			async_set_state(as, ASR_STATE_HALT);
239			} else
240			async_set_state(as, ASR_STATE_NEXT_NS);
241			break;
242			case 0:
243			async_set_state(as, ASR_STATE_PACKET);
244			break;
245			case 1:
246			ar->ar_cond = ASR_WANT_READ;
247			ar->ar_fd = as->as_fd;
248			ar->ar_timeout = as->as_timeout;
249			return (ASYNC_COND);
250			}
251			break;
252
253			case ASR_STATE_PACKET:
254
255			memmove(&ar->ar_ns, AS_NS_SA(as), AS_NS_SA(as)->sa_len);
256			ar->ar_datalen = as->as.dns.ibuflen;
257			ar->ar_data = as->as.dns.ibuf;
258			as->as.dns.ibuf = NULL;
259			ar->ar_errno = 0;
260			ar->ar_rcode = as->as.dns.rcode;
261			async_set_state(as, ASR_STATE_HALT);
262			break;
263
264			case ASR_STATE_HALT:
265
266			if (ar->ar_errno) {
267			ar->ar_h_errno = TRY_AGAIN;
268			ar->ar_count = 0;
269			ar->ar_datalen = -1;
270			ar->ar_data = NULL;
271			} else if (as->as.dns.ancount) {
272			ar->ar_h_errno = NETDB_SUCCESS;
273			ar->ar_count = as->as.dns.ancount;
274			} else {
275			ar->ar_count = 0;
276			switch (as->as.dns.rcode) {
277			case NXDOMAIN:
278			ar->ar_h_errno = HOST_NOT_FOUND;
279			break;
280			case SERVFAIL:
281			ar->ar_h_errno = TRY_AGAIN;
282			break;
283			case NOERROR:
284			ar->ar_h_errno = NO_DATA;
285			break;
286			default:
287			ar->ar_h_errno = NO_RECOVERY;
288			}
289			}
290			return (ASYNC_DONE);
291
292			default:
293
294			ar->ar_errno = EOPNOTSUPP;
295			ar->ar_h_errno = NETDB_INTERNAL;
296			async_set_state(as, ASR_STATE_HALT);
297			break;
298			}
299			goto next;
300			}
301
302			static int
303			sockaddr_connect(const struct sockaddr *sa, int socktype)
304			{
305			int errno_save, sock;
306
307			if ((sock = socket(sa->sa_family,
308			socktype \| SOCK_NONBLOCK \| SOCK_DNS, 0)) == -1)
309			goto fail;
310
311			if (connect(sock, sa, sa->sa_len) == -1) {
312			/*
313			* In the TCP case, the caller will be asked to poll for
314			* POLLOUT so that we start writing the packet in tcp_write()
315			* when the connection is established, or fail there on error.
316			*/
317			if (errno == EINPROGRESS)
318			return (sock);
319			goto fail;
320			}
321
322			return (sock);
323
324			fail:
325
326			if (sock != -1) {
327			errno_save = errno;
328			close(sock);
329			errno = errno_save;
330			}
331
332			return (-1);
333			}
334
335			/*
336			* Prepare the DNS packet for the query type "type", class "class" and domain
337			* name created by the concatenation on "name" and "dom".
338			* Return 0 on success, set errno and return -1 on error.
339			*/
340			static int
341			setup_query(struct asr_query as, const char name, const char *dom,
342			int class, int type)
343			{
344			struct asr_pack p;
345			struct asr_dns_header h;
346			char fqdn[MAXDNAME];
347			char dname[MAXDNAME];
348
349			if (as->as_flags & ASYNC_EXTOBUF) {
350			errno = EINVAL;
351			DPRINT("attempting to write in user packet");
352			return (-1);
353			}
354
355			if (_asr_make_fqdn(name, dom, fqdn, sizeof(fqdn)) > sizeof(fqdn)) {
356			errno = EINVAL;
357			DPRINT("asr_make_fqdn: name too long\n");
358			return (-1);
359			}
360
361			if (_asr_dname_from_fqdn(fqdn, dname, sizeof(dname)) == -1) {
362			errno = EINVAL;
363			DPRINT("asr_dname_from_fqdn: invalid\n");
364			return (-1);
365			}
366
367			if (as->as.dns.obuf == NULL) {
368			as->as.dns.obufsize = PACKETSZ;
369			as->as.dns.obuf = malloc(as->as.dns.obufsize);
370			if (as->as.dns.obuf == NULL)
371			return (-1); /* errno set */
372			}
373			as->as.dns.obuflen = 0;
374
375			memset(&h, 0, sizeof h);
376			h.id = res_randomid();
377			if (as->as_ctx->ac_options & RES_RECURSE)
378			h.flags \|= RD_MASK;
379			h.qdcount = 1;
380			if (as->as_ctx->ac_options & (RES_USE_EDNS0 \| RES_USE_DNSSEC))
381			h.arcount = 1;
382
383			_asr_pack_init(&p, as->as.dns.obuf, as->as.dns.obufsize);
384			_asr_pack_header(&p, &h);
385			_asr_pack_query(&p, type, class, dname);
386			if (as->as_ctx->ac_options & (RES_USE_EDNS0 \| RES_USE_DNSSEC))
387			_asr_pack_edns0(&p, MAXPACKETSZ,
388			as->as_ctx->ac_options & RES_USE_DNSSEC);
389			if (p.err) {
390			DPRINT("error packing query");
391			errno = EINVAL;
392			return (-1);
393			}
394
395			/* Remember the parameters. */
396			as->as.dns.reqid = h.id;
397			as->as.dns.type = type;
398			as->as.dns.class = class;
399			if (as->as.dns.dname)
400			free(as->as.dns.dname);
401			as->as.dns.dname = strdup(dname);
402			if (as->as.dns.dname == NULL) {
403			DPRINT("strdup");
404			return (-1); /* errno set */
405			}
406			as->as.dns.obuflen = p.offset;
407
408			DPRINT_PACKET("asr_setup_query", as->as.dns.obuf, as->as.dns.obuflen);
409
410			return (0);
411			}
412
413			/*
414			* Create a connect UDP socket and send the output packet.
415			*
416			* Return 0 on success, or -1 on error (errno set).
417			*/
418			static int
419			udp_send(struct asr_query *as)
420			{
421			ssize_t n;
422			int save_errno;
423			#ifdef DEBUG
424			char buf[256];
425			#endif
426
427			DPRINT("asr: [%p] connecting to %s UDP\n", as,
428			_asr_print_sockaddr(AS_NS_SA(as), buf, sizeof buf));
429
430			as->as_fd = sockaddr_connect(AS_NS_SA(as), SOCK_DGRAM);
431			if (as->as_fd == -1)
432			return (-1); /* errno set */
433
434			n = send(as->as_fd, as->as.dns.obuf, as->as.dns.obuflen, 0);
435			if (n == -1) {
436			save_errno = errno;
437			close(as->as_fd);
438			errno = save_errno;
439			as->as_fd = -1;
440			return (-1);
441			}
442
443			return (0);
444			}
445
446			/*
447			* Try to receive a valid packet from the current UDP socket.
448			*
449			* Return 0 if a full packet could be read, or -1 on error (errno set).
450			*/
451			static int
452			udp_recv(struct asr_query *as)
453			{
454			ssize_t n;
455			int save_errno;
456
457			if (ensure_ibuf(as, MAXPACKETSZ) == -1) {
458			save_errno = errno;
459			close(as->as_fd);
460			errno = save_errno;
461			as->as_fd = -1;
462			return (-1);
463			}
464
465			n = recv(as->as_fd, as->as.dns.ibuf, as->as.dns.ibufsize, 0);
466			save_errno = errno;
467			close(as->as_fd);
468			errno = save_errno;
469			as->as_fd = -1;
470			if (n == -1)
471			return (-1);
472
473			as->as.dns.ibuflen = n;
474
475			DPRINT_PACKET("asr_udp_recv()", as->as.dns.ibuf, as->as.dns.ibuflen);
476
477			if (validate_packet(as) == -1)
478			return (-1); /* errno set */
479
480			return (0);
481			}
482
483			/*
484			* Write the output packet to the TCP socket.
485			*
486			* Return 0 when all bytes have been sent, 1 there is no buffer space on the
487			* socket or it is not connected yet, or -1 on error (errno set).
488			*/
489			static int
490			tcp_write(struct asr_query *as)
491			{
492			struct msghdr msg;
493			struct iovec iov[2];
494			uint16_t len;
495			ssize_t n;
496			size_t offset;
497			int i;
498			#ifdef DEBUG
499			char buf[256];
500			#endif
501
502			/* First try to connect if not already */
503			if (as->as_fd == -1) {
504			DPRINT("asr: [%p] connecting to %s TCP\n", as,
505			_asr_print_sockaddr(AS_NS_SA(as), buf, sizeof buf));
506			as->as_fd = sockaddr_connect(AS_NS_SA(as), SOCK_STREAM);
507			if (as->as_fd == -1)
508			return (-1); /* errno set */
509			as->as.dns.datalen = 0; /* bytes sent */
510			return (1);
511			}
512
513			i = 0;
514
515			/* Prepend de packet length if not sent already. */
516			if (as->as.dns.datalen < sizeof(len)) {
517			offset = 0;
518			len = htons(as->as.dns.obuflen);
519			iov[i].iov_base = (char *)(&len) + as->as.dns.datalen;
520			iov[i].iov_len = sizeof(len) - as->as.dns.datalen;
521			i++;
522			} else
523			offset = as->as.dns.datalen - sizeof(len);
524
525			iov[i].iov_base = as->as.dns.obuf + offset;
526			iov[i].iov_len = as->as.dns.obuflen - offset;
527			i++;
528
529			memset(&msg, 0, sizeof msg);
530			msg.msg_iov = iov;
531			msg.msg_iovlen = i;
532
533			send_again:
534			n = sendmsg(as->as_fd, &msg, MSG_NOSIGNAL);
535			if (n == -1) {
536			if (errno == EINTR)
537			goto send_again;
538			goto close; /* errno set */
539			}
540
541			as->as.dns.datalen += n;
542
543			if (as->as.dns.datalen == as->as.dns.obuflen + sizeof(len)) {
544			/* All sent. Prepare for TCP read */
545			as->as.dns.datalen = 0;
546			return (0);
547			}
548
549			/* More data to write */
550			return (1);
551
552			close:
553			close(as->as_fd);
554			as->as_fd = -1;
555			return (-1);
556			}
557
558			/*
559			* Try to read a valid packet from the current TCP socket.
560			*
561			* Return 0 if a full packet could be read, 1 if more data is needed and the
562			* socket must be read again, or -1 on error (errno set).
563			*/
564			static int
565			tcp_read(struct asr_query *as)
566			{
567			ssize_t n;
568			size_t offset, len;
569			char *pos;
570			int save_errno, nfds;
571			struct pollfd pfd;
572
573			/* We must read the packet len first */
574			if (as->as.dns.datalen < sizeof(as->as.dns.pktlen)) {
575
576			pos = (char *)(&as->as.dns.pktlen) + as->as.dns.datalen;
577			len = sizeof(as->as.dns.pktlen) - as->as.dns.datalen;
578
579			n = read(as->as_fd, pos, len);
580			if (n == -1)
581			goto close; /* errno set */
582
583			as->as.dns.datalen += n;
584			if (as->as.dns.datalen < sizeof(as->as.dns.pktlen))
585			return (1); /* need more data */
586
587			as->as.dns.ibuflen = ntohs(as->as.dns.pktlen);
588			if (ensure_ibuf(as, as->as.dns.ibuflen) == -1)
589			goto close; /* errno set */
590
591			pfd.fd = as->as_fd;
592			pfd.events = POLLIN;
593			poll_again:
594			nfds = poll(&pfd, 1, 0);
595			if (nfds == -1) {
596			if (errno == EINTR)
597			goto poll_again;
598			goto close; /* errno set */
599			}
600			if (nfds == 0)
601			return (1); /* no more data available */
602			}
603
604			offset = as->as.dns.datalen - sizeof(as->as.dns.pktlen);
605			pos = as->as.dns.ibuf + offset;
606			len = as->as.dns.ibuflen - offset;
607
608			read_again:
609			n = read(as->as_fd, pos, len);
610			if (n == -1) {
611			if (errno == EINTR)
612			goto read_again;
613			goto close; /* errno set */
614			}
615			if (n == 0) {
616			errno = ECONNRESET;
617			goto close;
618			}
619			as->as.dns.datalen += n;
620
621			/* See if we got all the advertised bytes. */
622			if (as->as.dns.datalen != as->as.dns.ibuflen + sizeof(as->as.dns.pktlen))
623			return (1);
624
625			DPRINT_PACKET("asr_tcp_read()", as->as.dns.ibuf, as->as.dns.ibuflen);
626
627			if (validate_packet(as) == -1)
628			goto close; /* errno set */
629
630			errno = 0;
631			close:
632			save_errno = errno;
633			close(as->as_fd);
634			errno = save_errno;
635			as->as_fd = -1;
636			return (errno ? -1 : 0);
637			}
638
639			/*
640			* Make sure the input buffer is at least "n" bytes long, and allocate or
641			* extend it if necessary. Return 0 on success, or set errno and return -1.
642			*/
643			static int
644			ensure_ibuf(struct asr_query *as, size_t n)
645			{
646			char *t;
647
648			if (as->as.dns.ibufsize >= n)
649			return (0);
650
651			t = recallocarray(as->as.dns.ibuf, as->as.dns.ibufsize, n, 1);
652			if (t == NULL)
653			return (-1); /* errno set */
654			as->as.dns.ibuf = t;
655			as->as.dns.ibufsize = n;
656
657			return (0);
658			}
659
660			/*
661			* Check if the received packet is valid.
662			* Return 0 on success, or set errno and return -1.
663			*/
664			static int
665			validate_packet(struct asr_query *as)
666			{
667			struct asr_unpack p;
668			struct asr_dns_header h;
669			struct asr_dns_query q;
670			struct asr_dns_rr rr;
671			int r;
672
673			_asr_unpack_init(&p, as->as.dns.ibuf, as->as.dns.ibuflen);
674
675			_asr_unpack_header(&p, &h);
676			if (p.err)
677			goto inval;
678
679			if (h.id != as->as.dns.reqid) {
680			DPRINT("incorrect reqid\n");
681			goto inval;
682			}
683			if (h.qdcount != 1)
684			goto inval;
685			/* Should be zero, we could allow this */
686			if ((h.flags & Z_MASK) != 0)
687			goto inval;
688			/* Actually, it depends on the request but we only use OP_QUERY */
689			if (OPCODE(h.flags) != OP_QUERY)
690			goto inval;
691			/* Must be a response */
692			if ((h.flags & QR_MASK) == 0)
693			goto inval;
694
695			as->as.dns.rcode = RCODE(h.flags);
696			as->as.dns.ancount = h.ancount;
697
698			_asr_unpack_query(&p, &q);
699			if (p.err)
700			goto inval;
701
702			if (q.q_type != as->as.dns.type \|\|
703			q.q_class != as->as.dns.class \|\|
704			strcasecmp(q.q_dname, as->as.dns.dname)) {
705			DPRINT("incorrect type/class/dname '%s' != '%s'\n",
706			q.q_dname, as->as.dns.dname);
707			goto inval;
708			}
709
710			/* Check for truncation */
711			if (h.flags & TC_MASK && !(as->as_ctx->ac_options & RES_IGNTC)) {
712			DPRINT("truncated\n");
713			errno = EOVERFLOW;
714			return (-1);
715			}
716
717			/* Validate the rest of the packet */
718			for (r = h.ancount + h.nscount + h.arcount; r; r--)
719			_asr_unpack_rr(&p, &rr);
720
721			/* Report any error found when unpacking the RRs. */
722			if (p.err) {
723			DPRINT("unpack: %s\n", strerror(p.err));
724			errno = p.err;
725			return (-1);
726			}
727
728			if (p.offset != as->as.dns.ibuflen) {
729			DPRINT("trailing garbage\n");
730			errno = EMSGSIZE;
731			return (-1);
732			}
733
734			return (0);
735
736			inval:
737			errno = EINVAL;
738			return (-1);
739			}
740
741			/*
742			* Set the async context nameserver index to the next nameserver, cycling
743			* over the list until the maximum retry counter is reached. Return 0 on
744			* success, or -1 if all nameservers were used.
745			*/
746			static int
747			iter_ns(struct asr_query *as)
748			{
749			for (;;) {
750			if (as->as.dns.nsloop >= as->as_ctx->ac_nsretries)
751			return (-1);
752
753			as->as.dns.nsidx += 1;
754			if (as->as.dns.nsidx <= as->as_ctx->ac_nscount)
755			break;
756			as->as.dns.nsidx = 0;
757			as->as.dns.nsloop++;
758			DPRINT("asr: iter_ns(): cycle %i\n", as->as.dns.nsloop);
759			}
760
761			as->as_timeout = 1000 * (as->as_ctx->ac_nstimeout << as->as.dns.nsloop);
762			if (as->as.dns.nsloop > 0)
763			as->as_timeout /= as->as_ctx->ac_nscount;
764			if (as->as_timeout < 1000)
765			as->as_timeout = 1000;
766
767			return (0);
768			}