path: root/usr/src/lib/libdhcpdu/common/rfc2136.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include	<thread.h>
#include	<stdlib.h>
#include	<netdb.h>
#include	<strings.h>
#include	<alloca.h>
#include	<sys/socket.h>
#include	<netinet/in.h>
#include	<arpa/inet.h>
#include	<arpa/nameser.h>
#include	"res_update.h"
#include	<stdio.h>
#include	<errno.h>
#include	<resolv.h>
#include	<assert.h>
#include	<stdarg.h>
#include	<libnvpair.h>

#define	MAX_RETRIES	5	/* times to loop on TRY_AGAIN errors */
#define	LEASEMIN	3600	/* minimum lease time allowed by RFC 1531 */

static boolean_t	getNS(char *, struct in_addr *);
static void		cacheNS(char *, struct in_addr *, int);
static boolean_t	lookupNS(char *, struct in_addr *);
static boolean_t	send_update(struct hostent *, struct in_addr *);
static unsigned short	parse_ushort(const char **);
static unsigned int	parse_uint(const char **);
static void		freeupdrecs(ns_updque);
static void		freehost(struct hostent *);
static boolean_t	delA(struct __res_state *, char *);
static boolean_t	delPTR(struct __res_state *, char *, char *);
static boolean_t	addA(struct __res_state *, char *, struct in_addr);
static boolean_t	addPTR(struct __res_state *, char *, char *);
static boolean_t	retry_update(struct __res_state *, ns_updrec *);

extern char		*inet_ntoa_r(struct in_addr, char *);

/*
 *	The parent (calling) thread and the child thread it spawns to do an
 *	update use this structure to rendezvous.  The child thread sets the
 *	``done'' variable to B_TRUE when it's completed its work.  The nusers
 *	variable lets us arbitrate to see who has to clean up (via the
 *	provided childstat_cleanup() function) the dynamically-allocated
 *	structure - last one to wake up loses, and has to do the work.
 */
struct	childstat {
	mutex_t		m;
	cond_t		cv;
	struct hostent	*hp;
	boolean_t	synchflag;
	boolean_t	done;
	int		ret;
	int		nusers;
};
static void	childstat_cleanup(struct childstat *);

static void	update_thread(void *);

/*
 *	The given environment variable, if present, will contain the name
 *	of a file (or the distinguished values "stdout" and "stderr") into
 *	which we should place the debugging output from this shared object.
 *
 *	The debugging output is basically free-form but uses the dprint()
 *	function to ensure that each message is tagged with its thread ID,
 *	so we have some hope of sorting out later what actually happened.
 */
static char	env_filetoken[] = "DHCP_DNS_OUTPUT";
static void	dprint(char *, ...);
static FILE	*debug_fp;

static boolean_t	dns_config_ok;		/* did res_ninit() work? */

static nvlist_t	*nvl;

/* CSTYLED */
#pragma init	(init)

/*
 *	This is the shared object startup function, called once when we
 *	are dlopen()ed.
 */
static void
init(void)
{
	char *cp;
	struct __res_state res;

	if (cp = getenv(env_filetoken)) {
		if (strcmp(cp, "stdout") == 0)
			debug_fp = stdout;
		else if (strcmp(cp, "stderr") == 0)
			debug_fp = stderr;
		else {
			debug_fp = fopen(cp, "a");
		}
		if (debug_fp)
			(void) setvbuf(debug_fp, NULL, _IOLBF, BUFSIZ);
	}

	/*
	 *	Use res_ninit(3RESOLV) to see whether DNS has been configured
	 *	on the host running this code.  In practice, life must be very
	 *	bad for res_ninit() to fail.
	 */
	(void) memset(&res, 0, sizeof (res));
	if (res_ninit(&res) == -1) {
		dprint("res_ninit() failed - dns_config_ok FALSE\n");
		dns_config_ok = B_FALSE;
	} else {
		dprint("res_ninit() succeeded\n");
		dns_config_ok = B_TRUE;
	}
	res_ndestroy(&res);
}

/*
 *	This is the interface exported to the outside world.  Control over
 *	the hostent structure is assumed to pass to dns_puthostent();  it will
 *	free the associated space when done.
 */
int
dns_puthostent(struct hostent *hp, time_t timeout)
{
	struct childstat *sp;
	timestruc_t t;
	int ret;
	thread_t tid;


	/*
	 *	Check the consistency of the hostent structure:
	 *	both the name and address fields should be valid,
	 *	h_addrtype must be AF_INET, and h_length must be
	 *	sizeof (struct in_addr);
	 */
	if (hp == NULL) {
		dprint("hp is NULL - return -1\n");
		return (-1);
	}
	if (hp->h_addr_list == NULL) {
		dprint("h_addr_list is NULL - return -1\n");
		freehost(hp);
		return (-1);
	}
	if (hp->h_addr_list[0] == NULL) {
		dprint("h_addr_list is zero-length - return -1\n");
		freehost(hp);
		return (-1);
	}
	if (hp->h_name == NULL) {
		dprint("h_name is NULL - return -1\n");
		freehost(hp);
		return (-1);
	}
	if (hp->h_name[0] == '\0') {
		dprint("h_name[0] is NUL - return -1\n");
		freehost(hp);
		return (-1);
	}
	if (hp->h_addrtype != AF_INET) {
		dprint("h_addrtype (%d) != AF_INET - return -1\n",
		    hp->h_addrtype);
		freehost(hp);
		return (-1);
	}
	if (hp->h_length != sizeof (struct in_addr)) {
		dprint("h_length (%d) != sizeof (struct in_addr) - return -1\n",
		    hp->h_length);
		freehost(hp);
		return (-1);
	}

	dprint("dns_puthostent(%s, %d)\n", hp->h_name, (int)timeout);

	if (dns_config_ok == B_FALSE) {
		dprint("dns_config_ok FALSE - return -1\n");
		freehost(hp);
		return (-1);
	}

	if ((sp = malloc(sizeof (struct childstat))) == NULL) {
		dprint("malloc (sizeof struct childstat) failed\n");
		freehost(hp);
		return (-1);
	}

	/*
	 *	From this point on, both hp and sp are cleaned up and freed via
	 *	childstat_cleanup(), with bookkeeping done to see whether the
	 *	parent thread or the child one should be the one in charge of
	 *	cleaning up.
	 */
	sp->hp = hp;

	if (timeout > 0)
		sp->synchflag = B_TRUE;
	else
		sp->synchflag = B_FALSE;
	sp->done = B_FALSE;
	sp->ret = 0;
	sp->nusers = 1;
	(void) mutex_init(&sp->m, USYNC_THREAD, 0);
	(void) cond_init(&sp->cv, USYNC_THREAD, 0);
	(void) time(&t.tv_sec);
	t.tv_sec += timeout;
	t.tv_nsec = 0;

	if (thr_create(NULL, NULL, (void *(*)(void *))update_thread,
	    (void *) sp, THR_DAEMON|THR_DETACHED, &tid)) {
		dprint("thr_create failed (errno %d) - return -1\n", errno);
		childstat_cleanup(sp);
		return (-1);
	}
	else
		dprint("thread %u created\n", tid);

	if (!sp->done) {	/* we might already have finished */
		(void) mutex_lock(&sp->m);

		/* if asynchronous, and child still working, just return; */
		if ((!sp->done) && (timeout == 0)) {
			sp->nusers--;
			(void) mutex_unlock(&sp->m);
			dprint("done 0, timeout 0\n");
			return (0);
		}

		/* otherwise, wait for child to finish or time to expire */
		while (!sp->done)
			if (cond_timedwait(&sp->cv, &sp->m, &t) == ETIME) {
				/*
				 *	Child thread did not return before the
				 *	timeout.  One might think we could
				 *		assert(sp->nusers > 1);
				 *	here, but we can't:  we must protect
				 *	against this sequence of events:
				 *		cond_timedwait() times out
				 *
				 *		child finishes, grabs mutex,
				 *		decrements nusers, sets done,
				 *	    and exits.
				 *
				 *		cond_timedwait() reacquires the
				 *		mutex and returns ETIME
				 *
				 *	If this happens, nusers will now be 1,
				 *	even though cond_timedwait() returned
				 *	ETIME.
				 */
				if (sp->nusers == 1)
					/* child must have also set done */
					break;
				else
					/* child thread has not returned */
					sp->nusers--;
				(void) mutex_unlock(&sp->m);
				dprint("update for %s timed out\n", hp->h_name);
				return (0);
			}
		assert(sp->done);
		ret = sp->ret;
	}

	childstat_cleanup(sp);
	return (ret);
}

/*
 *	This worker thread, spawned by dns_puthostent(), is responsible for
 *	seeing that the update work gets done and cleaning up afterward
 *	if necessary.
 */
static void
update_thread(void *arg)
{
	char *p;
	int num_updated = 0;
	struct in_addr ia;
	struct hostent *hp;
	struct childstat *sp;

	dprint("update_thread running\n");

	sp = (struct childstat *)arg;

	(void) mutex_lock(&sp->m);
	/*
	 *	Paranoia:  if nusers was 0 and we were asked to do a
	 *	synchronous update, our parent must have incremented
	 *	it, called cond_timedwait(), timed out, and decremented it,
	 *	all before we got this far.  In this case, we do nothing
	 *	except clean up and exit.
	 */
	if ((++sp->nusers == 1) && sp->synchflag) {
		childstat_cleanup(sp);
		thr_exit(0);
	}

	(void) mutex_unlock(&sp->m);

	hp = sp->hp;

	/*
	 *	h_name should be full-qualified;  find the name servers for
	 *	its domain ...
	 */
	for (p = hp->h_name; *p != NULL; p++)
		if (*p == '.') {
			if (getNS(++p, &ia)) {
				char ntoab[INET_ADDRSTRLEN];

				(void) inet_ntoa_r(ia, ntoab);
				dprint("update for %s goes to %s\n",
				    hp->h_name, ntoab);
				/* ... and send the update to one of them. */
				if (send_update(hp, &ia)) {
					dprint("send_update succeeded\n");
					num_updated = 1;
				} else {
					dprint("send_update failed\n");
					num_updated = 0;
				}
			} else {
				dprint("getNS failed\n");
				num_updated = -1;
			}
			break;
		}
	dprint("update for %s returning %d\n", hp->h_name, num_updated);

	(void) mutex_lock(&sp->m);
	if (--sp->nusers == 0) {
		/* parent timed out and abandoned us - our turn to clean up */
		childstat_cleanup(sp);
	} else {
		sp->done = B_TRUE;
		sp->ret = num_updated;
		(void) cond_signal(&sp->cv);
		(void) mutex_unlock(&sp->m);
	}

	thr_exit(0);
}

/*
 *	Find a name server for the supplied domain and return its IP address.
 *	Sadly, in order to do this we have to parse the actual DNS reply
 *	packet - no functions are provided for doing this work for us.
 */
static boolean_t
getNS(char *domain, struct in_addr *iap)
{
	HEADER *hp;
	union {
		HEADER	h;
		char	buf[NS_PACKETSZ];
	} abuf;
	int alen;
	int count;
	int retries;
	unsigned char   name[MAXDNAME];
	int qdcount, ancount, nscount, arcount;
	unsigned char *data;
	unsigned char *m_bound;
	int type, class, ttl, dlen;
	struct hostent *ep;
	unsigned char *NS_data;
	boolean_t found_NS = B_FALSE;
	struct __res_state res;
	extern struct hostent *res_gethostbyname(const char *);

	if (lookupNS(domain, iap)) {
		dprint("getNS:  found cached IP address for domain %s\n",
		    domain);
		return (B_TRUE);
	}
	(void) memset(&res, 0, sizeof (res));
	if (res_ninit(&res) == -1) {
		dprint("getNS(\"%s\"):  res_ninit failed\n", domain);
		return (B_FALSE);
	}
	for (retries = 0; retries < MAX_RETRIES; retries++) {
		alen = res_nquery(&res, domain, C_IN, T_NS, (uchar_t *)&abuf,
		    sizeof (abuf));

		if (alen <= 0) {
			/*
			 * Look for indicators from libresolv:res_nsend()
			 * that we should retry a request.
			 */
			if ((errno == ECONNREFUSED) ||
			    ((h_errno == TRY_AGAIN) && (errno == ETIMEDOUT))) {
				dprint("getNS retry:  errno %d, h_errno %d\n",
				    errno, h_errno);
				continue;
			} else {
				dprint("getNS(\"%s\"):  res_nquery failed "
				    "(h_errno %d)\n", domain, h_errno);
				res_ndestroy(&res);
				return (B_FALSE);
			}
		}
	}
	if (alen <= 0) {
		dprint("getNS(\"%s\"):  res_nquery failed " "(h_errno %d)\n",
		    domain, h_errno);
		res_ndestroy(&res);
		return (B_FALSE);
	}

	m_bound = ((unsigned char *)&abuf) + alen;

	hp = (HEADER *)&abuf;
	data = (unsigned char *)&hp[1];	/* a DNS paradigm - actually abuf.buf */

	qdcount = ntohs(hp->qdcount);
	ancount = ntohs(hp->ancount);
	nscount = ntohs(hp->nscount);
	arcount = ntohs(hp->arcount);

	dprint("getNS(\"%s\"):\n", domain);
	dprint("\tqdcount %d\n", qdcount);
	dprint("\tancount %d\n", ancount);
	dprint("\tnscount %d\n", nscount);
	dprint("\tarcount %d\n", arcount);

	while (--qdcount >= 0) {
		dlen = dn_skipname(data, m_bound);
		if (dlen < 0) {
			dprint("dn_skipname returned < 0\n");
			res_ndestroy(&res);
			return (B_FALSE);
		}
		data += dlen + QFIXEDSZ;
	}

	count = ancount;
	count += arcount;
	while (--count >= 0 && data < m_bound) {
		if ((dlen = dn_expand((unsigned char *) &abuf, m_bound,
				data, (char *)name, sizeof (name))) < 0) {
			dprint("dn_expand() dom failed\n");
			res_ndestroy(&res);
			return (B_FALSE);
		}
		data += dlen;
		type = parse_ushort((const char **)&data);
		class = parse_ushort((const char **)&data);
		ttl = parse_uint((const char **)&data);
		dlen = parse_ushort((const char **)&data);

		switch (type) {
			case T_NS:
				dprint("\ttype T_NS\n");
				break;
			case T_CNAME:
				dprint("\ttype T_CNAME\n");
				break;
			case T_A:
				dprint("\ttype T_A\n");
				break;
			case T_SOA:
				dprint("\ttype T_SOA\n");
				break;
			case T_MX:
				dprint("\ttype T_MX\n");
				break;
			case T_TXT:
				dprint("\ttype T_TXT\n");
				break;
			default:
				dprint("\ttype %d\n", type);
			}
			if (class == C_IN)
				dprint("\tclass C_IN\n");
			else
				dprint("\tclass %d\n", class);
			dprint("\tttl %d secs\n", ttl);
			dprint("\tlen %d bytes\n", dlen);

		switch (type) {
		case T_A:
			(void) memcpy(iap, data, sizeof (struct in_addr));
			cacheNS(domain, iap, ttl);
			res_ndestroy(&res);
			return (B_TRUE);

		case T_NS:
			found_NS = B_TRUE;
			NS_data = data;	/* we may need this name below */
			if (dn_expand((unsigned char *) &abuf, m_bound, data,
			    (char *)name, sizeof (name)) < 0) {
				dprint("\tdn_expand() T_NS failed\n");
				res_ndestroy(&res);
				return (B_FALSE);
			}
			dprint("\tname %s\n", name);
			break;
		}
		data += dlen;
	}
	dprint("getNS:  fell through res_nquery results - no A records\n");

	/*
	 *	The reply contained NS records, but no A records.  Use
	 *	res_gethostbyname() to get the name server's address
	 *	via DNS.
	 */
	if (found_NS) {
		if (dn_expand((unsigned char *) &abuf, m_bound, NS_data,
		    (char *)name, sizeof (name)) < 0) {
			dprint("\tdn_expand() T_NS failed\n");
			res_ndestroy(&res);
			return (B_FALSE);
		}

		if (ep = res_gethostbyname((const char *)name)) {
			(void) memcpy(iap, ep->h_addr, sizeof (struct in_addr));
			cacheNS(domain, iap, ttl);
			res_ndestroy(&res);
			return (B_TRUE);
		} else
			dprint("getNS:  res_gethostbyname(%s) failed\n", name);
	} else {
		dprint("getNS:  reply contained no NS records\n");
	}

	res_ndestroy(&res);
	return (B_FALSE);
}

/*
 *	Cache the <domain, IP address> tuple (which is assumed to not already
 *	be cached) for ttl seconds.
 */
static void
cacheNS(char *domain, struct in_addr *iap, int ttl)
{
	if (ttl > 0) {
		time_t now;

		if (nvl == NULL &&
		    nvlist_alloc(&nvl, NV_UNIQUE_NAME_TYPE, 0) != 0) {
			dprint("cacheNS:  nvlist_alloc failed\n");
			return;
		}

		(void) time(&now);
		now += ttl;
		if ((nvlist_add_int32(nvl, domain, iap->s_addr) != 0) ||
		    (nvlist_add_byte_array(nvl, domain, (uchar_t *)&now,
			sizeof (now)) != 0)) {
			dprint("cacheNS:  nvlist_add failed\n");
			nvlist_free(nvl);
			nvl = NULL;
		}
	} else
		dprint("cacheNS:  ttl 0 - nothing to cache\n");
}

/*
 *	See whether the <domain, IP address> tuple has been cached.
 */
static boolean_t
lookupNS(char *domain, struct in_addr *iap)
{
	int32_t i;

	if (nvlist_lookup_int32(nvl, domain, &i) == 0) {
		time_t *ttlptr;
		uint_t nelem = sizeof (*ttlptr);

		if (nvlist_lookup_byte_array(nvl, domain, (uchar_t **)&ttlptr,
		    &nelem) != 0)
			return (B_FALSE);

		if (*ttlptr >= time(0)) {	/* still OK to use */
			iap->s_addr = i;
			return (B_TRUE);
		} else {
			(void) nvlist_remove_all(nvl, domain);
		}
	}

	return (B_FALSE);
}

/*
 *	Do the work of updating DNS to have the <hp->h_name <-> hp->h_addr>
 *	pairing.
 */
static boolean_t
send_update(struct hostent *hp, struct in_addr *to_server)
{
	char *forfqhost;
	struct __res_state res;
	struct in_addr netaddr;
	char revnamebuf[MAXDNAME];

	(void) memset(&res, 0, sizeof (res));
	if (res_ninit(&res) == -1) {
		dprint("send_updated res_ninit failed!");
		return (B_FALSE);
	}
	res.nscount = 1;
	res.nsaddr.sin_family = AF_INET;
	res.nsaddr.sin_port = htons(NAMESERVER_PORT);
	res.nsaddr.sin_addr.s_addr = to_server->s_addr;

	/* If debugging output desired, then ask resolver to do it, too */
	if (debug_fp != NULL)
		res.options |= RES_DEBUG;

	if (strchr(hp->h_name, '.') == NULL) {
		dprint("send_update handed non-FQDN:  %s\n", hp->h_name);
		res_ndestroy(&res);
		return (B_FALSE);
	}
	forfqhost = hp->h_name;

	/* Construct the fully-qualified name for PTR record updates */
	/* LINTED - alignment */
	netaddr.s_addr = ((struct in_addr *)hp->h_addr)->s_addr;
	(void) snprintf(revnamebuf, sizeof (revnamebuf),
	    "%u.%u.%u.%u.in-addr.ARPA",
	    netaddr.S_un.S_un_b.s_b4, netaddr.S_un.S_un_b.s_b3,
	    netaddr.S_un.S_un_b.s_b2, netaddr.S_un.S_un_b.s_b1);
	dprint("send_update %s:  revname %s\n", hp->h_name, revnamebuf);

	/*
	 *	The steps in doing an update:
	 *		-  delete any A records
	 *		-  delete any PTR records
	 *		-  add an A record
	 *		-  add a PTR record
	 */

	if (!delA(&res, forfqhost) ||
	    !delPTR(&res, forfqhost, revnamebuf) ||
	    !addA(&res, forfqhost, netaddr) ||
	    !addPTR(&res, forfqhost, revnamebuf)) {
		res_ndestroy(&res);
		return (B_FALSE);
	}
	res_ndestroy(&res);
	return (B_TRUE);
}

/* delete A records for this fully-qualified name */
static boolean_t
delA(struct __res_state *resp, char *fqdn)
{
	ns_updque q;
	ns_updrec *updreqp;

	INIT_LIST(q);
	updreqp = res_mkupdrec(S_UPDATE, fqdn, C_IN, T_A, 0);
	if (updreqp == NULL) {
		dprint("res_mkupdrec (del A) failed\n");
		return (B_FALSE);
	}
	updreqp->r_opcode = DELETE;
	updreqp->r_data = NULL;
	updreqp->r_size = 0;
	APPEND(q, updreqp, r_link);
	if (retry_update(resp, HEAD(q)) != 1) {
		dprint("res_nupdate (del A) failed - errno %d, h_errno %d\n",
		    errno, h_errno);
		freeupdrecs(q);
		return (B_FALSE);
	}
	freeupdrecs(q);
	return (B_TRUE);
}

/* delete PTR records for this address */
static boolean_t
delPTR(struct __res_state *resp, char *fqdn, char *revname)
{
	ns_updque q;
	ns_updrec *updreqp;

	INIT_LIST(q);
	updreqp = res_mkupdrec(S_UPDATE, revname, C_IN, T_PTR, 0);
	if (updreqp == NULL) {
		dprint("res_mkupdrec (del PTR) failed\n");
		return (B_FALSE);
	}
	updreqp->r_opcode = DELETE;
	updreqp->r_data = (unsigned char *)fqdn;
	updreqp->r_size = strlen(fqdn);
	APPEND(q, updreqp, r_link);
	if (retry_update(resp, HEAD(q)) != 1) {
		dprint("res_nupdate (del PTR) failed - errno %d, h_errno %d\n",
		    errno, h_errno);
		freeupdrecs(q);
		return (B_FALSE);
	}
	freeupdrecs(q);
	return (B_TRUE);
}

/* add an A record for this fqdn <-> addr pair */
static boolean_t
addA(struct __res_state *resp, char *fqdn, struct in_addr na)
{
	ns_updque q;
	ns_updrec *prereqp, *updreqp;
	int ttl = LEASEMIN;
	char ntoab[INET_ADDRSTRLEN];

	INIT_LIST(q);
	prereqp = res_mkupdrec(S_PREREQ, fqdn, C_IN, T_A, 0);
	if (prereqp == NULL) {
		dprint("res_mkupdrec (add A PREREQ) failed\n");
		return (B_FALSE);
	}
	prereqp->r_opcode = NXRRSET;
	prereqp->r_data = NULL;
	prereqp->r_size = 0;
	APPEND(q, prereqp, r_link);
	updreqp = res_mkupdrec(S_UPDATE, fqdn, C_IN, T_A, ttl);
	if (updreqp == NULL) {
		dprint("res_mkupdrec (add A UPDATE) failed\n");
		freeupdrecs(q);
		return (B_FALSE);
	}

	(void) inet_ntoa_r(na, ntoab);
	updreqp->r_opcode = ADD;
	updreqp->r_data = (unsigned char *)ntoab;
	updreqp->r_size = strlen(ntoab);
	APPEND(q, updreqp, r_link);
	if (retry_update(resp, HEAD(q)) != 1) {
		dprint("res_nupdate (ADD A) failed - errno %d, h_errno %d\n",
		    errno, h_errno);
		freeupdrecs(q);
		return (B_FALSE);
	}
	freeupdrecs(q);
	return (B_TRUE);
}

/* add a PTR record for this fqdn <-> address pair */
static boolean_t
addPTR(struct __res_state *resp, char *fqdn, char *revname)
{
	ns_updque q;
	ns_updrec *prereqp, *updreqp;
	int ttl = LEASEMIN;

	INIT_LIST(q);
	prereqp = res_mkupdrec(S_UPDATE, revname, C_IN, T_PTR, 0);
	if (prereqp == NULL) {
		dprint("res_mkupdrec (add PTR DELETE) failed\n");
		return (B_FALSE);
	}
	prereqp->r_opcode = DELETE;
	prereqp->r_data = NULL;
	prereqp->r_size = 0;
	APPEND(q, prereqp, r_link);
	updreqp = res_mkupdrec(S_UPDATE, revname, C_IN, T_PTR, ttl);
	if (updreqp == NULL) {
		dprint("res_mkupdrec (add PTR ADD) failed\n");
		freeupdrecs(q);
		return (B_FALSE);
	}
	updreqp->r_opcode = ADD;
	updreqp->r_data = (unsigned char *)fqdn;
	updreqp->r_size = strlen(fqdn);
	APPEND(q, updreqp, r_link);
	if (retry_update(resp, HEAD(q)) != 1) {
		dprint("res_nupdate (ADD PTR) failed - errno %d, h_errno %d\n",
		    errno, h_errno);
		freeupdrecs(q);
		return (B_FALSE);
	}
	freeupdrecs(q);

	return (B_TRUE);
}

/* retry an update request when appropriate */
static boolean_t
retry_update(struct __res_state *resp, ns_updrec *h)
{
	int retries;

	for (retries = 0; retries < MAX_RETRIES; retries++)
		if (res_nupdate(resp, h, NULL) == 1) {
			return (B_TRUE);
		} else {
			/*
			 * Look for indicators from libresolv:res_nsend()
			 * that we should retry a request.
			 */
			if ((errno == ECONNREFUSED) ||
			    ((h_errno == TRY_AGAIN) && (errno == ETIMEDOUT))) {
				dprint("retry_update - errno %d, h_errno %d\n",
				    errno, h_errno);
				continue;
			} else
				return (B_FALSE);
		}

	return (B_FALSE);
}

static void
freeupdrecs(ns_updque q)
{
	while (!EMPTY(q)) {
		ns_updrec *tmp;

		tmp = HEAD(q);
		UNLINK(q, tmp, r_link);
		res_freeupdrec(tmp);
	}
}

/*
 *	Parse a 16-bit quantity from a DNS reply packet.
 */
static unsigned short
parse_ushort(const char **pp)
{
	const uchar_t	*p = (const uchar_t *)*pp;
	unsigned short  val;

	val = (p[0] << 8) | p[1];
	*pp += 2;
	return (val);
}


/*
 *	Parse a 32-bit quantity from a DNS reply packet.
 */
static unsigned int
parse_uint(const char **pp)
{
	const uchar_t	*p = (const uchar_t *)*pp;
	unsigned int   val;

	val =  ((uint_t)p[0] << 24) | ((uint_t)p[1] << 16) |
	    ((uint_t)p[2] << 8) | (uint_t)p[3];
	*pp += 4;
	return (val);
}

/*
 *	Clean up a childstat structure's synchronization variables and free
 *	the allocated memory.
 */
static void
childstat_cleanup(struct childstat *sp)
{
	(void) cond_destroy(&sp->cv);
	(void) mutex_destroy(&sp->m);
	freehost(sp->hp);
	free(sp);
}

/*
 *	Format and print a debug message, prepending the thread ID of the
 *	thread logging the message.
 */
/* PRINTFLIKE1 */
static void
dprint(char *format, ...)
{
	va_list ap;

	va_start(ap, format);
	if (debug_fp) {
		(void) fprintf(debug_fp, "%u:  ", thr_self());
		(void) vfprintf(debug_fp, format, ap);
		va_end(ap);
	}
}

static void
freehost(struct hostent *hp)
{
	free(hp->h_addr);
	free(hp->h_addr_list);
	free(hp->h_name);
	free(hp);
}