 @@ -1,468 +1,468 @@
-.\"	$NetBSD: getaddrinfo.3,v 1.47 2009/10/02 02:45:29 tsarna Exp $
+.\"	$NetBSD: getaddrinfo.3,v 1.48 2009/10/02 06:49:23 cegger Exp $
 .\"	$KAME: getaddrinfo.3,v 1.36 2005/01/05 03:23:05 itojun Exp $
 .\"	$OpenBSD: getaddrinfo.3,v 1.35 2004/12/21 03:40:31 jaredy Exp $
 .\"
 .\" Copyright (C) 2004  Internet Systems Consortium, Inc. ("ISC")
 .\" Copyright (C) 2000, 2001  Internet Software Consortium.
 .\"
 .\" 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 ISC DISCLAIMS ALL WARRANTIES WITH
 .\" REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 .\" AND FITNESS.  IN NO EVENT SHALL ISC 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.
 .\"
 .Dd November 24, 2006
 .Dt GETADDRINFO 3
 .Os
 .Sh NAME
 .Nm getaddrinfo ,
 .Nm freeaddrinfo ,
 .Nm allocaddrinfo
 .Nd host and service name to socket address structure
 .Sh SYNOPSIS
 .In netdb.h
 .Ft int
 .Fn getaddrinfo "const char * restrict hostname" \
     "const char * restrict servname" \
     "const struct addrinfo * restrict hints" "struct addrinfo ** restrict res"
 .Ft void
 .Fn freeaddrinfo "struct addrinfo *ai"
 .Ft struct addrinfo *
 .Fn allocaddrinfo "socklen_t len"
 .Sh DESCRIPTION
 The
 .Fn getaddrinfo
 function is used to get a list of
 .Tn IP
 addresses and port numbers for host
 .Fa hostname
 and service
 .Fa servname .
 It is a replacement for and provides more flexibility than the
 .Xr gethostbyname 3
 and
 .Xr getservbyname 3
 functions.
 .Pp
 The
 .Fa hostname
 and
 .Fa servname
 arguments are either pointers to NUL-terminated strings or the null pointer.
 An acceptable value for
 .Fa hostname
 is either a valid host name or a numeric host address string consisting
 of a dotted decimal IPv4 address or an IPv6 address.
 The
 .Fa servname
 is either a decimal port number or a service name listed in
 .Xr services 5 .
 At least one of
 .Fa hostname
 and
 .Fa servname
 must be non-null.
 .Pp
 .Fa hints
 is an optional pointer to a
 .Li struct addrinfo ,
 as defined by
 .Aq Pa netdb.h :
 .Bd -literal
 struct addrinfo {
 	int ai_flags;		/* input flags */
 	int ai_family;		/* protocol family for socket */
 	int ai_socktype;	/* socket type */
 	int ai_protocol;	/* protocol for socket */
 	socklen_t ai_addrlen;	/* length of socket-address */
 	struct sockaddr *ai_addr; /* socket-address for socket */
 	char *ai_canonname;	/* canonical name for service location */
 	struct addrinfo *ai_next; /* pointer to next in list */
 };
 .Ed
 .Pp
 This structure can be used to provide hints concerning the type of socket
 that the caller supports or wishes to use.
 The caller can supply the following structure elements in
 .Fa hints :
 .Bl -tag -width "ai_socktypeXX"
 .It Fa ai_family
 The protocol family that should be used.
 When
 .Fa ai_family
 is set to
 .Dv PF_UNSPEC ,
 it means the caller will accept any protocol family supported by the
 operating system.
 .It Fa ai_socktype
 Denotes the type of socket that is wanted:
 .Dv SOCK_STREAM ,
 .Dv SOCK_DGRAM ,
 or
 .Dv SOCK_RAW .
 When
 .Fa ai_socktype
 is zero the caller will accept any socket type.
 .It Fa ai_protocol
 Indicates which transport protocol is desired,
 .Dv IPPROTO_UDP
 or
 .Dv IPPROTO_TCP .
 If
 .Fa ai_protocol
 is zero the caller will accept any protocol.
 .It Fa ai_flags
 .Fa ai_flags
 is formed by
 .Tn OR Ns 'ing
 the following values:
 .Bl -tag -width "AI_CANONNAMEXX"
 .It Dv AI_CANONNAME
 If the
 .Dv AI_CANONNAME
 bit is set, a successful call to
 .Fn getaddrinfo
 will return a NUL-terminated string containing the canonical name
 of the specified hostname in the
 .Fa ai_canonname
 element of the first
 .Li addrinfo
 structure returned.
 .It Dv AI_NUMERICHOST
 If the
 .Dv AI_NUMERICHOST
 bit is set, it indicates that
 .Fa hostname
 should be treated as a numeric string defining an IPv4 or IPv6 address
 and no name resolution should be attempted.
 .It Dv AI_NUMERICSERV
 If the
 .Dv AI_NUMERICSERV
 bit is set, it indicates that the
 .Fa servname
 string contains a numeric port number.
 This is used to prevent service name resolution.
 .It Dv AI_PASSIVE
 If the
 .Dv AI_PASSIVE
 bit is set it indicates that the returned socket address structure
 is intended for use in a call to
 .Xr bind 2 .
 In this case, if the
 .Fa hostname
 argument is the null pointer, then the IP address portion of the
 socket address structure will be set to
 .Dv INADDR_ANY
 for an IPv4 address or
 .Dv IN6ADDR_ANY_INIT
 for an IPv6 address.
 .Pp
 If the
 .Dv AI_PASSIVE
 bit is not set, the returned socket address structure will be ready
 for use in a call to
 .Xr connect 2
 for a connection-oriented protocol or
 .Xr connect 2 ,
 .Xr sendto 2 ,
 or
 .Xr sendmsg 2
 if a connectionless protocol was chosen.
 The
 .Tn IP
 address portion of the socket address structure will be set to the
 loopback address if
 .Fa hostname
 is the null pointer and
 .Dv AI_PASSIVE
 is not set.
 .El
 .El
 .Pp
 All other elements of the
 .Li addrinfo
 structure passed via
 .Fa hints
 must be zero or the null pointer.
 .Pp
 If
 .Fa hints
 is the null pointer,
 .Fn getaddrinfo
 behaves as if the caller provided a
 .Li struct addrinfo
 with
 .Fa ai_family
 set to
 .Dv PF_UNSPEC
 and all other elements set to zero or
 .Dv NULL .
 .Pp
 After a successful call to
 .Fn getaddrinfo ,
 .Fa *res
 is a pointer to a linked list of one or more
 .Li addrinfo
 structures.
 The list can be traversed by following the
 .Fa ai_next
 pointer in each
 .Li addrinfo
 structure until a null pointer is encountered.
 The three members
 .Fa ai_family ,
 .Fa ai_socktype ,
 and
 .Fa ai_protocol
 in each returned
 .Li addrinfo
 structure are suitable for a call to
 .Xr socket 2 .
 For each
 .Li addrinfo
 structure in the list, the
 .Fa ai_addr
 member points to a filled-in socket address structure of length
 .Fa ai_addrlen .
 .Pp
 This implementation of
 .Fn getaddrinfo
 allows numeric IPv6 address notation with scope identifier,
 as documented in chapter 11 of draft-ietf-ipv6-scoping-arch-02.txt.
 By appending the percent character and scope identifier to addresses,
 one can fill the
 .Li sin6_scope_id
 field for addresses.
 This would make management of scoped addresses easier
 and allows cut-and-paste input of scoped addresses.
 .Pp
 At this moment the code supports only link-local addresses with the format.
 The scope identifier is hardcoded to the name of the hardware interface
 associated
 with the link
 .Po
 such as
 .Li ne0
 .Pc .
 An example is
 .Dq Li fe80::1%ne0 ,
 which means
 .Do
 .Li fe80::1
 on the link associated with the
 .Li ne0
 interface
 .Dc .
 .Pp
-The current implementation assumes a one-to-one relationship between
+The current implementation assumes an one-to-one relationship between
 the interface and link, which is not necessarily true from the specification.
 .Pp
 All of the information returned by
 .Fn getaddrinfo
 is dynamically allocated: the
 .Li addrinfo
 structures themselves as well as the socket address structures and
 the canonical host name strings included in the
 .Li addrinfo
 structures.
 .Pp
 Memory allocated for the dynamically allocated structures created by
 a successful call to
 .Fn getaddrinfo
 is released by the
 .Fn freeaddrinfo
 function.
 The
 .Fa ai
-pointer should be a
+pointer should be an
 .Li addrinfo
 structure created by a call to
 .Fn getaddrinfo
 or
 .Fn allocaddrinfo .
 The
 .Fn allocaddrinfo
 function is intended primarily for authors of
 .Xr nsdispatch 3
 plugins implementing
 .Fn getaddrinfo
 backends.
 .Fn allocaddrinfo
 allocates a
 .Li struct addrinfo
 in a way that is compatible with being returned from
 .Fn getaddrinfo
 and being ultimately freed by
 .Fn freeaddrinfo .
 The returned structure is zeroed, except for the
 .Fa ai_addr
 field, which
 will point to
 .Fa len
 bytes of memory for storage of a socket address.
 It is safe to allocate memory separately for
 .Fa ai_canonname
 with
 .Xr malloc 3 ,
 or in any other way that is compatible with deallocation by
 .Xr free 3 .
 .Sh RETURN VALUES
 .Fn getaddrinfo
 returns zero on success or one of the error codes listed in
 .Xr gai_strerror 3
 if an error occurs.
 .Sh EXAMPLES
 The following code tries to connect to
 .Dq Li www.kame.net
 service
 .Dq Li http
 via a stream socket.
 It loops through all the addresses available, regardless of address family.
 If the destination resolves to an IPv4 address, it will use an
 .Dv AF_INET
 socket.
 Similarly, if it resolves to IPv6, an
 .Dv AF_INET6
 socket is used.
 Observe that there is no hardcoded reference to a particular address family.
 The code works even if
 .Fn getaddrinfo
 returns addresses that are not IPv4/v6.
 .Bd -literal -offset indent
 struct addrinfo hints, *res, *res0;
 int error;
 int s;
 const char *cause = NULL;
 memset(\*[Am]hints, 0, sizeof(hints));
 hints.ai_family = PF_UNSPEC;
 hints.ai_socktype = SOCK_STREAM;
 error = getaddrinfo("www.kame.net", "http", \*[Am]hints, \*[Am]res0);
 if (error) {
 	errx(1, "%s", gai_strerror(error));
 	/*NOTREACHED*/
+}
 s = -1;
 for (res = res0; res; res = res-\*[Gt]ai_next) {
 	s = socket(res-\*[Gt]ai_family, res-\*[Gt]ai_socktype,
 	    res-\*[Gt]ai_protocol);
 	if (s \*[Lt] 0) {
 		cause = "socket";
 		continue;
+	}
 	if (connect(s, res-\*[Gt]ai_addr, res-\*[Gt]ai_addrlen) \*[Lt] 0) {
 		cause = "connect";
 		close(s);
 		s = -1;
 		continue;
+	}
 	break;	/* okay we got one */
+}
 if (s \*[Lt] 0) {
 	err(1, "%s", cause);
 	/*NOTREACHED*/
+}
 freeaddrinfo(res0);
 .Ed
 .Pp
 The following example tries to open a wildcard listening socket onto service
 .Dq Li http ,
 for all the address families available.
 .Bd -literal -offset indent
 struct addrinfo hints, *res, *res0;
 int error;
 int s[MAXSOCK];
 int nsock;
 const char *cause = NULL;
 memset(\*[Am]hints, 0, sizeof(hints));
 hints.ai_family = PF_UNSPEC;
 hints.ai_socktype = SOCK_STREAM;
 hints.ai_flags = AI_PASSIVE;
 error = getaddrinfo(NULL, "http", \*[Am]hints, \*[Am]res0);
 if (error) {
 	errx(1, "%s", gai_strerror(error));
 	/*NOTREACHED*/
+}
 nsock = 0;
 for (res = res0; res \*[Am]\*[Am] nsock \*[Lt] MAXSOCK; res = res-\*[Gt]ai_next) {
 	s[nsock] = socket(res-\*[Gt]ai_family, res-\*[Gt]ai_socktype,
 	    res-\*[Gt]ai_protocol);
 	if (s[nsock] \*[Lt] 0) {
 		cause = "socket";
 		continue;
+	}
 	if (bind(s[nsock], res-\*[Gt]ai_addr, res-\*[Gt]ai_addrlen) \*[Lt] 0) {
 		cause = "bind";
 		close(s[nsock]);
 		continue;
+	}
 	(void) listen(s[nsock], 5);
 	nsock++;
+}
 if (nsock == 0) {
 	err(1, "%s", cause);
 	/*NOTREACHED*/
+}
 freeaddrinfo(res0);
 .Ed
 .Sh SEE ALSO
 .Xr bind 2 ,
 .Xr connect 2 ,
 .Xr send 2 ,
 .Xr socket 2 ,
 .Xr gai_strerror 3 ,
 .Xr gethostbyname 3 ,
 .Xr getnameinfo 3 ,
 .Xr getservbyname 3 ,
 .Xr resolver 3 ,
 .Xr hosts 5 ,
 .Xr resolv.conf 5 ,
 .Xr services 5 ,
 .Xr hostname 7 ,
 .Xr named 8
 .Rs
 .%A R. Gilligan
 .%A S. Thomson
 .%A J. Bound
 .%A J. McCann
 .%A W. Stevens
 .%T Basic Socket Interface Extensions for IPv6
 .%R RFC 3493
 .%D February 2003
 .Re
 .Rs
 .%A S. Deering
 .%A B. Haberman
 .%A T. Jinmei
 .%A E. Nordmark
 .%A B. Zill
 .%T "IPv6 Scoped Address Architecture"
 .%R internet draft
 .%N draft-ietf-ipv6-scoping-arch-02.txt
 .%O work in progress material
 .Re
 .Rs
 .%A Craig Metz
 .%T Protocol Independence Using the Sockets API
 .%B "Proceedings of the FREENIX track: 2000 USENIX annual technical conference"
 .%D June 2000
 .Re
 .Sh STANDARDS
 The
 .Fn getaddrinfo
 function is defined by the
 .St -p1003.1g-2000
 draft specification and documented in
 .Dv "RFC 3493" ,
 .Dq Basic Socket Interface Extensions for IPv6 .

 @@ -1,1958 +1,1958 @@
-/*	$NetBSD: getaddrinfo.c,v 1.93 2009/10/02 02:45:29 tsarna Exp $	*/
+/*	$NetBSD: getaddrinfo.c,v 1.94 2009/10/02 06:49:23 cegger Exp $	*/
 /*	$KAME: getaddrinfo.c,v 1.29 2000/08/31 17:26:57 itojun Exp $	*/
 /*
  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the project nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 /*
  * Issues to be discussed:
  * - Return values.  There are nonstandard return values defined and used
  *   in the source code.  This is because RFC2553 is silent about which error
  *   code must be returned for which situation.
  * - IPv4 classful (shortened) form.  RFC2553 is silent about it.  XNET 5.2
  *   says to use inet_aton() to convert IPv4 numeric to binary (alows
  *   classful form as a result).
  *   current code - disallow classful form for IPv4 (due to use of inet_pton).
  * - freeaddrinfo(NULL).  RFC2553 is silent about it.  XNET 5.2 says it is
  *   invalid.
  *   current code - SEGV on freeaddrinfo(NULL)
  * Note:
  * - The code filters out AFs that are not supported by the kernel,
  *   when globbing NULL hostname (to loopback, or wildcard).  Is it the right
  *   thing to do?  What is the relationship with post-RFC2553 AI_ADDRCONFIG
  *   in ai_flags?
  * - (post-2553) semantics of AI_ADDRCONFIG itself is too vague.
  *   (1) what should we do against numeric hostname (2) what should we do
  *   against NULL hostname (3) what is AI_ADDRCONFIG itself.  AF not ready?
  *   non-loopback address configured?  global address configured?
  */
 #include <sys/cdefs.h>
 #if defined(LIBC_SCCS) && !defined(lint)
-__RCSID("$NetBSD: getaddrinfo.c,v 1.93 2009/10/02 02:45:29 tsarna Exp $");
+__RCSID("$NetBSD: getaddrinfo.c,v 1.94 2009/10/02 06:49:23 cegger Exp $");
 #endif /* LIBC_SCCS and not lint */
 #include "namespace.h"
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/socket.h>
 #include <net/if.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <arpa/nameser.h>
 #include <assert.h>
 #include <ctype.h>
 #include <errno.h>
 #include <netdb.h>
 #include <resolv.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <syslog.h>
 #include <stdarg.h>
 #include <nsswitch.h>
 #ifdef YP
 #include <rpc/rpc.h>
 #include <rpcsvc/yp_prot.h>
 #include <rpcsvc/ypclnt.h>
 #endif
 #include "servent.h"
 #ifdef __weak_alias
 __weak_alias(getaddrinfo,_getaddrinfo)
 __weak_alias(freeaddrinfo,_freeaddrinfo)
 __weak_alias(gai_strerror,_gai_strerror)
 #endif
 #define SUCCESS 0
 #define ANY 0
 #define YES 1
 #define NO  0
 static const char in_addrany[] = { 0, 0, 0, 0 };
 static const char in_loopback[] = { 127, 0, 0, 1 };
 #ifdef INET6
 static const char in6_addrany[] = {
 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 };
 static const char in6_loopback[] = {
 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1
 };
 #endif
 static const struct afd {
 	int a_af;
 	int a_addrlen;
 	int a_socklen;
 	int a_off;
 	const char *a_addrany;
 	const char *a_loopback;
 	int a_scoped;
 } afdl [] = {
 #ifdef INET6
 	{PF_INET6, sizeof(struct in6_addr),
 	 sizeof(struct sockaddr_in6),
 	 offsetof(struct sockaddr_in6, sin6_addr),
 	 in6_addrany, in6_loopback, 1},
 #endif
 	{PF_INET, sizeof(struct in_addr),
 	 sizeof(struct sockaddr_in),
 	 offsetof(struct sockaddr_in, sin_addr),
 	 in_addrany, in_loopback, 0},
 	{0, 0, 0, 0, NULL, NULL, 0},
 };
 struct explore {
 	int e_af;
 	int e_socktype;
 	int e_protocol;
 	const char *e_protostr;
 	int e_wild;
 #define WILD_AF(ex)		((ex)->e_wild & 0x01)
 #define WILD_SOCKTYPE(ex)	((ex)->e_wild & 0x02)
 #define WILD_PROTOCOL(ex)	((ex)->e_wild & 0x04)
 };
 static const struct explore explore[] = {
 #if 0
 	{ PF_LOCAL, 0, ANY, ANY, NULL, 0x01 },
 #endif
 #ifdef INET6
 	{ PF_INET6, SOCK_DGRAM, IPPROTO_UDP, "udp", 0x07 },
 	{ PF_INET6, SOCK_STREAM, IPPROTO_TCP, "tcp", 0x07 },
 	{ PF_INET6, SOCK_RAW, ANY, NULL, 0x05 },
 #endif
 	{ PF_INET, SOCK_DGRAM, IPPROTO_UDP, "udp", 0x07 },
 	{ PF_INET, SOCK_STREAM, IPPROTO_TCP, "tcp", 0x07 },
 	{ PF_INET, SOCK_RAW, ANY, NULL, 0x05 },
 	{ PF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP, "udp", 0x07 },
 	{ PF_UNSPEC, SOCK_STREAM, IPPROTO_TCP, "tcp", 0x07 },
 	{ PF_UNSPEC, SOCK_RAW, ANY, NULL, 0x05 },
 	{ -1, 0, 0, NULL, 0 },
 };
 #ifdef INET6
 #define PTON_MAX	16
 #else
 #define PTON_MAX	4
 #endif
 static const ns_src default_dns_files[] = {
 	{ NSSRC_FILES, 	NS_SUCCESS },
 	{ NSSRC_DNS, 	NS_SUCCESS },
 	{ 0, 0 }
 };
 #define MAXPACKET	(64*1024)
 typedef union {
 	HEADER hdr;
 	u_char buf[MAXPACKET];
 } querybuf;
 struct res_target {
 	struct res_target *next;
 	const char *name;	/* domain name */
 	int qclass, qtype;	/* class and type of query */
 	u_char *answer;		/* buffer to put answer */
 	int anslen;		/* size of answer buffer */
 	int n;			/* result length */
 };
 static int str2number(const char *);
 static int explore_fqdn(const struct addrinfo *, const char *,
 	const char *, struct addrinfo **, struct servent_data *);
 static int explore_null(const struct addrinfo *,
 	const char *, struct addrinfo **, struct servent_data *);
 static int explore_numeric(const struct addrinfo *, const char *,
 	const char *, struct addrinfo **, const char *, struct servent_data *);
 static int explore_numeric_scope(const struct addrinfo *, const char *,
 	const char *, struct addrinfo **, struct servent_data *);
 static int get_canonname(const struct addrinfo *,
 	struct addrinfo *, const char *);
 static struct addrinfo *get_ai(const struct addrinfo *,
 	const struct afd *, const char *);
 static int get_portmatch(const struct addrinfo *, const char *,
     struct servent_data *);
 static int get_port(const struct addrinfo *, const char *, int,
     struct servent_data *);
 static const struct afd *find_afd(int);
 #ifdef INET6
 static int ip6_str2scopeid(char *, struct sockaddr_in6 *, u_int32_t *);
 #endif
 static struct addrinfo *getanswer(const querybuf *, int, const char *, int,
 	const struct addrinfo *);
 static void aisort(struct addrinfo *s, res_state res);
 static int _dns_getaddrinfo(void *, void *, va_list);
 static void _sethtent(FILE **);
 static void _endhtent(FILE **);
 static struct addrinfo *_gethtent(FILE **, const char *,
     const struct addrinfo *);
 static int _files_getaddrinfo(void *, void *, va_list);
 #ifdef YP
 static struct addrinfo *_yphostent(char *, const struct addrinfo *);
 static int _yp_getaddrinfo(void *, void *, va_list);
 #endif
 static int res_queryN(const char *, struct res_target *, res_state);
 static int res_searchN(const char *, struct res_target *, res_state);
 static int res_querydomainN(const char *, const char *,
 	struct res_target *, res_state);
 static const char * const ai_errlist[] = {
 	"Success",
 	"Address family for hostname not supported",	/* EAI_ADDRFAMILY */
 	"Temporary failure in name resolution",		/* EAI_AGAIN      */
 	"Invalid value for ai_flags",		       	/* EAI_BADFLAGS   */
 	"Non-recoverable failure in name resolution", 	/* EAI_FAIL       */
 	"ai_family not supported",			/* EAI_FAMILY     */
 	"Memory allocation failure", 			/* EAI_MEMORY     */
 	"No address associated with hostname", 		/* EAI_NODATA     */
 	"hostname nor servname provided, or not known",	/* EAI_NONAME     */
 	"servname not supported for ai_socktype",	/* EAI_SERVICE    */
 	"ai_socktype not supported", 			/* EAI_SOCKTYPE   */
 	"System error returned in errno", 		/* EAI_SYSTEM     */
 	"Invalid value for hints",			/* EAI_BADHINTS	  */
 	"Resolved protocol is unknown",			/* EAI_PROTOCOL   */
 	"Argument buffer overflow",			/* EAI_OVERFLOW   */
 	"Unknown error", 				/* EAI_MAX        */
 };
 /* XXX macros that make external reference is BAD. */
 #define GET_AI(ai, afd, addr) 					\
 do { 								\
 	/* external reference: pai, error, and label free */ 	\
 	(ai) = get_ai(pai, (afd), (addr)); 			\
 	if ((ai) == NULL) { 					\
 		error = EAI_MEMORY; 				\
 		goto free; 					\
 	} 							\
 } while (/*CONSTCOND*/0)
 #define GET_PORT(ai, serv, svd) 				\
 do { 								\
 	/* external reference: error and label free */ 		\
 	error = get_port((ai), (serv), 0, (svd)); 		\
 	if (error != 0) 					\
 		goto free; 					\
 } while (/*CONSTCOND*/0)
 #define GET_CANONNAME(ai, str) 					\
 do { 								\
 	/* external reference: pai, error and label free */ 	\
 	error = get_canonname(pai, (ai), (str)); 		\
 	if (error != 0) 					\
 		goto free; 					\
 } while (/*CONSTCOND*/0)
 #define ERR(err) 						\
 do { 								\
 	/* external reference: error, and label bad */ 		\
 	error = (err); 						\
 	goto bad; 						\
 	/*NOTREACHED*/ 						\
 } while (/*CONSTCOND*/0)
 #define MATCH_FAMILY(x, y, w) 						\
 	((x) == (y) || (/*CONSTCOND*/(w) && ((x) == PF_UNSPEC || 	\
 	    (y) == PF_UNSPEC)))
 #define MATCH(x, y, w) 							\
 	((x) == (y) || (/*CONSTCOND*/(w) && ((x) == ANY || (y) == ANY)))
 const char *
 gai_strerror(int ecode)
+{
 	if (ecode < 0 || ecode > EAI_MAX)
 		ecode = EAI_MAX;
 	return ai_errlist[ecode];
+}
 void
 freeaddrinfo(struct addrinfo *ai)
+{
 	struct addrinfo *next;
 	_DIAGASSERT(ai != NULL);
 	do {
 		next = ai->ai_next;
 		if (ai->ai_canonname)
 			free(ai->ai_canonname);
 		/* no need to free(ai->ai_addr) */
 		free(ai);
 		ai = next;
 	} while (ai);
+}
 static int
 str2number(const char *p)
+{
 	char *ep;
 	unsigned long v;
 	_DIAGASSERT(p != NULL);
 	if (*p == '\0')
 		return -1;
 	ep = NULL;
 	errno = 0;
 	v = strtoul(p, &ep, 10);
 	if (errno == 0 && ep && *ep == '\0' && v <= UINT_MAX)
 		return v;
 	else
 		return -1;
+}
 int
 getaddrinfo(const char *hostname, const char *servname,
     const struct addrinfo *hints, struct addrinfo **res)
+{
 	struct addrinfo sentinel;
 	struct addrinfo *cur;
 	int error = 0;
 	struct addrinfo ai;
 	struct addrinfo ai0;
 	struct addrinfo *pai;
 	const struct explore *ex;
 	struct servent_data svd;
 	/* hostname is allowed to be NULL */
 	/* servname is allowed to be NULL */
 	/* hints is allowed to be NULL */
 	_DIAGASSERT(res != NULL);
 	(void)memset(&svd, 0, sizeof(svd));
 	memset(&sentinel, 0, sizeof(sentinel));
 	cur = &sentinel;
 	memset(&ai, 0, sizeof(ai));
 	pai = &ai;
 	pai->ai_flags = 0;
 	pai->ai_family = PF_UNSPEC;
 	pai->ai_socktype = ANY;
 	pai->ai_protocol = ANY;
 	pai->ai_addrlen = 0;
 	pai->ai_canonname = NULL;
 	pai->ai_addr = NULL;
 	pai->ai_next = NULL;
 	if (hostname == NULL && servname == NULL)
 		return EAI_NONAME;
 	if (hints) {
 		/* error check for hints */
 		if (hints->ai_addrlen || hints->ai_canonname ||
 		    hints->ai_addr || hints->ai_next)
 			ERR(EAI_BADHINTS); /* xxx */
 		if (hints->ai_flags & ~AI_MASK)
 			ERR(EAI_BADFLAGS);
 		switch (hints->ai_family) {
 		case PF_UNSPEC:
 		case PF_INET:
 #ifdef INET6
 		case PF_INET6:
 #endif
 			break;
 		default:
 			ERR(EAI_FAMILY);
+		}
 		memcpy(pai, hints, sizeof(*pai));
 		/*
 		 * if both socktype/protocol are specified, check if they
 		 * are meaningful combination.
 		 */
 		if (pai->ai_socktype != ANY && pai->ai_protocol != ANY) {
 			for (ex = explore; ex->e_af >= 0; ex++) {
 				if (pai->ai_family != ex->e_af)
 					continue;
 				if (ex->e_socktype == ANY)
 					continue;
 				if (ex->e_protocol == ANY)
 					continue;
 				if (pai->ai_socktype == ex->e_socktype
 				 && pai->ai_protocol != ex->e_protocol) {
 					ERR(EAI_BADHINTS);
+				}
+			}
+		}
+	}
 	/*
 	 * check for special cases.  (1) numeric servname is disallowed if
 	 * socktype/protocol are left unspecified. (2) servname is disallowed
 	 * for raw and other inet{,6} sockets.
 	 */
 	if (MATCH_FAMILY(pai->ai_family, PF_INET, 1)
 #ifdef PF_INET6
 	 || MATCH_FAMILY(pai->ai_family, PF_INET6, 1)
 #endif
 	    ) {
 		ai0 = *pai;	/* backup *pai */
 		if (pai->ai_family == PF_UNSPEC) {
 #ifdef PF_INET6
 			pai->ai_family = PF_INET6;
 #else
 			pai->ai_family = PF_INET;
 #endif
+		}
 		error = get_portmatch(pai, servname, &svd);
 		if (error)
 			ERR(error);
 		*pai = ai0;
+	}
 	ai0 = *pai;
 	/* NULL hostname, or numeric hostname */
 	for (ex = explore; ex->e_af >= 0; ex++) {
 		*pai = ai0;
 		/* PF_UNSPEC entries are prepared for DNS queries only */
 		if (ex->e_af == PF_UNSPEC)
 			continue;
 		if (!MATCH_FAMILY(pai->ai_family, ex->e_af, WILD_AF(ex)))
 			continue;
 		if (!MATCH(pai->ai_socktype, ex->e_socktype, WILD_SOCKTYPE(ex)))
 			continue;
 		if (!MATCH(pai->ai_protocol, ex->e_protocol, WILD_PROTOCOL(ex)))
 			continue;
 		if (pai->ai_family == PF_UNSPEC)
 			pai->ai_family = ex->e_af;
 		if (pai->ai_socktype == ANY && ex->e_socktype != ANY)
 			pai->ai_socktype = ex->e_socktype;
 		if (pai->ai_protocol == ANY && ex->e_protocol != ANY)
 			pai->ai_protocol = ex->e_protocol;
 		if (hostname == NULL)
 			error = explore_null(pai, servname, &cur->ai_next,
 			    &svd);
 		else
 			error = explore_numeric_scope(pai, hostname, servname,
 			    &cur->ai_next, &svd);
 		if (error)
 			goto free;
 		while (cur->ai_next)
 			cur = cur->ai_next;
+	}
 	/*
 	 * XXX
 	 * If numeric representation of AF1 can be interpreted as FQDN
 	 * representation of AF2, we need to think again about the code below.
 	 */
 	if (sentinel.ai_next)
 		goto good;
 	if (hostname == NULL)
 		ERR(EAI_NODATA);
 	if (pai->ai_flags & AI_NUMERICHOST)
 		ERR(EAI_NONAME);
 	/*
 	 * hostname as alphabetical name.
 	 * we would like to prefer AF_INET6 than AF_INET, so we'll make a
 	 * outer loop by AFs.
 	 */
 	for (ex = explore; ex->e_af >= 0; ex++) {
 		*pai = ai0;
 		/* require exact match for family field */
 		if (pai->ai_family != ex->e_af)
 			continue;
 		if (!MATCH(pai->ai_socktype, ex->e_socktype,
 				WILD_SOCKTYPE(ex))) {
 			continue;
+		}
 		if (!MATCH(pai->ai_protocol, ex->e_protocol,
 				WILD_PROTOCOL(ex))) {
 			continue;
+		}
 		if (pai->ai_socktype == ANY && ex->e_socktype != ANY)
 			pai->ai_socktype = ex->e_socktype;
 		if (pai->ai_protocol == ANY && ex->e_protocol != ANY)
 			pai->ai_protocol = ex->e_protocol;
 		error = explore_fqdn(pai, hostname, servname, &cur->ai_next,
 		    &svd);
 		while (cur && cur->ai_next)
 			cur = cur->ai_next;
+	}
 	/* XXX */
 	if (sentinel.ai_next)
 		error = 0;
 	if (error)
 		goto free;
 	if (sentinel.ai_next) {
  good:
 		endservent_r(&svd);
 		*res = sentinel.ai_next;
 		return SUCCESS;
 	} else
 		error = EAI_FAIL;
  free:
  bad:
 	endservent_r(&svd);
 	if (sentinel.ai_next)
 		freeaddrinfo(sentinel.ai_next);
 	*res = NULL;
 	return error;
+}
 /*
  * FQDN hostname, DNS lookup
  */
 static int
 explore_fqdn(const struct addrinfo *pai, const char *hostname,
     const char *servname, struct addrinfo **res, struct servent_data *svd)
+{
 	struct addrinfo *result;
 	struct addrinfo *cur;
 	int error = 0;
 	static const ns_dtab dtab[] = {
 		NS_FILES_CB(_files_getaddrinfo, NULL)
 		{ NSSRC_DNS, _dns_getaddrinfo, NULL },	/* force -DHESIOD */
 		NS_NIS_CB(_yp_getaddrinfo, NULL)
 		NS_NULL_CB
 	};
 	_DIAGASSERT(pai != NULL);
 	/* hostname may be NULL */
 	/* servname may be NULL */
 	_DIAGASSERT(res != NULL);
 	result = NULL;
 	/*
 	 * if the servname does not match socktype/protocol, ignore it.
 	 */
 	if (get_portmatch(pai, servname, svd) != 0)
 		return 0;
 	switch (nsdispatch(&result, dtab, NSDB_HOSTS, "getaddrinfo",
 			default_dns_files, hostname, pai)) {
 	case NS_TRYAGAIN:
 		error = EAI_AGAIN;
 		goto free;
 	case NS_UNAVAIL:
 		error = EAI_FAIL;
 		goto free;
 	case NS_NOTFOUND:
 		error = EAI_NODATA;
 		goto free;
 	case NS_SUCCESS:
 		error = 0;
 		for (cur = result; cur; cur = cur->ai_next) {
 			GET_PORT(cur, servname, svd);
 			/* canonname should be filled already */
+		}
 		break;
+	}
 	*res = result;
 	return 0;
 free:
 	if (result)
 		freeaddrinfo(result);
 	return error;
+}
 /*
  * hostname == NULL.
  * passive socket -> anyaddr (0.0.0.0 or ::)
  * non-passive socket -> localhost (127.0.0.1 or ::1)
  */
 static int
 explore_null(const struct addrinfo *pai, const char *servname,
     struct addrinfo **res, struct servent_data *svd)
+{
 	int s;
 	const struct afd *afd;
 	struct addrinfo *cur;
 	struct addrinfo sentinel;
 	int error;
 	_DIAGASSERT(pai != NULL);
 	/* servname may be NULL */
 	_DIAGASSERT(res != NULL);
 	*res = NULL;
 	sentinel.ai_next = NULL;
 	cur = &sentinel;
 	/*
 	 * filter out AFs that are not supported by the kernel
 	 * XXX errno?
 	 */
 	s = socket(pai->ai_family, SOCK_DGRAM, 0);
 	if (s < 0) {
 		if (errno != EMFILE)
 			return 0;
 	} else
 		close(s);
 	/*
 	 * if the servname does not match socktype/protocol, ignore it.
 	 */
 	if (get_portmatch(pai, servname, svd) != 0)
 		return 0;
 	afd = find_afd(pai->ai_family);
 	if (afd == NULL)
 		return 0;
 	if (pai->ai_flags & AI_PASSIVE) {
 		GET_AI(cur->ai_next, afd, afd->a_addrany);
 		/* xxx meaningless?
 		 * GET_CANONNAME(cur->ai_next, "anyaddr");
 		 */
 		GET_PORT(cur->ai_next, servname, svd);
 	} else {
 		GET_AI(cur->ai_next, afd, afd->a_loopback);
 		/* xxx meaningless?
 		 * GET_CANONNAME(cur->ai_next, "localhost");
 		 */
 		GET_PORT(cur->ai_next, servname, svd);
+	}
 	cur = cur->ai_next;
 	*res = sentinel.ai_next;
 	return 0;
 free:
 	if (sentinel.ai_next)
 		freeaddrinfo(sentinel.ai_next);
 	return error;
+}
 /*
  * numeric hostname
  */
 static int
 explore_numeric(const struct addrinfo *pai, const char *hostname,
     const char *servname, struct addrinfo **res, const char *canonname,
     struct servent_data *svd)
+{
 	const struct afd *afd;
 	struct addrinfo *cur;
 	struct addrinfo sentinel;
 	int error;
 	char pton[PTON_MAX];
 	_DIAGASSERT(pai != NULL);
 	/* hostname may be NULL */
 	/* servname may be NULL */
 	_DIAGASSERT(res != NULL);
 	*res = NULL;
 	sentinel.ai_next = NULL;
 	cur = &sentinel;
 	/*
 	 * if the servname does not match socktype/protocol, ignore it.
 	 */
 	if (get_portmatch(pai, servname, svd) != 0)
 		return 0;
 	afd = find_afd(pai->ai_family);
 	if (afd == NULL)
 		return 0;
 	switch (afd->a_af) {
 #if 0 /*X/Open spec*/
 	case AF_INET:
 		if (inet_aton(hostname, (struct in_addr *)pton) == 1) {
 			if (pai->ai_family == afd->a_af ||
 			    pai->ai_family == PF_UNSPEC /*?*/) {
 				GET_AI(cur->ai_next, afd, pton);
 				GET_PORT(cur->ai_next, servname, svd);
 				if ((pai->ai_flags & AI_CANONNAME)) {
 					/*
 					 * Set the numeric address itself as
 					 * the canonical name, based on a
 					 * clarification in rfc2553bis-03.
 					 */
 					GET_CANONNAME(cur->ai_next, canonname);
+				}
 				while (cur && cur->ai_next)
 					cur = cur->ai_next;
 			} else
 				ERR(EAI_FAMILY);	/*xxx*/
+		}
 		break;
 #endif
 	default:
 		if (inet_pton(afd->a_af, hostname, pton) == 1) {
 			if (pai->ai_family == afd->a_af ||
 			    pai->ai_family == PF_UNSPEC /*?*/) {
 				GET_AI(cur->ai_next, afd, pton);
 				GET_PORT(cur->ai_next, servname, svd);
 				if ((pai->ai_flags & AI_CANONNAME)) {
 					/*
 					 * Set the numeric address itself as
 					 * the canonical name, based on a
 					 * clarification in rfc2553bis-03.
 					 */
 					GET_CANONNAME(cur->ai_next, canonname);
+				}
 				while (cur->ai_next)
 					cur = cur->ai_next;
 			} else
 				ERR(EAI_FAMILY);	/*xxx*/
+		}
 		break;
+	}
 	*res = sentinel.ai_next;
 	return 0;
 free:
 bad:
 	if (sentinel.ai_next)
 		freeaddrinfo(sentinel.ai_next);
 	return error;
+}
 /*
  * numeric hostname with scope
  */
 static int
 explore_numeric_scope(const struct addrinfo *pai, const char *hostname,
     const char *servname, struct addrinfo **res, struct servent_data *svd)
+{
 #if !defined(SCOPE_DELIMITER) || !defined(INET6)
 	return explore_numeric(pai, hostname, servname, res, hostname, svd);
 #else
 	const struct afd *afd;
 	struct addrinfo *cur;
 	int error;
 	char *cp, *hostname2 = NULL, *scope, *addr;
 	struct sockaddr_in6 *sin6;
 	_DIAGASSERT(pai != NULL);
 	/* hostname may be NULL */
 	/* servname may be NULL */
 	_DIAGASSERT(res != NULL);
 	/*
 	 * if the servname does not match socktype/protocol, ignore it.
 	 */
 	if (get_portmatch(pai, servname, svd) != 0)
 		return 0;
 	afd = find_afd(pai->ai_family);
 	if (afd == NULL)
 		return 0;
 	if (!afd->a_scoped)
 		return explore_numeric(pai, hostname, servname, res, hostname,
 		    svd);
 	cp = strchr(hostname, SCOPE_DELIMITER);
 	if (cp == NULL)
 		return explore_numeric(pai, hostname, servname, res, hostname,
 		    svd);
 	/*
 	 * Handle special case of <scoped_address><delimiter><scope id>
 	 */
 	hostname2 = strdup(hostname);
 	if (hostname2 == NULL)
 		return EAI_MEMORY;
 	/* terminate at the delimiter */
 	hostname2[cp - hostname] = '\0';
 	addr = hostname2;
 	scope = cp + 1;
 	error = explore_numeric(pai, addr, servname, res, hostname, svd);
 	if (error == 0) {
 		u_int32_t scopeid;
 		for (cur = *res; cur; cur = cur->ai_next) {
 			if (cur->ai_family != AF_INET6)
 				continue;
 			sin6 = (struct sockaddr_in6 *)(void *)cur->ai_addr;
 			if (ip6_str2scopeid(scope, sin6, &scopeid) == -1) {
 				free(hostname2);
 				return(EAI_NODATA); /* XXX: is return OK? */
+			}
 			sin6->sin6_scope_id = scopeid;
+		}
+	}
 	free(hostname2);
 	return error;
 #endif
+}
 static int
 get_canonname(const struct addrinfo *pai, struct addrinfo *ai, const char *str)
+{
 	_DIAGASSERT(pai != NULL);
 	_DIAGASSERT(ai != NULL);
 	_DIAGASSERT(str != NULL);
 	if ((pai->ai_flags & AI_CANONNAME) != 0) {
 		ai->ai_canonname = strdup(str);
 		if (ai->ai_canonname == NULL)
 			return EAI_MEMORY;
+	}
 	return 0;
+}
 struct addrinfo *
 allocaddrinfo(socklen_t addrlen)
+{
 	struct addrinfo *ai;
 	ai = calloc(sizeof(struct addrinfo) + addrlen, 1);
 	if (ai) {
 		ai->ai_addr = (void *)(ai+1);
 		ai->ai_addrlen = ai->ai_addr->sa_len = addrlen;
+	}
 	return ai;
+}
 static struct addrinfo *
 get_ai(const struct addrinfo *pai, const struct afd *afd, const char *addr)
+{
 	char *p;
 	struct addrinfo *ai;
 	struct sockaddr *save;
 	_DIAGASSERT(pai != NULL);
 	_DIAGASSERT(afd != NULL);
 	_DIAGASSERT(addr != NULL);
 	ai = allocaddrinfo((socklen_t)afd->a_socklen);
 	if (ai == NULL)
 		return NULL;
         save = ai->ai_addr;
 	memcpy(ai, pai, sizeof(struct addrinfo));
         /* since we just overwrote all of ai, we have
            to restore ai_addr and ai_addrlen */
         ai->ai_addr = save;
         ai->ai_addrlen = (socklen_t)afd->a_socklen;
 	ai->ai_addr->sa_family = ai->ai_family = afd->a_af;
 	p = (char *)(void *)(ai->ai_addr);
 	memcpy(p + afd->a_off, addr, (size_t)afd->a_addrlen);
 	return ai;
+}
 static int
 get_portmatch(const struct addrinfo *ai, const char *servname,
     struct servent_data *svd)
+{
 	_DIAGASSERT(ai != NULL);
 	/* servname may be NULL */
 	return get_port(ai, servname, 1, svd);
+}
 static int
 get_port(const struct addrinfo *ai, const char *servname, int matchonly,
     struct servent_data *svd)
+{
 	const char *proto;
 	struct servent *sp;
 	int port;
 	int allownumeric;
 	_DIAGASSERT(ai != NULL);
 	/* servname may be NULL */
 	if (servname == NULL)
 		return 0;
 	switch (ai->ai_family) {
 	case AF_INET:
 #ifdef AF_INET6
 	case AF_INET6:
 #endif
 		break;
 	default:
 		return 0;
+	}
 	switch (ai->ai_socktype) {
 	case SOCK_RAW:
 		return EAI_SERVICE;
 	case SOCK_DGRAM:
 	case SOCK_STREAM:
 		allownumeric = 1;
 		break;
 	case ANY:
 		/*
 		 * This was 0.  It is now 1 so that queries specifying
 		 * a NULL hint, or hint without socktype (but, hopefully,
 		 * with protocol) and numeric address actually work.
 		 */
 		allownumeric = 1;
 		break;
 	default:
 		return EAI_SOCKTYPE;
+	}
 	port = str2number(servname);
 	if (port >= 0) {
 		if (!allownumeric)
 			return EAI_SERVICE;
 		if (port < 0 || port > 65535)
 			return EAI_SERVICE;
 		port = htons(port);
 	} else {
 		struct servent sv;
 		if (ai->ai_flags & AI_NUMERICSERV)
 			return EAI_NONAME;
 		switch (ai->ai_socktype) {
 		case SOCK_DGRAM:
 			proto = "udp";
 			break;
 		case SOCK_STREAM:
 			proto = "tcp";
 			break;
 		default:
 			proto = NULL;
 			break;
+		}
 		sp = getservbyname_r(servname, proto, &sv, svd);
 		if (sp == NULL)
 			return EAI_SERVICE;
 		port = sp->s_port;
+	}
 	if (!matchonly) {
 		switch (ai->ai_family) {
 		case AF_INET:
 			((struct sockaddr_in *)(void *)
 			    ai->ai_addr)->sin_port = port;
 			break;
 #ifdef INET6
 		case AF_INET6:
 			((struct sockaddr_in6 *)(void *)
 			    ai->ai_addr)->sin6_port = port;
 			break;
 #endif
+		}
+	}
 	return 0;
+}
 static const struct afd *
 find_afd(int af)
+{
 	const struct afd *afd;
 	if (af == PF_UNSPEC)
 		return NULL;
 	for (afd = afdl; afd->a_af; afd++) {
 		if (afd->a_af == af)
 			return afd;
+	}
 	return NULL;
+}
 #ifdef INET6
 /* convert a string to a scope identifier. XXX: IPv6 specific */
 static int
 ip6_str2scopeid(char *scope, struct sockaddr_in6 *sin6, u_int32_t *scopeid)
+{
 	u_long lscopeid;
 	struct in6_addr *a6;
 	char *ep;
 	_DIAGASSERT(scope != NULL);
 	_DIAGASSERT(sin6 != NULL);
 	_DIAGASSERT(scopeid != NULL);
 	a6 = &sin6->sin6_addr;
 	/* empty scopeid portion is invalid */
 	if (*scope == '\0')
 		return -1;
 	if (IN6_IS_ADDR_LINKLOCAL(a6) || IN6_IS_ADDR_MC_LINKLOCAL(a6)) {
 		/*
-		 * We currently assume a one-to-one mapping between links
+		 * We currently assume an one-to-one mapping between links
 		 * and interfaces, so we simply use interface indices for
 		 * like-local scopes.
 		 */
 		*scopeid = if_nametoindex(scope);
 		if (*scopeid == 0)
 			goto trynumeric;
 		return 0;
+	}
 	/* still unclear about literal, allow numeric only - placeholder */
 	if (IN6_IS_ADDR_SITELOCAL(a6) || IN6_IS_ADDR_MC_SITELOCAL(a6))
 		goto trynumeric;
 	if (IN6_IS_ADDR_MC_ORGLOCAL(a6))
 		goto trynumeric;
 	else
 		goto trynumeric;	/* global */
 	/* try to convert to a numeric id as a last resort */
   trynumeric:
 	errno = 0;
 	lscopeid = strtoul(scope, &ep, 10);
 	*scopeid = (u_int32_t)(lscopeid & 0xffffffffUL);
 	if (errno == 0 && ep && *ep == '\0' && *scopeid == lscopeid)
 		return 0;
 	else
 		return -1;
+}
 #endif
 /* code duplicate with gethnamaddr.c */
 static const char AskedForGot[] =
 	"gethostby*.getanswer: asked for \"%s\", got \"%s\"";
 static struct addrinfo *
 getanswer(const querybuf *answer, int anslen, const char *qname, int qtype,
     const struct addrinfo *pai)
+{
 	struct addrinfo sentinel, *cur;
 	struct addrinfo ai;
 	const struct afd *afd;
 	char *canonname;
 	const HEADER *hp;
 	const u_char *cp;
 	int n;
 	const u_char *eom;
 	char *bp, *ep;
 	int type, class, ancount, qdcount;
 	int haveanswer, had_error;
 	char tbuf[MAXDNAME];
 	int (*name_ok) (const char *);
 	char hostbuf[8*1024];
 	_DIAGASSERT(answer != NULL);
 	_DIAGASSERT(qname != NULL);
 	_DIAGASSERT(pai != NULL);
 	memset(&sentinel, 0, sizeof(sentinel));
 	cur = &sentinel;
 	canonname = NULL;
 	eom = answer->buf + anslen;
 	switch (qtype) {
 	case T_A:
 	case T_AAAA:
 	case T_ANY:	/*use T_ANY only for T_A/T_AAAA lookup*/
 		name_ok = res_hnok;
 		break;
 	default:
 		return NULL;	/* XXX should be abort(); */
+	}
 	/*
 	 * find first satisfactory answer
 	 */
 	hp = &answer->hdr;
 	ancount = ntohs(hp->ancount);
 	qdcount = ntohs(hp->qdcount);
 	bp = hostbuf;
 	ep = hostbuf + sizeof hostbuf;
 	cp = answer->buf + HFIXEDSZ;
 	if (qdcount != 1) {
 		h_errno = NO_RECOVERY;
 		return (NULL);
+	}
 	n = dn_expand(answer->buf, eom, cp, bp, ep - bp);
 	if ((n < 0) || !(*name_ok)(bp)) {
 		h_errno = NO_RECOVERY;
 		return (NULL);
+	}
 	cp += n + QFIXEDSZ;
 	if (qtype == T_A || qtype == T_AAAA || qtype == T_ANY) {
 		/* res_send() has already verified that the query name is the
 		 * same as the one we sent; this just gets the expanded name
 		 * (i.e., with the succeeding search-domain tacked on).
 		 */
 		n = strlen(bp) + 1;		/* for the \0 */
 		if (n >= MAXHOSTNAMELEN) {
 			h_errno = NO_RECOVERY;
 			return (NULL);
+		}
 		canonname = bp;
 		bp += n;
 		/* The qname can be abbreviated, but h_name is now absolute. */
 		qname = canonname;
+	}
 	haveanswer = 0;
 	had_error = 0;
 	while (ancount-- > 0 && cp < eom && !had_error) {
 		n = dn_expand(answer->buf, eom, cp, bp, ep - bp);
 		if ((n < 0) || !(*name_ok)(bp)) {
 			had_error++;
 			continue;
+		}
 		cp += n;			/* name */
 		type = _getshort(cp);
  		cp += INT16SZ;			/* type */
 		class = _getshort(cp);
  		cp += INT16SZ + INT32SZ;	/* class, TTL */
 		n = _getshort(cp);
 		cp += INT16SZ;			/* len */
 		if (class != C_IN) {
 			/* XXX - debug? syslog? */
 			cp += n;
 			continue;		/* XXX - had_error++ ? */
+		}
 		if ((qtype == T_A || qtype == T_AAAA || qtype == T_ANY) &&
 		    type == T_CNAME) {
 			n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf);
 			if ((n < 0) || !(*name_ok)(tbuf)) {
 				had_error++;
 				continue;
+			}
 			cp += n;
 			/* Get canonical name. */
 			n = strlen(tbuf) + 1;	/* for the \0 */
 			if (n > ep - bp || n >= MAXHOSTNAMELEN) {
 				had_error++;
 				continue;
+			}
 			strlcpy(bp, tbuf, (size_t)(ep - bp));
 			canonname = bp;
 			bp += n;
 			continue;
+		}
 		if (qtype == T_ANY) {
 			if (!(type == T_A || type == T_AAAA)) {
 				cp += n;
 				continue;
+			}
 		} else if (type != qtype) {
 			if (type != T_KEY && type != T_SIG) {
 				struct syslog_data sd = SYSLOG_DATA_INIT;
 				syslog_r(LOG_NOTICE|LOG_AUTH, &sd,
 	       "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
 				       qname, p_class(C_IN), p_type(qtype),
 				       p_type(type));
+			}
 			cp += n;
 			continue;		/* XXX - had_error++ ? */
+		}
 		switch (type) {
 		case T_A:
 		case T_AAAA:
 			if (strcasecmp(canonname, bp) != 0) {
 				struct syslog_data sd = SYSLOG_DATA_INIT;
 				syslog_r(LOG_NOTICE|LOG_AUTH, &sd,
 				       AskedForGot, canonname, bp);
 				cp += n;
 				continue;	/* XXX - had_error++ ? */
+			}
 			if (type == T_A && n != INADDRSZ) {
 				cp += n;
 				continue;
+			}
 			if (type == T_AAAA && n != IN6ADDRSZ) {
 				cp += n;
 				continue;
+			}
 			if (type == T_AAAA) {
 				struct in6_addr in6;
 				memcpy(&in6, cp, IN6ADDRSZ);
 				if (IN6_IS_ADDR_V4MAPPED(&in6)) {
 					cp += n;
 					continue;
+				}
+			}
 			if (!haveanswer) {
 				int nn;
 				canonname = bp;
 				nn = strlen(bp) + 1;	/* for the \0 */
 				bp += nn;
+			}
 			/* don't overwrite pai */
 			ai = *pai;
 			ai.ai_family = (type == T_A) ? AF_INET : AF_INET6;
 			afd = find_afd(ai.ai_family);
 			if (afd == NULL) {
 				cp += n;
 				continue;
+			}
 			cur->ai_next = get_ai(&ai, afd, (const char *)cp);
 			if (cur->ai_next == NULL)
 				had_error++;
 			while (cur && cur->ai_next)
 				cur = cur->ai_next;
 			cp += n;
 			break;
 		default:
 			abort();
+		}
 		if (!had_error)
 			haveanswer++;
+	}
 	if (haveanswer) {
 		if (!canonname)
 			(void)get_canonname(pai, sentinel.ai_next, qname);
 		else
 			(void)get_canonname(pai, sentinel.ai_next, canonname);
 		h_errno = NETDB_SUCCESS;
 		return sentinel.ai_next;
+	}
 	h_errno = NO_RECOVERY;
 	return NULL;
+}
 #define SORTEDADDR(p)	(((struct sockaddr_in *)(void *)(p->ai_next->ai_addr))->sin_addr.s_addr)
 #define SORTMATCH(p, s) ((SORTEDADDR(p) & (s).mask) == (s).addr.s_addr)
 static void
 aisort(struct addrinfo *s, res_state res)
+{
 	struct addrinfo head, *t, *p;
 	int i;
 	head.ai_next = NULL;
 	t = &head;
 	for (i = 0; i < res->nsort; i++) {
 		p = s;
 		while (p->ai_next) {
 			if ((p->ai_next->ai_family != AF_INET)
 			|| SORTMATCH(p, res->sort_list[i])) {
 				t->ai_next = p->ai_next;
 				t = t->ai_next;
 				p->ai_next = p->ai_next->ai_next;
 			} else {
 				p = p->ai_next;
+			}
+		}
+	}
 	/* add rest of list and reset s to the new list*/
 	t->ai_next = s->ai_next;
 	s->ai_next = head.ai_next;
+}
 /*ARGSUSED*/
 static int
 _dns_getaddrinfo(void *rv, void	*cb_data, va_list ap)
+{
 	struct addrinfo *ai;
 	querybuf *buf, *buf2;
 	const char *name;
 	const struct addrinfo *pai;
 	struct addrinfo sentinel, *cur;
 	struct res_target q, q2;
 	res_state res;
 	name = va_arg(ap, char *);
 	pai = va_arg(ap, const struct addrinfo *);
 	memset(&q, 0, sizeof(q));
 	memset(&q2, 0, sizeof(q2));
 	memset(&sentinel, 0, sizeof(sentinel));
 	cur = &sentinel;
 	buf = malloc(sizeof(*buf));
 	if (buf == NULL) {
 		h_errno = NETDB_INTERNAL;
 		return NS_NOTFOUND;
+	}
 	buf2 = malloc(sizeof(*buf2));
 	if (buf2 == NULL) {
 		free(buf);
 		h_errno = NETDB_INTERNAL;
 		return NS_NOTFOUND;
+	}
 	switch (pai->ai_family) {
 	case AF_UNSPEC:
 		/* prefer IPv6 */
 		q.name = name;
 		q.qclass = C_IN;
 		q.qtype = T_AAAA;
 		q.answer = buf->buf;
 		q.anslen = sizeof(buf->buf);
 		q.next = &q2;
 		q2.name = name;
 		q2.qclass = C_IN;
 		q2.qtype = T_A;
 		q2.answer = buf2->buf;
 		q2.anslen = sizeof(buf2->buf);
 		break;
 	case AF_INET:
 		q.name = name;
 		q.qclass = C_IN;
 		q.qtype = T_A;
 		q.answer = buf->buf;
 		q.anslen = sizeof(buf->buf);
 		break;
 	case AF_INET6:
 		q.name = name;
 		q.qclass = C_IN;
 		q.qtype = T_AAAA;
 		q.answer = buf->buf;
 		q.anslen = sizeof(buf->buf);
 		break;
 	default:
 		free(buf);
 		free(buf2);
 		return NS_UNAVAIL;
+	}
 	res = __res_get_state();
 	if (res == NULL) {
 		free(buf);
 		free(buf2);
 		return NS_NOTFOUND;
+	}
 	if (res_searchN(name, &q, res) < 0) {
 		__res_put_state(res);
 		free(buf);
 		free(buf2);
 		return NS_NOTFOUND;
+	}
 	ai = getanswer(buf, q.n, q.name, q.qtype, pai);
 	if (ai) {
 		cur->ai_next = ai;
 		while (cur && cur->ai_next)
 			cur = cur->ai_next;
+	}
 	if (q.next) {
 		ai = getanswer(buf2, q2.n, q2.name, q2.qtype, pai);
 		if (ai)
 			cur->ai_next = ai;
+	}
 	free(buf);
 	free(buf2);
 	if (sentinel.ai_next == NULL) {
 		__res_put_state(res);
 		switch (h_errno) {
 		case HOST_NOT_FOUND:
 			return NS_NOTFOUND;
 		case TRY_AGAIN:
 			return NS_TRYAGAIN;
 		default:
 			return NS_UNAVAIL;
+		}
+	}
 	if (res->nsort)
 		aisort(&sentinel, res);
 	__res_put_state(res);
 	*((struct addrinfo **)rv) = sentinel.ai_next;
 	return NS_SUCCESS;
+}
 static void
 _sethtent(FILE **hostf)
+{
 	if (!*hostf)
 		*hostf = fopen(_PATH_HOSTS, "r" );
 	else
 		rewind(*hostf);
+}
 static void
 _endhtent(FILE **hostf)
+{
 	if (*hostf) {
 		(void) fclose(*hostf);
 		*hostf = NULL;
+	}
+}
 static struct addrinfo *
 _gethtent(FILE **hostf, const char *name, const struct addrinfo *pai)
+{
 	char *p;
 	char *cp, *tname, *cname;
 	struct addrinfo hints, *res0, *res;
 	int error;
 	const char *addr;
 	char hostbuf[8*1024];
 	_DIAGASSERT(name != NULL);
 	_DIAGASSERT(pai != NULL);
 	if (!*hostf && !(*hostf = fopen(_PATH_HOSTS, "r" )))
 		return (NULL);
  again:
 	if (!(p = fgets(hostbuf, sizeof hostbuf, *hostf)))
 		return (NULL);
 	if (*p == '#')
 		goto again;
 	if (!(cp = strpbrk(p, "#\n")))
 		goto again;
 	*cp = '\0';
 	if (!(cp = strpbrk(p, " \t")))
 		goto again;
 	*cp++ = '\0';
 	addr = p;
 	/* if this is not something we're looking for, skip it. */
 	cname = NULL;
 	while (cp && *cp) {
 		if (*cp == ' ' || *cp == '\t') {
 			cp++;
 			continue;
+		}
 		if (!cname)
 			cname = cp;
 		tname = cp;
 		if ((cp = strpbrk(cp, " \t")) != NULL)
 			*cp++ = '\0';
 		if (strcasecmp(name, tname) == 0)
 			goto found;
+	}
 	goto again;
 found:
 	hints = *pai;
 	hints.ai_flags = AI_NUMERICHOST;
 	error = getaddrinfo(addr, NULL, &hints, &res0);
 	if (error)
 		goto again;
 	for (res = res0; res; res = res->ai_next) {
 		/* cover it up */
 		res->ai_flags = pai->ai_flags;
 		if (pai->ai_flags & AI_CANONNAME) {
 			if (get_canonname(pai, res, cname) != 0) {
 				freeaddrinfo(res0);
 				goto again;
+			}
+		}
+	}
 	return res0;
+}
 /*ARGSUSED*/
 static int
 _files_getaddrinfo(void *rv, void *cb_data, va_list ap)
+{
 	const char *name;
 	const struct addrinfo *pai;
 	struct addrinfo sentinel, *cur;
 	struct addrinfo *p;
 #ifndef _REENTRANT
 	static
 #endif
 	FILE *hostf = NULL;
 	name = va_arg(ap, char *);
 	pai = va_arg(ap, const struct addrinfo *);
 	memset(&sentinel, 0, sizeof(sentinel));
 	cur = &sentinel;
 	_sethtent(&hostf);
 	while ((p = _gethtent(&hostf, name, pai)) != NULL) {
 		cur->ai_next = p;
 		while (cur && cur->ai_next)
 			cur = cur->ai_next;
+	}
 	_endhtent(&hostf);
 	*((struct addrinfo **)rv) = sentinel.ai_next;
 	if (sentinel.ai_next == NULL)
 		return NS_NOTFOUND;
 	return NS_SUCCESS;
+}
 #ifdef YP
 /*ARGSUSED*/
 static struct addrinfo *
 _yphostent(char *line, const struct addrinfo *pai)
+{
 	struct addrinfo sentinel, *cur;
 	struct addrinfo hints, *res, *res0;
 	int error;
 	char *p;
 	const char *addr, *canonname;
 	char *nextline;
 	char *cp;
 	_DIAGASSERT(line != NULL);
 	_DIAGASSERT(pai != NULL);
 	p = line;
 	addr = canonname = NULL;
 	memset(&sentinel, 0, sizeof(sentinel));
 	cur = &sentinel;
 nextline:
 	/* terminate line */
 	cp = strchr(p, '\n');
 	if (cp) {
 		*cp++ = '\0';
 		nextline = cp;
 	} else
 		nextline = NULL;
 	cp = strpbrk(p, " \t");
 	if (cp == NULL) {
 		if (canonname == NULL)
 			return (NULL);
 		else
 			goto done;
+	}
 	*cp++ = '\0';
 	addr = p;
 	while (cp && *cp) {
 		if (*cp == ' ' || *cp == '\t') {
 			cp++;
 			continue;
+		}
 		if (!canonname)
 			canonname = cp;
 		if ((cp = strpbrk(cp, " \t")) != NULL)
 			*cp++ = '\0';
+	}
 	hints = *pai;
 	hints.ai_flags = AI_NUMERICHOST;
 	error = getaddrinfo(addr, NULL, &hints, &res0);
 	if (error == 0) {
 		for (res = res0; res; res = res->ai_next) {
 			/* cover it up */
 			res->ai_flags = pai->ai_flags;
 			if (pai->ai_flags & AI_CANONNAME)
 				(void)get_canonname(pai, res, canonname);
+		}
 	} else
 		res0 = NULL;
 	if (res0) {
 		cur->ai_next = res0;
 		while (cur->ai_next)
 			cur = cur->ai_next;
+	}
 	if (nextline) {
 		p = nextline;
 		goto nextline;
+	}
 done:
 	return sentinel.ai_next;
+}
 /*ARGSUSED*/
 static int
 _yp_getaddrinfo(void *rv, void *cb_data, va_list ap)
+{
 	struct addrinfo sentinel, *cur;
 	struct addrinfo *ai = NULL;
 	char *ypbuf;
 	int ypbuflen, r;
 	const char *name;
 	const struct addrinfo *pai;
 	char *ypdomain;
 	if (_yp_check(&ypdomain) == 0)
 		return NS_UNAVAIL;
 	name = va_arg(ap, char *);
 	pai = va_arg(ap, const struct addrinfo *);
 	memset(&sentinel, 0, sizeof(sentinel));
 	cur = &sentinel;
 	/* hosts.byname is only for IPv4 (Solaris8) */
 	if (pai->ai_family == PF_UNSPEC || pai->ai_family == PF_INET) {
 		r = yp_match(ypdomain, "hosts.byname", name,
 			(int)strlen(name), &ypbuf, &ypbuflen);
 		if (r == 0) {
 			struct addrinfo ai4;
 			ai4 = *pai;
 			ai4.ai_family = AF_INET;
 			ai = _yphostent(ypbuf, &ai4);
 			if (ai) {
 				cur->ai_next = ai;
 				while (cur && cur->ai_next)
 					cur = cur->ai_next;
+			}
+		}
 		free(ypbuf);
+	}
 	/* ipnodes.byname can hold both IPv4/v6 */
 	r = yp_match(ypdomain, "ipnodes.byname", name,
 		(int)strlen(name), &ypbuf, &ypbuflen);
 	if (r == 0) {
 		ai = _yphostent(ypbuf, pai);
 		if (ai)
 			cur->ai_next = ai;
 		free(ypbuf);
+	}
 	if (sentinel.ai_next == NULL) {
 		h_errno = HOST_NOT_FOUND;
 		return NS_NOTFOUND;
+	}
 	*((struct addrinfo **)rv) = sentinel.ai_next;
 	return NS_SUCCESS;
+}
 #endif
 /* resolver logic */
 /*
  * Formulate a normal query, send, and await answer.
  * Returned answer is placed in supplied buffer "answer".
  * Perform preliminary check of answer, returning success only
  * if no error is indicated and the answer count is nonzero.
  * Return the size of the response on success, -1 on error.
  * Error number is left in h_errno.
+ *
  * Caller must parse answer and determine whether it answers the question.
  */
 static int
 res_queryN(const char *name, /* domain name */ struct res_target *target,
     res_state res)
+{
 	u_char buf[MAXPACKET];
 	HEADER *hp;
 	int n;
 	struct res_target *t;
 	int rcode;
 	int ancount;
 	_DIAGASSERT(name != NULL);
 	/* XXX: target may be NULL??? */
 	rcode = NOERROR;
 	ancount = 0;
 	for (t = target; t; t = t->next) {
 		int class, type;
 		u_char *answer;
 		int anslen;
 		hp = (HEADER *)(void *)t->answer;
 		hp->rcode = NOERROR;	/* default */
 		/* make it easier... */
 		class = t->qclass;
 		type = t->qtype;
 		answer = t->answer;
 		anslen = t->anslen;
 #ifdef DEBUG
 		if (res->options & RES_DEBUG)
 			printf(";; res_nquery(%s, %d, %d)\n", name, class, type);
 #endif
 		n = res_nmkquery(res, QUERY, name, class, type, NULL, 0, NULL,
 		    buf, sizeof(buf));
 #ifdef RES_USE_EDNS0
 		if (n > 0 && (res->options & RES_USE_EDNS0) != 0)
 			n = res_nopt(res, n, buf, sizeof(buf), anslen);
 #endif
 		if (n <= 0) {
 #ifdef DEBUG
 			if (res->options & RES_DEBUG)
 				printf(";; res_nquery: mkquery failed\n");
 #endif
 			h_errno = NO_RECOVERY;
 			return n;
+		}
 		n = res_nsend(res, buf, n, answer, anslen);
 #if 0
 		if (n < 0) {
 #ifdef DEBUG
 			if (res->options & RES_DEBUG)
 				printf(";; res_query: send error\n");
 #endif
 			h_errno = TRY_AGAIN;
 			return n;
+		}
 #endif
 		if (n < 0 || hp->rcode != NOERROR || ntohs(hp->ancount) == 0) {
 			rcode = hp->rcode;	/* record most recent error */
 #ifdef DEBUG
 			if (res->options & RES_DEBUG)
 				printf(";; rcode = %u, ancount=%u\n", hp->rcode,
 				    ntohs(hp->ancount));
 #endif
 			continue;
+		}
 		ancount += ntohs(hp->ancount);
 		t->n = n;
+	}
 	if (ancount == 0) {
 		switch (rcode) {
 		case NXDOMAIN:
 			h_errno = HOST_NOT_FOUND;
 			break;
 		case SERVFAIL:
 			h_errno = TRY_AGAIN;
 			break;
 		case NOERROR:
 			h_errno = NO_DATA;
 			break;
 		case FORMERR:
 		case NOTIMP:
 		case REFUSED:
 		default:
 			h_errno = NO_RECOVERY;
 			break;
+		}
 		return -1;
+	}
 	return ancount;
+}
 /*
  * Formulate a normal query, send, and retrieve answer in supplied buffer.
  * Return the size of the response on success, -1 on error.
  * If enabled, implement search rules until answer or unrecoverable failure
  * is detected.  Error code, if any, is left in h_errno.
  */
 static int
 res_searchN(const char *name, struct res_target *target, res_state res)
+{
 	const char *cp, * const *domain;
 	HEADER *hp;
 	u_int dots;
 	int trailing_dot, ret, saved_herrno;
 	int got_nodata = 0, got_servfail = 0, tried_as_is = 0;
 	_DIAGASSERT(name != NULL);
 	_DIAGASSERT(target != NULL);
 	hp = (HEADER *)(void *)target->answer;	/*XXX*/
 	errno = 0;
 	h_errno = HOST_NOT_FOUND;	/* default, if we never query */
 	dots = 0;
 	for (cp = name; *cp; cp++)
 		dots += (*cp == '.');
 	trailing_dot = 0;
 	if (cp > name && *--cp == '.')
 		trailing_dot++;
 	/*
-	 * if there aren't any dots, it could be a user-level alias
+	 * if there aren't any dots, it could be an user-level alias
 	 */
 	if (!dots && (cp = __hostalias(name)) != NULL) {
 		ret = res_queryN(cp, target, res);
 		return ret;
+	}
 	/*
 	 * If there are dots in the name already, let's just give it a try
 	 * 'as is'.  The threshold can be set with the "ndots" option.
 	 */
 	saved_herrno = -1;
 	if (dots >= res->ndots) {
 		ret = res_querydomainN(name, NULL, target, res);
 		if (ret > 0)
 			return (ret);
 		saved_herrno = h_errno;
 		tried_as_is++;
+	}
 	/*
 	 * We do at least one level of search if
 	 *	- there is no dot and RES_DEFNAME is set, or
 	 *	- there is at least one dot, there is no trailing dot,
 	 *	  and RES_DNSRCH is set.
 	 */
 	if ((!dots && (res->options & RES_DEFNAMES)) ||
 	    (dots && !trailing_dot && (res->options & RES_DNSRCH))) {
 		int done = 0;
 		for (domain = (const char * const *)res->dnsrch;
 		   *domain && !done;
 		   domain++) {
 			ret = res_querydomainN(name, *domain, target, res);
 			if (ret > 0)
 				return ret;
 			/*
 			 * If no server present, give up.
 			 * If name isn't found in this domain,
 			 * keep trying higher domains in the search list
 			 * (if that's enabled).
 			 * On a NO_DATA error, keep trying, otherwise
 			 * a wildcard entry of another type could keep us
 			 * from finding this entry higher in the domain.
 			 * If we get some other error (negative answer or
 			 * server failure), then stop searching up,
 			 * but try the input name below in case it's
 			 * fully-qualified.
 			 */
 			if (errno == ECONNREFUSED) {
 				h_errno = TRY_AGAIN;
 				return -1;
+			}
 			switch (h_errno) {
 			case NO_DATA:
 				got_nodata++;
 				/* FALLTHROUGH */
 			case HOST_NOT_FOUND:
 				/* keep trying */
 				break;
 			case TRY_AGAIN:
 				if (hp->rcode == SERVFAIL) {
 					/* try next search element, if any */
 					got_servfail++;
 					break;
+				}
 				/* FALLTHROUGH */
 			default:
 				/* anything else implies that we're done */
 				done++;
+			}
 			/*
 			 * if we got here for some reason other than DNSRCH,
 			 * we only wanted one iteration of the loop, so stop.
 			 */
 			if (!(res->options & RES_DNSRCH))
 			        done++;
+		}
+	}
 	/*
 	 * if we have not already tried the name "as is", do that now.
 	 * note that we do this regardless of how many dots were in the
 	 * name or whether it ends with a dot.
 	 */
 	if (!tried_as_is) {
 		ret = res_querydomainN(name, NULL, target, res);
 		if (ret > 0)
 			return ret;
+	}
 	/*
 	 * if we got here, we didn't satisfy the search.
 	 * if we did an initial full query, return that query's h_errno
 	 * (note that we wouldn't be here if that query had succeeded).
 	 * else if we ever got a nodata, send that back as the reason.
 	 * else send back meaningless h_errno, that being the one from
 	 * the last DNSRCH we did.
 	 */
 	if (saved_herrno != -1)
 		h_errno = saved_herrno;
 	else if (got_nodata)
 		h_errno = NO_DATA;
 	else if (got_servfail)
 		h_errno = TRY_AGAIN;
 	return -1;
+}
 /*
  * Perform a call on res_query on the concatenation of name and domain,
  * removing a trailing dot from name if domain is NULL.
  */
 static int
 res_querydomainN(const char *name, const char *domain,
     struct res_target *target, res_state res)
+{
 	char nbuf[MAXDNAME];
 	const char *longname = nbuf;
 	size_t n, d;
 	_DIAGASSERT(name != NULL);
 	/* XXX: target may be NULL??? */
 #ifdef DEBUG
 	if (res->options & RES_DEBUG)
 		printf(";; res_querydomain(%s, %s)\n",
 			name, domain?domain:"<Nil>");
 #endif
 	if (domain == NULL) {
 		/*
 		 * Check for trailing '.';
 		 * copy without '.' if present.
 		 */
 		n = strlen(name);
 		if (n + 1 > sizeof(nbuf)) {
 			h_errno = NO_RECOVERY;
 			return -1;
+		}
 		if (n > 0 && name[--n] == '.') {
 			strncpy(nbuf, name, n);
 			nbuf[n] = '\0';
 		} else
 			longname = name;
 	} else {
 		n = strlen(name);
 		d = strlen(domain);
 		if (n + 1 + d + 1 > sizeof(nbuf)) {
 			h_errno = NO_RECOVERY;
 			return -1;
+		}
 		snprintf(nbuf, sizeof(nbuf), "%s.%s", name, domain);
+	}
 	return res_queryN(longname, target, res);
+}

 @@ -1,1441 +1,1441 @@
-/*	$NetBSD: gethnamaddr.c,v 1.73 2007/01/27 22:27:35 christos Exp $	*/
+/*	$NetBSD: gethnamaddr.c,v 1.74 2009/10/02 06:49:23 cegger Exp $	*/
 /*
  * ++Copyright++ 1985, 1988, 1993
  * -
  * Copyright (c) 1985, 1988, 1993
  *    The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * -
  * Portions Copyright (c) 1993 by Digital Equipment Corporation.
+ *
  * 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, and that
  * the name of Digital Equipment Corporation not be used in advertising or
  * publicity pertaining to distribution of the document or software without
  * specific, written prior permission.
+ *
  * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
  * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS.   IN NO EVENT SHALL DIGITAL EQUIPMENT
  * CORPORATION 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.
  * -
  * --Copyright--
  */
 #include <sys/cdefs.h>
 #if defined(LIBC_SCCS) && !defined(lint)
 #if 0
 static char sccsid[] = "@(#)gethostnamadr.c	8.1 (Berkeley) 6/4/93";
 static char rcsid[] = "Id: gethnamaddr.c,v 8.21 1997/06/01 20:34:37 vixie Exp ";
 #else
-__RCSID("$NetBSD: gethnamaddr.c,v 1.73 2007/01/27 22:27:35 christos Exp $");
+__RCSID("$NetBSD: gethnamaddr.c,v 1.74 2009/10/02 06:49:23 cegger Exp $");
 #endif
 #endif /* LIBC_SCCS and not lint */
 #if defined(_LIBC)
 #include "namespace.h"
 #endif
 #include <sys/param.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <arpa/nameser.h>
 #include <assert.h>
 #include <ctype.h>
 #include <errno.h>
 #include <netdb.h>
 #include <resolv.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <syslog.h>
 #ifndef LOG_AUTH
 # define LOG_AUTH 0
 #endif
 #define MULTI_PTRS_ARE_ALIASES 1	/* XXX - experimental */
 #include <nsswitch.h>
 #include <stdlib.h>
 #include <string.h>
 #ifdef YP
 #include <rpc/rpc.h>
 #include <rpcsvc/yp_prot.h>
 #include <rpcsvc/ypclnt.h>
 #endif
 #if defined(_LIBC) && defined(__weak_alias)
 __weak_alias(gethostbyaddr,_gethostbyaddr)
 __weak_alias(gethostbyname,_gethostbyname)
 __weak_alias(gethostent,_gethostent)
 #endif
 #define	MAXALIASES	35
 #define	MAXADDRS	35
 static const char AskedForGot[] =
 			  "gethostby*.getanswer: asked for \"%s\", got \"%s\"";
 static char *h_addr_ptrs[MAXADDRS + 1];
 #ifdef YP
 static char *__ypdomain;
 #endif
 static struct hostent host;
 static char *host_aliases[MAXALIASES];
 static char hostbuf[8*1024];
 static u_int32_t host_addr[16 / sizeof(u_int32_t)];	/* IPv4 or IPv6 */
 static FILE *hostf = NULL;
 static int stayopen = 0;
 #define	MAXPACKET	(64*1024)
 typedef union {
     HEADER hdr;
     u_char buf[MAXPACKET];
 } querybuf;
 typedef union {
     int32_t al;
     char ac;
 } align;
 #ifdef DEBUG
 static void dprintf(const char *, res_state, ...)
 	__attribute__((__format__(__printf__, 1, 3)));
 #endif
 static struct hostent *getanswer(const querybuf *, int, const char *, int,
     res_state);
 static void map_v4v6_address(const char *, char *);
 static void map_v4v6_hostent(struct hostent *, char **, char *);
 static void addrsort(char **, int, res_state);
 void _sethtent(int);
 void _endhtent(void);
 struct hostent *_gethtent(void);
 void ht_sethostent(int);
 void ht_endhostent(void);
 struct hostent *ht_gethostbyname(char *);
 struct hostent *ht_gethostbyaddr(const char *, int, int);
 void dns_service(void);
 #undef dn_skipname
 int dn_skipname(const u_char *, const u_char *);
 int _gethtbyaddr(void *, void *, va_list);
 int _gethtbyname(void *, void *, va_list);
 struct hostent *_gethtbyname2(const char *, int);
 int _dns_gethtbyaddr(void *, void *, va_list);
 int _dns_gethtbyname(void *, void *, va_list);
 #ifdef YP
 struct hostent *_yphostent(char *, int);
 int _yp_gethtbyaddr(void *, void *, va_list);
 int _yp_gethtbyname(void *, void *, va_list);
 #endif
 static struct hostent *gethostbyname_internal(const char *, int, res_state);
 static const ns_src default_dns_files[] = {
 	{ NSSRC_FILES, 	NS_SUCCESS },
 	{ NSSRC_DNS, 	NS_SUCCESS },
 	{ 0, 0 }
 };
 #ifdef DEBUG
 static void
 dprintf(const char *msg, res_state res, ...)
+{
 	_DIAGASSERT(msg != NULL);
 	if (res->options & RES_DEBUG) {
 		int save = errno;
 		va_list ap;
 		va_start (ap, res);
 		vprintf(msg, ap);
 		va_end (ap);
 		errno = save;
+	}
+}
 #else
 # define dprintf(msg, res, num) /*nada*/
 #endif
 #define BOUNDED_INCR(x) \
 	do { \
 		cp += (x); \
 		if (cp > eom) { \
 			h_errno = NO_RECOVERY; \
 			return NULL; \
 		} \
 	} while (/*CONSTCOND*/0)
 #define BOUNDS_CHECK(ptr, count) \
 	do { \
 		if ((ptr) + (count) > eom) { \
 			h_errno = NO_RECOVERY; \
 			return NULL; \
 		} \
 	} while (/*CONSTCOND*/0)
 static struct hostent *
 getanswer(const querybuf *answer, int anslen, const char *qname, int qtype,
     res_state res)
+{
 	const HEADER *hp;
 	const u_char *cp;
 	int n;
 	const u_char *eom, *erdata;
 	char *bp, **ap, **hap, *ep;
 	int type, class, ancount, qdcount;
 	int haveanswer, had_error;
 	int toobig = 0;
 	char tbuf[MAXDNAME];
 	const char *tname;
 	int (*name_ok)(const char *);
 	_DIAGASSERT(answer != NULL);
 	_DIAGASSERT(qname != NULL);
 	tname = qname;
 	host.h_name = NULL;
 	eom = answer->buf + anslen;
 	switch (qtype) {
 	case T_A:
 	case T_AAAA:
 		name_ok = res_hnok;
 		break;
 	case T_PTR:
 		name_ok = res_dnok;
 		break;
 	default:
 		return NULL;	/* XXX should be abort(); */
+	}
 	/*
 	 * find first satisfactory answer
 	 */
 	hp = &answer->hdr;
 	ancount = ntohs(hp->ancount);
 	qdcount = ntohs(hp->qdcount);
 	bp = hostbuf;
 	ep = hostbuf + sizeof hostbuf;
 	cp = answer->buf;
 	BOUNDED_INCR(HFIXEDSZ);
 	if (qdcount != 1) {
 		h_errno = NO_RECOVERY;
 		return NULL;
+	}
 	n = dn_expand(answer->buf, eom, cp, bp, ep - bp);
 	if ((n < 0) || !(*name_ok)(bp)) {
 		h_errno = NO_RECOVERY;
 		return NULL;
+	}
 	BOUNDED_INCR(n + QFIXEDSZ);
 	if (qtype == T_A || qtype == T_AAAA) {
 		/* res_send() has already verified that the query name is the
 		 * same as the one we sent; this just gets the expanded name
 		 * (i.e., with the succeeding search-domain tacked on).
 		 */
 		n = strlen(bp) + 1;		/* for the \0 */
 		if (n >= MAXHOSTNAMELEN) {
 			h_errno = NO_RECOVERY;
 			return NULL;
+		}
 		host.h_name = bp;
 		bp += n;
 		/* The qname can be abbreviated, but h_name is now absolute. */
 		qname = host.h_name;
+	}
 	ap = host_aliases;
 	*ap = NULL;
 	host.h_aliases = host_aliases;
 	hap = h_addr_ptrs;
 	*hap = NULL;
 	host.h_addr_list = h_addr_ptrs;
 	haveanswer = 0;
 	had_error = 0;
 	while (ancount-- > 0 && cp < eom && !had_error) {
 		n = dn_expand(answer->buf, eom, cp, bp, ep - bp);
 		if ((n < 0) || !(*name_ok)(bp)) {
 			had_error++;
 			continue;
+		}
 		cp += n;			/* name */
 		BOUNDS_CHECK(cp, 3 * INT16SZ + INT32SZ);
 		type = _getshort(cp);
  		cp += INT16SZ;			/* type */
 		class = _getshort(cp);
  		cp += INT16SZ + INT32SZ;	/* class, TTL */
 		n = _getshort(cp);
 		cp += INT16SZ;			/* len */
 		BOUNDS_CHECK(cp, n);
 		erdata = cp + n;
 		if (class != C_IN) {
 			/* XXX - debug? syslog? */
 			cp += n;
 			continue;		/* XXX - had_error++ ? */
+		}
 		if ((qtype == T_A || qtype == T_AAAA) && type == T_CNAME) {
 			if (ap >= &host_aliases[MAXALIASES-1])
 				continue;
 			n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf);
 			if ((n < 0) || !(*name_ok)(tbuf)) {
 				had_error++;
 				continue;
+			}
 			cp += n;
 			if (cp != erdata) {
 				h_errno = NO_RECOVERY;
 				return NULL;
+			}
 			/* Store alias. */
 			*ap++ = bp;
 			n = strlen(bp) + 1;	/* for the \0 */
 			if (n >= MAXHOSTNAMELEN) {
 				had_error++;
 				continue;
+			}
 			bp += n;
 			/* Get canonical name. */
 			n = strlen(tbuf) + 1;	/* for the \0 */
 			if (n > ep - bp || n >= MAXHOSTNAMELEN) {
 				had_error++;
 				continue;
+			}
 			strlcpy(bp, tbuf, (size_t)(ep - bp));
 			host.h_name = bp;
 			bp += n;
 			continue;
+		}
 		if (qtype == T_PTR && type == T_CNAME) {
 			n = dn_expand(answer->buf, eom, cp, tbuf, sizeof tbuf);
 			if (n < 0 || !res_dnok(tbuf)) {
 				had_error++;
 				continue;
+			}
 			cp += n;
 			if (cp != erdata) {
 				h_errno = NO_RECOVERY;
 				return NULL;
+			}
 			/* Get canonical name. */
 			n = strlen(tbuf) + 1;	/* for the \0 */
 			if (n > ep - bp || n >= MAXHOSTNAMELEN) {
 				had_error++;
 				continue;
+			}
 			strlcpy(bp, tbuf, (size_t)(ep - bp));
 			tname = bp;
 			bp += n;
 			continue;
+		}
 		if (type != qtype) {
 			if (type != T_KEY && type != T_SIG)
 				syslog(LOG_NOTICE|LOG_AUTH,
 	       "gethostby*.getanswer: asked for \"%s %s %s\", got type \"%s\"",
 				       qname, p_class(C_IN), p_type(qtype),
 				       p_type(type));
 			cp += n;
 			continue;		/* XXX - had_error++ ? */
+		}
 		switch (type) {
 		case T_PTR:
 			if (strcasecmp(tname, bp) != 0) {
 				syslog(LOG_NOTICE|LOG_AUTH,
 				       AskedForGot, qname, bp);
 				cp += n;
 				continue;	/* XXX - had_error++ ? */
+			}
 			n = dn_expand(answer->buf, eom, cp, bp, ep - bp);
 			if ((n < 0) || !res_hnok(bp)) {
 				had_error++;
 				break;
+			}
 #if MULTI_PTRS_ARE_ALIASES
 			cp += n;
 			if (cp != erdata) {
 				h_errno = NO_RECOVERY;
 				return NULL;
+			}
 			if (!haveanswer)
 				host.h_name = bp;
 			else if (ap < &host_aliases[MAXALIASES-1])
 				*ap++ = bp;
 			else
 				n = -1;
 			if (n != -1) {
 				n = strlen(bp) + 1;	/* for the \0 */
 				if (n >= MAXHOSTNAMELEN) {
 					had_error++;
 					break;
+				}
 				bp += n;
+			}
 			break;
 #else
 			host.h_name = bp;
 			if (res->options & RES_USE_INET6) {
 				n = strlen(bp) + 1;	/* for the \0 */
 				if (n >= MAXHOSTNAMELEN) {
 					had_error++;
 					break;
+				}
 				bp += n;
 				map_v4v6_hostent(&host, &bp, ep);
+			}
 			h_errno = NETDB_SUCCESS;
 			return &host;
 #endif
 		case T_A:
 		case T_AAAA:
 			if (strcasecmp(host.h_name, bp) != 0) {
 				syslog(LOG_NOTICE|LOG_AUTH,
 				       AskedForGot, host.h_name, bp);
 				cp += n;
 				continue;	/* XXX - had_error++ ? */
+			}
 			if (n != host.h_length) {
 				cp += n;
 				continue;
+			}
 			if (type == T_AAAA) {
 				struct in6_addr in6;
 				memcpy(&in6, cp, IN6ADDRSZ);
 				if (IN6_IS_ADDR_V4MAPPED(&in6)) {
 					cp += n;
 					continue;
+				}
+			}
 			if (!haveanswer) {
 				int nn;
 				host.h_name = bp;
 				nn = strlen(bp) + 1;	/* for the \0 */
 				bp += nn;
+			}
 			bp += sizeof(align) -
 			    (size_t)((u_long)bp % sizeof(align));
 			if (bp + n >= &hostbuf[sizeof hostbuf]) {
 				dprintf("size (%d) too big\n", res, n);
 				had_error++;
 				continue;
+			}
 			if (hap >= &h_addr_ptrs[MAXADDRS-1]) {
 				if (!toobig++) {
 					dprintf("Too many addresses (%d)\n",
 						res, MAXADDRS);
+				}
 				cp += n;
 				continue;
+			}
 			(void)memcpy(*hap++ = bp, cp, (size_t)n);
 			bp += n;
 			cp += n;
 			if (cp != erdata) {
 				h_errno = NO_RECOVERY;
 				return NULL;
+			}
 			break;
 		default:
 			abort();
+		}
 		if (!had_error)
 			haveanswer++;
+	}
 	if (haveanswer) {
 		*ap = NULL;
 		*hap = NULL;
 		/*
 		 * Note: we sort even if host can take only one address
 		 * in its return structures - should give it the "best"
 		 * address in that case, not some random one
 		 */
 		if (res->nsort && haveanswer > 1 && qtype == T_A)
 			addrsort(h_addr_ptrs, haveanswer, res);
 		if (!host.h_name) {
 			n = strlen(qname) + 1;	/* for the \0 */
 			if (n > ep - bp || n >= MAXHOSTNAMELEN)
 				goto no_recovery;
 			strlcpy(bp, qname, (size_t)(ep - bp));
 			host.h_name = bp;
 			bp += n;
+		}
 		if (res->options & RES_USE_INET6)
 			map_v4v6_hostent(&host, &bp, ep);
 		h_errno = NETDB_SUCCESS;
 		return &host;
+	}
  no_recovery:
 	h_errno = NO_RECOVERY;
 	return NULL;
+}
 struct hostent *
 gethostbyname(const char *name)
+{
 	struct hostent *hp;
 	res_state res = __res_get_state();
 	if (res == NULL)
 		return NULL;
 	_DIAGASSERT(name != NULL);
 	if (res->options & RES_USE_INET6) {
 		hp = gethostbyname_internal(name, AF_INET6, res);
 		if (hp) {
 			__res_put_state(res);
 			return hp;
+		}
+	}
 	hp = gethostbyname_internal(name, AF_INET, res);
 	__res_put_state(res);
 	return hp;
+}
 struct hostent *
 gethostbyname2(const char *name, int af)
+{
 	struct hostent *hp;
 	res_state res = __res_get_state();
 	if (res == NULL)
 		return NULL;
 	hp = gethostbyname_internal(name, af, res);
 	__res_put_state(res);
 	return hp;
+}
 static struct hostent *
 gethostbyname_internal(const char *name, int af, res_state res)
+{
 	const char *cp;
 	char *bp, *ep;
 	int size;
 	struct hostent *hp;
 	static const ns_dtab dtab[] = {
 		NS_FILES_CB(_gethtbyname, NULL)
 		{ NSSRC_DNS, _dns_gethtbyname, NULL },	/* force -DHESIOD */
 		NS_NIS_CB(_yp_gethtbyname, NULL)
 		NS_NULL_CB
 	};
 	_DIAGASSERT(name != NULL);
 	switch (af) {
 	case AF_INET:
 		size = INADDRSZ;
 		break;
 	case AF_INET6:
 		size = IN6ADDRSZ;
 		break;
 	default:
 		h_errno = NETDB_INTERNAL;
 		errno = EAFNOSUPPORT;
 		return NULL;
+	}
 	host.h_addrtype = af;
 	host.h_length = size;
 	/*
-	 * if there aren't any dots, it could be a user-level alias.
+	 * if there aren't any dots, it could be an user-level alias.
 	 * this is also done in res_nquery() since we are not the only
 	 * function that looks up host names.
 	 */
 	if (!strchr(name, '.') && (cp = __hostalias(name)))
 		name = cp;
 	/*
 	 * disallow names consisting only of digits/dots, unless
 	 * they end in a dot.
 	 */
 	if (isdigit((u_char) name[0]))
 		for (cp = name;; ++cp) {
 			if (!*cp) {
 				if (*--cp == '.')
 					break;
 				/*
 				 * All-numeric, no dot at the end.
 				 * Fake up a hostent as if we'd actually
 				 * done a lookup.
 				 */
 				if (inet_pton(af, name,
 				    (char *)(void *)host_addr) <= 0) {
 					h_errno = HOST_NOT_FOUND;
 					return NULL;
+				}
 				strncpy(hostbuf, name, MAXDNAME);
 				hostbuf[MAXDNAME] = '\0';
 				bp = hostbuf + MAXDNAME;
 				ep = hostbuf + sizeof hostbuf;
 				host.h_name = hostbuf;
 				host.h_aliases = host_aliases;
 				host_aliases[0] = NULL;
 				h_addr_ptrs[0] = (char *)(void *)host_addr;
 				h_addr_ptrs[1] = NULL;
 				host.h_addr_list = h_addr_ptrs;
 				if (res->options & RES_USE_INET6)
 					map_v4v6_hostent(&host, &bp, ep);
 				h_errno = NETDB_SUCCESS;
 				return &host;
+			}
 			if (!isdigit((u_char) *cp) && *cp != '.')
 				break;
+		}
 	if ((isxdigit((u_char) name[0]) && strchr(name, ':') != NULL) ||
 	    name[0] == ':')
 		for (cp = name;; ++cp) {
 			if (!*cp) {
 				if (*--cp == '.')
 					break;
 				/*
 				 * All-IPv6-legal, no dot at the end.
 				 * Fake up a hostent as if we'd actually
 				 * done a lookup.
 				 */
 				if (inet_pton(af, name,
 				    (char *)(void *)host_addr) <= 0) {
 					h_errno = HOST_NOT_FOUND;
 					return NULL;
+				}
 				strncpy(hostbuf, name, MAXDNAME);
 				hostbuf[MAXDNAME] = '\0';
 				bp = hostbuf + MAXDNAME;
 				ep = hostbuf + sizeof hostbuf;
 				host.h_name = hostbuf;
 				host.h_aliases = host_aliases;
 				host_aliases[0] = NULL;
 				h_addr_ptrs[0] = (char *)(void *)host_addr;
 				h_addr_ptrs[1] = NULL;
 				host.h_addr_list = h_addr_ptrs;
 				h_errno = NETDB_SUCCESS;
 				return &host;
+			}
 			if (!isxdigit((u_char) *cp) && *cp != ':' && *cp != '.')
 				break;
+		}
 	hp = NULL;
 	h_errno = NETDB_INTERNAL;
 	if (nsdispatch(&hp, dtab, NSDB_HOSTS, "gethostbyname",
 	    default_dns_files, name, strlen(name), af) != NS_SUCCESS)
 		return NULL;
 	h_errno = NETDB_SUCCESS;
 	return hp;
+}
 struct hostent *
 gethostbyaddr(const char *addr,	/* XXX should have been def'd as u_char! */
     socklen_t len, int af)
+{
 	const u_char *uaddr = (const u_char *)addr;
 	socklen_t size;
 	struct hostent *hp;
 	static const ns_dtab dtab[] = {
 		NS_FILES_CB(_gethtbyaddr, NULL)
 		{ NSSRC_DNS, _dns_gethtbyaddr, NULL },	/* force -DHESIOD */
 		NS_NIS_CB(_yp_gethtbyaddr, NULL)
 		NS_NULL_CB
 	};
 	_DIAGASSERT(addr != NULL);
 	if (af == AF_INET6 && len == IN6ADDRSZ &&
 	    (IN6_IS_ADDR_LINKLOCAL((const struct in6_addr *)(const void *)uaddr) ||
 	     IN6_IS_ADDR_SITELOCAL((const struct in6_addr *)(const void *)uaddr))) {
 		h_errno = HOST_NOT_FOUND;
 		return NULL;
+	}
 	if (af == AF_INET6 && len == IN6ADDRSZ &&
 	    (IN6_IS_ADDR_V4MAPPED((const struct in6_addr *)(const void *)uaddr) ||
 	     IN6_IS_ADDR_V4COMPAT((const struct in6_addr *)(const void *)uaddr))) {
 		/* Unmap. */
 		addr += IN6ADDRSZ - INADDRSZ;
 		uaddr += IN6ADDRSZ - INADDRSZ;
 		af = AF_INET;
 		len = INADDRSZ;
+	}
 	switch (af) {
 	case AF_INET:
 		size = INADDRSZ;
 		break;
 	case AF_INET6:
 		size = IN6ADDRSZ;
 		break;
 	default:
 		errno = EAFNOSUPPORT;
 		h_errno = NETDB_INTERNAL;
 		return NULL;
+	}
 	if (size != len) {
 		errno = EINVAL;
 		h_errno = NETDB_INTERNAL;
 		return NULL;
+	}
 	hp = NULL;
 	h_errno = NETDB_INTERNAL;
 	if (nsdispatch(&hp, dtab, NSDB_HOSTS, "gethostbyaddr",
 	    default_dns_files, uaddr, len, af) != NS_SUCCESS)
 		return NULL;
 	h_errno = NETDB_SUCCESS;
 	return hp;
+}
 void
 _sethtent(int f)
+{
 	if (!hostf)
 		hostf = fopen(_PATH_HOSTS, "r" );
 	else
 		rewind(hostf);
 	stayopen = f;
+}
 void
 _endhtent(void)
+{
 	if (hostf && !stayopen) {
 		(void) fclose(hostf);
 		hostf = NULL;
+	}
+}
 struct hostent *
 _gethtent(void)
+{
 	char *p;
 	char *cp, **q;
 	int af, len;
 	if (!hostf && !(hostf = fopen(_PATH_HOSTS, "r" ))) {
 		h_errno = NETDB_INTERNAL;
 		return NULL;
+	}
  again:
 	if (!(p = fgets(hostbuf, sizeof hostbuf, hostf))) {
 		h_errno = HOST_NOT_FOUND;
 		return NULL;
+	}
 	if (*p == '#')
 		goto again;
 	if (!(cp = strpbrk(p, "#\n")))
 		goto again;
 	*cp = '\0';
 	if (!(cp = strpbrk(p, " \t")))
 		goto again;
 	*cp++ = '\0';
 	if (inet_pton(AF_INET6, p, (char *)(void *)host_addr) > 0) {
 		af = AF_INET6;
 		len = IN6ADDRSZ;
 	} else if (inet_pton(AF_INET, p, (char *)(void *)host_addr) > 0) {
 		res_state res = __res_get_state();
 		if (res == NULL)
 			return NULL;
 		if (res->options & RES_USE_INET6) {
 			map_v4v6_address((char *)(void *)host_addr,
 			    (char *)(void *)host_addr);
 			af = AF_INET6;
 			len = IN6ADDRSZ;
 		} else {
 			af = AF_INET;
 			len = INADDRSZ;
+		}
 		__res_put_state(res);
 	} else {
 		goto again;
+	}
 	/* if this is not something we're looking for, skip it. */
 	if (host.h_addrtype != 0 && host.h_addrtype != af)
 		goto again;
 	if (host.h_length != 0 && host.h_length != len)
 		goto again;
 	h_addr_ptrs[0] = (char *)(void *)host_addr;
 	h_addr_ptrs[1] = NULL;
 	host.h_addr_list = h_addr_ptrs;
 	host.h_length = len;
 	host.h_addrtype = af;
 	while (*cp == ' ' || *cp == '\t')
 		cp++;
 	host.h_name = cp;
 	q = host.h_aliases = host_aliases;
 	if ((cp = strpbrk(cp, " \t")) != NULL)
 		*cp++ = '\0';
 	while (cp && *cp) {
 		if (*cp == ' ' || *cp == '\t') {
 			cp++;
 			continue;
+		}
 		if (q < &host_aliases[MAXALIASES - 1])
 			*q++ = cp;
 		if ((cp = strpbrk(cp, " \t")) != NULL)
 			*cp++ = '\0';
+	}
 	*q = NULL;
 	h_errno = NETDB_SUCCESS;
 	return &host;
+}
 /*ARGSUSED*/
 int
 _gethtbyname(void *rv, void *cb_data, va_list ap)
+{
 	struct hostent *hp;
 	const char *name;
 	int af;
 	_DIAGASSERT(rv != NULL);
 	name = va_arg(ap, char *);
 	/* NOSTRICT skip len */(void)va_arg(ap, int);
 	af = va_arg(ap, int);
 	hp = NULL;
 #if 0
+	{
 		res_state res = __res_get_state();
 		if (res == NULL)
 			return NS_NOTFOUND;
 		if (res->options & RES_USE_INET6)
 			hp = _gethtbyname2(name, AF_INET6);
 		if (hp==NULL)
 			hp = _gethtbyname2(name, AF_INET);
 		__res_put_state(res);
+	}
 #else
 	hp = _gethtbyname2(name, af);
 #endif
 	*((struct hostent **)rv) = hp;
 	if (hp == NULL) {
 		h_errno = HOST_NOT_FOUND;
 		return NS_NOTFOUND;
+	}
 	return NS_SUCCESS;
+}
 struct hostent *
 _gethtbyname2(const char *name, int af)
+{
 	struct hostent *p;
 	char *tmpbuf, *ptr, **cp;
 	int num;
 	size_t len;
 	_DIAGASSERT(name != NULL);
 	_sethtent(stayopen);
 	ptr = tmpbuf = NULL;
 	num = 0;
 	while ((p = _gethtent()) != NULL && num < MAXADDRS) {
 		if (p->h_addrtype != af)
 			continue;
 		if (strcasecmp(p->h_name, name) != 0) {
 			for (cp = p->h_aliases; *cp != NULL; cp++)
 				if (strcasecmp(*cp, name) == 0)
 					break;
 			if (*cp == NULL) continue;
+		}
 		if (num == 0) {
 			size_t bufsize;
 			char *src;
 			bufsize = strlen(p->h_name) + 2 +
 				  MAXADDRS * p->h_length +
 				  ALIGNBYTES;
 			for (cp = p->h_aliases; *cp != NULL; cp++)
 				bufsize += strlen(*cp) + 1;
 			if ((tmpbuf = malloc(bufsize)) == NULL) {
 				h_errno = NETDB_INTERNAL;
 				return NULL;
+			}
 			ptr = tmpbuf;
 			src = p->h_name;
 			while ((*ptr++ = *src++) != '\0');
 			for (cp = p->h_aliases; *cp != NULL; cp++) {
 				src = *cp;
 				while ((*ptr++ = *src++) != '\0');
+			}
 			*ptr++ = '\0';
 			ptr = (char *)(void *)ALIGN(ptr);
+		}
 		(void)memcpy(ptr, p->h_addr_list[0], (size_t)p->h_length);
 		ptr += p->h_length;
 		num++;
+	}
 	_endhtent();
 	if (num == 0) return NULL;
 	len = ptr - tmpbuf;
 	if (len > (sizeof(hostbuf) - ALIGNBYTES)) {
 		free(tmpbuf);
 		errno = ENOSPC;
 		h_errno = NETDB_INTERNAL;
 		return NULL;
+	}
 	ptr = memcpy((void *)ALIGN(hostbuf), tmpbuf, len);
 	free(tmpbuf);
 	host.h_name = ptr;
 	while (*ptr++);
 	cp = host_aliases;
 	while (*ptr) {
 		*cp++ = ptr;
 		while (*ptr++);
+	}
 	ptr++;
 	*cp = NULL;
 	ptr = (char *)(void *)ALIGN(ptr);
 	cp = h_addr_ptrs;
 	while (num--) {
 		*cp++ = ptr;
 		ptr += host.h_length;
+	}
 	*cp = NULL;
 	return &host;
+}
 /*ARGSUSED*/
 int
 _gethtbyaddr(void *rv, void *cb_data, va_list ap)
+{
 	struct hostent *p;
 	const unsigned char *addr;
 	int len, af;
 	_DIAGASSERT(rv != NULL);
 	addr = va_arg(ap, unsigned char *);
 	len = va_arg(ap, int);
 	af = va_arg(ap, int);
 	host.h_length = len;
 	host.h_addrtype = af;
 	_sethtent(stayopen);
 	while ((p = _gethtent()) != NULL)
 		if (p->h_addrtype == af && !memcmp(p->h_addr, addr,
 		    (size_t)len))
 			break;
 	_endhtent();
 	*((struct hostent **)rv) = p;
 	if (p==NULL) {
 		h_errno = HOST_NOT_FOUND;
 		return NS_NOTFOUND;
+	}
 	return NS_SUCCESS;
+}
 static void
 map_v4v6_address(const char *src, char *dst)
+{
 	u_char *p = (u_char *)dst;
 	char tmp[INADDRSZ];
 	int i;
 	_DIAGASSERT(src != NULL);
 	_DIAGASSERT(dst != NULL);
 	/* Stash a temporary copy so our caller can update in place. */
 	(void)memcpy(tmp, src, INADDRSZ);
 	/* Mark this ipv6 addr as a mapped ipv4. */
 	for (i = 0; i < 10; i++)
 		*p++ = 0x00;
 	*p++ = 0xff;
 	*p++ = 0xff;
 	/* Retrieve the saved copy and we're done. */
 	(void)memcpy((void *)p, tmp, INADDRSZ);
+}
 static void
 map_v4v6_hostent(struct hostent *hp, char **bpp, char *ep)
+{
 	char **ap;
 	_DIAGASSERT(hp != NULL);
 	_DIAGASSERT(bpp != NULL);
 	_DIAGASSERT(ep != NULL);
 	if (hp->h_addrtype != AF_INET || hp->h_length != INADDRSZ)
 		return;
 	hp->h_addrtype = AF_INET6;
 	hp->h_length = IN6ADDRSZ;
 	for (ap = hp->h_addr_list; *ap; ap++) {
 		int i = sizeof(align) - (size_t)((u_long)*bpp % sizeof(align));
 		if (ep - *bpp < (i + IN6ADDRSZ)) {
 			/* Out of memory.  Truncate address list here.  XXX */
 			*ap = NULL;
 			return;
+		}
 		*bpp += i;
 		map_v4v6_address(*ap, *bpp);
 		*ap = *bpp;
 		*bpp += IN6ADDRSZ;
+	}
+}
 static void
 addrsort(char **ap, int num, res_state res)
+{
 	int i, j;
 	char **p;
 	short aval[MAXADDRS];
 	int needsort = 0;
 	_DIAGASSERT(ap != NULL);
 	p = ap;
 	for (i = 0; i < num; i++, p++) {
 	    for (j = 0 ; (unsigned)j < res->nsort; j++)
 		if (res->sort_list[j].addr.s_addr ==
 		    (((struct in_addr *)(void *)(*p))->s_addr &
 		    res->sort_list[j].mask))
 			break;
 	    aval[i] = j;
 	    if (needsort == 0 && i > 0 && j < aval[i-1])
 		needsort = i;
+	}
 	if (!needsort)
 	    return;
 	while (needsort < num) {
 	    for (j = needsort - 1; j >= 0; j--) {
 		if (aval[j] > aval[j+1]) {
 		    char *hp;
 		    i = aval[j];
 		    aval[j] = aval[j+1];
 		    aval[j+1] = i;
 		    hp = ap[j];
 		    ap[j] = ap[j+1];
 		    ap[j+1] = hp;
 		} else
 		    break;
+	    }
 	    needsort++;
+	}
+}
 struct hostent *
 gethostent(void)
+{
 	host.h_addrtype = 0;
 	host.h_length = 0;
 	return _gethtent();
+}
 /*ARGSUSED*/
 int
 _dns_gethtbyname(void *rv, void *cb_data, va_list ap)
+{
 	querybuf *buf;
 	int n, type;
 	struct hostent *hp;
 	const char *name;
 	int af;
 	res_state res;
 	_DIAGASSERT(rv != NULL);
 	name = va_arg(ap, char *);
 	/* NOSTRICT skip len */(void)va_arg(ap, int);
 	af = va_arg(ap, int);
 	switch (af) {
 	case AF_INET:
 		type = T_A;
 		break;
 	case AF_INET6:
 		type = T_AAAA;
 		break;
 	default:
 		return NS_UNAVAIL;
+	}
 	buf = malloc(sizeof(*buf));
 	if (buf == NULL) {
 		h_errno = NETDB_INTERNAL;
 		return NS_NOTFOUND;
+	}
 	res = __res_get_state();
 	if (res == NULL) {
 		free(buf);
 		return NS_NOTFOUND;
+	}
 	n = res_nsearch(res, name, C_IN, type, buf->buf, sizeof(buf->buf));
 	if (n < 0) {
 		free(buf);
 		dprintf("res_nsearch failed (%d)\n", res, n);
 		__res_put_state(res);
 		return NS_NOTFOUND;
+	}
 	hp = getanswer(buf, n, name, type, res);
 	free(buf);
 	__res_put_state(res);
 	if (hp == NULL)
 		switch (h_errno) {
 		case HOST_NOT_FOUND:
 			return NS_NOTFOUND;
 		case TRY_AGAIN:
 			return NS_TRYAGAIN;
 		default:
 			return NS_UNAVAIL;
+		}
 	*((struct hostent **)rv) = hp;
 	return NS_SUCCESS;
+}
 /*ARGSUSED*/
 int
 _dns_gethtbyaddr(void *rv, void	*cb_data, va_list ap)
+{
 	char qbuf[MAXDNAME + 1], *qp, *ep;
 	int n;
 	querybuf *buf;
 	struct hostent *hp;
 	const unsigned char *uaddr;
 	int len, af, advance;
 	res_state res;
 	_DIAGASSERT(rv != NULL);
 	uaddr = va_arg(ap, unsigned char *);
 	len = va_arg(ap, int);
 	af = va_arg(ap, int);
 	switch (af) {
 	case AF_INET:
 		(void)snprintf(qbuf, sizeof(qbuf), "%u.%u.%u.%u.in-addr.arpa",
 		    (uaddr[3] & 0xff), (uaddr[2] & 0xff),
 		    (uaddr[1] & 0xff), (uaddr[0] & 0xff));
 		break;
 	case AF_INET6:
 		qp = qbuf;
 		ep = qbuf + sizeof(qbuf) - 1;
 		for (n = IN6ADDRSZ - 1; n >= 0; n--) {
 			advance = snprintf(qp, (size_t)(ep - qp), "%x.%x.",
 			    uaddr[n] & 0xf,
 			    ((unsigned int)uaddr[n] >> 4) & 0xf);
 			if (advance > 0 && qp + advance < ep)
 				qp += advance;
 			else {
 				h_errno = NETDB_INTERNAL;
 				return NS_NOTFOUND;
+			}
+		}
 		if (strlcat(qbuf, "ip6.arpa", sizeof(qbuf)) >= sizeof(qbuf)) {
 			h_errno = NETDB_INTERNAL;
 			return NS_NOTFOUND;
+		}
 		break;
 	default:
 		abort();
+	}
 	buf = malloc(sizeof(*buf));
 	if (buf == NULL) {
 		h_errno = NETDB_INTERNAL;
 		return NS_NOTFOUND;
+	}
 	res = __res_get_state();
 	if (res == NULL) {
 		free(buf);
 		return NS_NOTFOUND;
+	}
 	n = res_nquery(res, qbuf, C_IN, T_PTR, buf->buf, sizeof(buf->buf));
 	if (n < 0) {
 		free(buf);
 		dprintf("res_nquery failed (%d)\n", res, n);
 		__res_put_state(res);
 		return NS_NOTFOUND;
+	}
 	hp = getanswer(buf, n, qbuf, T_PTR, res);
 	free(buf);
 	if (hp == NULL) {
 		__res_put_state(res);
 		switch (h_errno) {
 		case HOST_NOT_FOUND:
 			return NS_NOTFOUND;
 		case TRY_AGAIN:
 			return NS_TRYAGAIN;
 		default:
 			return NS_UNAVAIL;
+		}
+	}
 	hp->h_addrtype = af;
 	hp->h_length = len;
 	(void)memcpy(host_addr, uaddr, (size_t)len);
 	h_addr_ptrs[0] = (char *)(void *)host_addr;
 	h_addr_ptrs[1] = NULL;
 	if (af == AF_INET && (res->options & RES_USE_INET6)) {
 		map_v4v6_address((char *)(void *)host_addr,
 		    (char *)(void *)host_addr);
 		hp->h_addrtype = AF_INET6;
 		hp->h_length = IN6ADDRSZ;
+	}
 	__res_put_state(res);
 	*((struct hostent **)rv) = hp;
 	h_errno = NETDB_SUCCESS;
 	return NS_SUCCESS;
+}
 #ifdef YP
 /*ARGSUSED*/
 struct hostent *
 _yphostent(char *line, int af)
+{
 	static struct in_addr host_addrs[MAXADDRS];
 	static struct in6_addr host6_addrs[MAXADDRS];
 	char *p = line;
 	char *cp, **q;
 	char **hap;
 	int addrok;
 	int more;
 	size_t naddrs;
 	_DIAGASSERT(line != NULL);
 	host.h_name = NULL;
 	host.h_addr_list = h_addr_ptrs;
 	host.h_addrtype = af;
 	switch (af) {
 	case AF_INET:
 		host.h_length = INADDRSZ;
 		break;
 	case AF_INET6:
 		host.h_length = IN6ADDRSZ;
 		break;
 	default:
 		return NULL;
+	}
 	hap = h_addr_ptrs;
 	q = host.h_aliases = host_aliases;
 	naddrs = 0;
 nextline:
 	/* check for host_addrs overflow */
 	if (naddrs >= sizeof(host_addrs) / sizeof(host_addrs[0]))
 		goto done;
 	if (naddrs >= sizeof(host6_addrs) / sizeof(host6_addrs[0]))
 		goto done;
 	more = 0;
 	cp = strpbrk(p, " \t");
 	if (cp == NULL)
 		goto done;
 	*cp++ = '\0';
 	/* p has should have an address */
 	addrok = 0;
 	switch (af) {
 	case AF_INET:
 		addrok = inet_aton(p, &host_addrs[naddrs]);
 		break;
 	case AF_INET6:
 		addrok = inet_pton(af, p, &host6_addrs[naddrs]);
 		break;
+	}
 	if (addrok != 1) {
 		/* skip to the next line */
 		while (cp && *cp) {
 			if (*cp == '\n') {
 				cp++;
 				goto nextline;
+			}
 			cp++;
+		}
 		goto done;
+	}
 	switch (af) {
 	case AF_INET:
 		*hap++ = (char *)(void *)&host_addrs[naddrs++];
 		break;
 	case AF_INET6:
 		*hap++ = (char *)(void *)&host6_addrs[naddrs++];
 		break;
+	}
 	while (*cp == ' ' || *cp == '\t')
 		cp++;
 	p = cp;
 	cp = strpbrk(p, " \t\n");
 	if (cp != NULL) {
 		if (*cp == '\n')
 			more = 1;
 		*cp++ = '\0';
+	}
 	if (!host.h_name)
 		host.h_name = p;
 	else if (strcmp(host.h_name, p)==0)
+		;
 	else if (q < &host_aliases[MAXALIASES - 1])
 		*q++ = p;
 	p = cp;
 	if (more)
 		goto nextline;
 	while (cp && *cp) {
 		if (*cp == ' ' || *cp == '\t') {
 			cp++;
 			continue;
+		}
 		if (*cp == '\n') {
 			cp++;
 			goto nextline;
+		}
 		if (q < &host_aliases[MAXALIASES - 1])
 			*q++ = cp;
 		cp = strpbrk(cp, " \t");
 		if (cp != NULL)
 			*cp++ = '\0';
+	}
 done:
 	if (host.h_name == NULL)
 		return NULL;
 	*q = NULL;
 	*hap = NULL;
 	return &host;
+}
 /*ARGSUSED*/
 int
 _yp_gethtbyaddr(void *rv, void *cb_data, va_list ap)
+{
 	struct hostent *hp = NULL;
 	static char *__ypcurrent;
 	int __ypcurrentlen, r;
 	char name[INET6_ADDRSTRLEN];	/* XXX enough? */
 	const unsigned char *uaddr;
 	int af;
 	const char *map;
 	_DIAGASSERT(rv != NULL);
 	uaddr = va_arg(ap, unsigned char *);
 	/* NOSTRICT skip len */(void)va_arg(ap, int);
 	af = va_arg(ap, int);
 	if (!__ypdomain) {
 		if (_yp_check(&__ypdomain) == 0)
 			return NS_UNAVAIL;
+	}
 	/*
 	 * XXX unfortunately, we cannot support IPv6 extended scoped address
 	 * notation here.  gethostbyaddr() is not scope-aware.  too bad.
 	 */
 	if (inet_ntop(af, uaddr, name, sizeof(name)) == NULL)
 		return NS_UNAVAIL;
 	if (__ypcurrent)
 		free(__ypcurrent);
 	__ypcurrent = NULL;
 	switch (af) {
 	case AF_INET:
 		map = "hosts.byaddr";
 		break;
 	default:
 		map = "ipnodes.byaddr";
 		break;
+	}
 	r = yp_match(__ypdomain, map, name,
 		(int)strlen(name), &__ypcurrent, &__ypcurrentlen);
 	if (r == 0)
 		hp = _yphostent(__ypcurrent, af);
 	if (hp == NULL) {
 		h_errno = HOST_NOT_FOUND;
 		return NS_NOTFOUND;
+	}
 	*((struct hostent **)rv) = hp;
 	return NS_SUCCESS;
+}
 /*ARGSUSED*/
 int
 _yp_gethtbyname(void *rv, void *cb_data, va_list ap)
+{
 	struct hostent *hp = NULL;
 	static char *__ypcurrent;
 	int __ypcurrentlen, r;
 	const char *name;
 	int af;
 	const char *map;
 	_DIAGASSERT(rv != NULL);
 	name = va_arg(ap, char *);
 	/* NOSTRICT skip len */(void)va_arg(ap, int);
 	af = va_arg(ap, int);
 	if (!__ypdomain) {
 		if (_yp_check(&__ypdomain) == 0)
 			return NS_UNAVAIL;
+	}
 	if (__ypcurrent)
 		free(__ypcurrent);
 	__ypcurrent = NULL;
 	switch (af) {
 	case AF_INET:
 		map = "hosts.byname";
 		break;
 	default:
 		map = "ipnodes.byname";
 		break;
+	}
 	r = yp_match(__ypdomain, map, name,
 		(int)strlen(name), &__ypcurrent, &__ypcurrentlen);
 	if (r == 0)
 		hp = _yphostent(__ypcurrent, af);
 	if (hp == NULL) {
 		h_errno = HOST_NOT_FOUND;
 		return NS_NOTFOUND;
+	}
 	*((struct hostent **)rv) = hp;
 	return NS_SUCCESS;
+}
 #endif

 @@ -1,717 +1,717 @@
-.\"	$NetBSD: resolver.3,v 1.22 2009/06/08 16:55:30 christos Exp $
+.\"	$NetBSD: resolver.3,v 1.23 2009/10/02 06:49:23 cegger Exp $
 .\" Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
 .\"
 .\" 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 ISC DISCLAIMS ALL WARRANTIES
 .\" WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 .\" MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC 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.
 .\"
 .\" Copyright (c) 1985, 1995 The Regents of the University of California.
 .\" All rights reserved.
 .\"
 .\" Redistribution and use in source and binary forms are permitted provided
 .\" that: (1) source distributions retain this entire copyright notice and
 .\" comment, and (2) distributions including binaries display the following
 .\" acknowledgement:  ``This product includes software developed by the
 .\" University of California, Berkeley and its contributors'' in the
 .\" documentation or other materials provided with the distribution and in
 .\" all advertising materials mentioning features or use of this software.
 .\" Neither the name of the University nor the names of its contributors may
 .\" be used to endorse or promote products derived from this software without
 .\" specific prior written permission.
 .\" THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
 .\" WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
 .\" MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 .\"
 .\"	@(#)resolver.3	6.5 (Berkeley) 6/23/90
 .\"	Id: resolver.man3,v 1.2 2009/01/21 00:12:34 each Exp
 .\"
 .Dd July 4, 2000
 .Dt RESOLVER 3
 .Os
 .Sh NAME
 .Nm res_ninit ,
 .Nm res_ourserver_p ,
 .Nm fp_resstat ,
 .Nm res_hostalias ,
 .Nm res_pquery ,
 .Nm res_nquery ,
 .Nm res_nsearch ,
 .Nm res_nquerydomain ,
 .Nm res_nmkquery ,
 .Nm res_nsend ,
 .Nm res_nupdate ,
 .Nm res_nmkupdate ,
 .Nm res_nclose ,
 .Nm res_nsendsigned ,
 .Nm res_findzonecut ,
 .Nm res_getservers ,
 .Nm res_setservers ,
 .Nm res_ndestroy ,
 .Nm dn_comp ,
 .Nm dn_expand ,
 .\" .Nm hstrerror ,
 .Nm res_init ,
 .Nm res_isourserver ,
 .Nm fp_nquery ,
 .Nm p_query ,
 .Nm hostalias ,
 .Nm res_query ,
 .Nm res_search ,
 .Nm res_querydomain ,
 .Nm res_mkquery ,
 .Nm res_send ,
 .Nm res_update ,
 .Nm res_close ,
 .\" .Nm herror
 .Nd resolver routines
 .Sh LIBRARY
 .Lb libc
 .Sh SYNOPSIS
 .In sys/types.h
 .In netinet/in.h
 .In arpa/nameser.h
 .In resolv.h
 .In res_update.h
 .Vt typedef struct __res_state *res_state ;
 .Pp
 .Ft int
 .Fn res_ninit "res_state statp"
 .Ft int
 .Fn res_ourserver_p "const res_state statp" "const struct sockaddr_in *addr"
 .Ft void
 .Fn fp_resstat "const res_state statp" "FILE *fp"
 .Ft "const char *"
 .Fn res_hostalias "const res_state statp" "const char *name" "char *buf" "size_t buflen"
 .Ft int
 .Fn res_pquery "const res_state statp" "const u_char *msg" "int msglen" "FILE *fp"
 .Ft int
 .Fn res_nquery "res_state statp" "const char *dname" "int class" "int type" "u_char *answer" "int anslen"
 .Ft int
 .Fn res_nsearch "res_state statp" "const char *dname" "int class" "int type" "u_char * answer" "int anslen"
 .Ft int
 .Fn res_nquerydomain "res_state statp" "const char *name" "const char *domain" "int class" "int type" "u_char *answer" "int anslen"
 .Ft int
 .Fo res_nmkquery
 .Fa "res_state statp"
 .Fa "int op"
 .Fa "const char *dname"
 .Fa "int class"
 .Fa "int type"
 .Fa "const u_char *data"
 .Fa "int datalen"
 .Fa "const u_char *newrr"
 .Fa "u_char *buf"
 .Fa "int buflen"
 .Fc
 .Ft int
 .Fn res_nsend "res_state statp" "const u_char *msg" "int msglen" "u_char *answer" "int anslen"
 .Ft int
 .Fn res_nupdate "res_state statp" "ns_updrec *rrecp_in"
 .Ft int
 .Fn res_nmkupdate "res_state statp" "ns_updrec *rrecp_in" "u_char *buf" "int buflen"
 .Ft void
 .Fn res_nclose "res_state statp"
 .Ft int
 .Fn res_nsendsigned "res_state statp" "const u_char *msg" "int msglen" "ns_tsig_key *key" "u_char *answer" "int anslen"
 .Ft int
 .Fn res_findzonecut "res_state statp" "const char *dname" "ns_class class" "int options" "char *zname" "size_t zsize" "struct in_addr *addrs" "int naddrs"
 .Ft int
 .Fn res_getservers "res_state statp" "union res_sockaddr_union *set" "int cnt"
 .Ft void
 .Fn res_setservers "res_state statp" "const union res_sockaddr_union *set" "int cnt"
 .Ft void
 .Fn res_ndestroy "res_state statp"
 .Ft int
 .Fn dn_comp "const char *exp_dn" "u_char *comp_dn" "int length" "u_char **dnptrs" "u_char **lastdnptr"
 .Ft int
 .Fn dn_expand "const u_char *msg" "const u_char *eomorig" "const u_char *comp_dn" "char *exp_dn" "int  length"
 .\" .Ft "const char *"
 .\" .Fn hstrerror "int err"
 .Ss DEPRECATED
 .In sys/types.h
 .In netinet/in.h
 .In arpa/nameser.h
 .In resolv.h
 .In res_update.h
 .Ft int
 .Fn res_init "void"
 .Ft int
 .Fn res_isourserver "const struct sockaddr_in *addr"
 .Ft int
 .Fn fp_nquery "const u_char *msg" "int msglen" "FILE *fp"
 .Ft void
 .Fn p_query "const u_char *msg" "FILE *fp"
 .Ft "const char *"
 .Fn hostalias "const char *name"
 .Ft int
 .Fn res_query "const char *dname" "int class" "int type" "u_char *answer" "int anslen"
 .Ft int
 .Fn res_search "const char *dname" "int class" "int type" "u_char *answer" "int anslen"
 .Ft int
 .Fn res_querydomain "const char *name" "const char *domain" "int class" "int type" "u_char *answer" "int anslen"
 .Ft int
 .Fo res_mkquery
 .Fa "int op"
 .Fa "const char *dname"
 .Fa "int class"
 .Fa "int type"
 .Fa "const char *data"
 .Fa "int datalen"
 .Fa "struct rrec *newrr"
 .Fa "u_char *buf"
 .Fa "int buflen"
 .Fc
 .Ft int
 .Fn res_send "const u_char *msg" "int msglen" "u_char *answer" "int anslen"
 .Ft int
 .Fn res_update "ns_updrec *rrecp_in"
 .Ft void
 .Fn res_close "void"
 .\" .Ft void
 .\" .Fn herror "const char *s"
 .Sh DESCRIPTION
 These routines are used for making, sending and interpreting
 query and reply messages with Internet domain name servers.
 .Pp
 State information is kept in
 .Fa statp
 and is used to control the behavior of these functions.
 .Fa statp
 should be set to all zeros prior to the first call to any of these functions.
 .Pp
 The functions
 .Fn res_init ,
 .Fn res_isourserver ,
 .Fn fp_nquery ,
 .Fn p_query ,
 .Fn hostalias ,
 .Fn res_query ,
 .Fn res_search ,
 .Fn res_querydomain ,
 .Fn res_mkquery ,
 .Fn res_send ,
 .Fn res_update ,
 .Fn res_close
 .\" and
 .\" .Fn herror
 are deprecated and are supplied for compatability with old source
 code.
 They use global configuration and state information that is
 kept in the structure
 .Ft _res
 rather than that referenced through
 .Ft statp .
 .Pp
 Most of the values in
 .Ft statp
 and
 .Ft _res
 are initialized on the first call to
 .Fn res_ninit
+/
 .Fn res_init
 to reasonable defaults and can be ignored.
 Options
 stored in
 .Ft statp->options
+/
 .Ft _res.options
 are defined in
 .Pa resolv.h
 and are as follows.
 Options are stored as a simple bit mask containing the bitwise
 .Dq OR
 of the options enabled.
 .Bl -tag -width "RES_USE_INET6"
 .It Dv RES_INIT
 True if the initial name server address and default domain name are
 initialized (i.e.,
 .Fn res_ninit
+/
 .Fn res_init
 has been called).
 .It Dv RES_DEBUG
 Print debugging messages.
 .It Dv RES_AAONLY
 Accept authoritative answers only.
 Should continue until it finds an authoritative answer or finds an error.
 Currently this is not implemented.
 .It Dv RES_USEVC
 Use TCP connections for queries instead of UDP datagrams.
 .It Dv RES_STAYOPEN
 Used with
 .Dv RES_USEVC
 to keep the TCP connection open between queries.
 This is useful only in programs that regularly do many queries.
 UDP should be the normal mode used.
 .It Dv RES_IGNTC
 Ignore truncation errors, i.e., don't retry with TCP.
 .It Dv RES_RECURSE
 Set the recursion-desired bit in queries.
 This is the default.
 (\c
 .Fn res_nsend
+/
 .Fn res_send
 does not do iterative queries and expects the name server
 to handle recursion.)
 .It Dv RES_DEFNAMES
 If set,
 .Fn res_nsearch
+/
 .Fn res_search
 will append the default domain name to single-component names
 (those that do not contain a dot).
 This option is enabled by default.
 .It Dv RES_DNSRCH
 If this option is set,
 .Fn res_nsearch
+/
 .Fn res_search
 will search for host names in the current domain and in parent domains; see
 .Xr hostname 7 .
 This is used by the standard host lookup routine
 .Xr gethostbyname 3 .
 This option is enabled by default.
 .It Dv RES_USE_INET6
 Enables support for IPv6-only applications.
 This causes IPv4 addresses to be returned as an IPv4 mapped address.
 For example, 10.1.1.1 will be returned as ::ffff:10.1.1.1.
 The option is meaningful with certain kernel configuration only.
 .It Dv RES_USE_EDNS0
 Enables support for OPT pseudo-RR for EDNS0 extension.
 With the option, resolver code will attach OPT pseudo-RR into DNS queries,
 to inform of our receive buffer size.
 The option will allow DNS servers to take advantage of non-default receive
 buffer size, and to send larger replies.
 DNS query packets with EDNS0 extension is not compatible with
 non-EDNS0 DNS servers.
 .It Dv RES_NOALIASES
 This option turns off the user level aliasing feature controlled by
 the
 .Ev HOSTALIASES
 environment variable.
 Network daemons should set this option.
 .It Dv RES_ROTATE
 This options causes the
 .Fn res_nsend
+/
 .Fn res_send
 to rotate the list of nameservers in
 .Fa statp->nsaddr_list
+/
 .Fa _res.nsaddr_list .
 .It Dv RES_KEEPTSIG
 This option causes
 .Fn res_nsendsigned
 to leave the message unchanged after TSIG verification; otherwise the TSIG
 record would be removed and the header updated.
 .It Dv RES_NOTLDQUERY
 This option causes
 .Fn res_nsearch
-to not attempt to resolve a unqualified name as if it were a top level
+to not attempt to resolve an unqualified name as if it were a top level
 domain (TLD).
 This option can cause problems if the site has "localhost" as a TLD rather
 than having localhost on one or more elements of the search list.
 This option has no effect if neither
 .Dv RES_DEFNAMES
 or
 .Dv RES_DNSRCH
 is set.
 .El
 .Pp
 The
 .Fn res_ninit
+/
 .Fn res_init
 routine
 reads the configuration file (if any; see
 .Xr resolv.conf 5 )
 to get the default domain name, search list and
 the Internet address of the local name server(s).
 If no server is configured, the host running the resolver is tried.
 The current domain name is defined by the hostname
 if not specified in the configuration file;
 it can be overridden by the environment variable
 .Ev LOCALDOMAIN .
 This environment variable may contain several blank-separated
 tokens if you wish to override the
 .Fa search list
 on a per-process basis.  This is similar to the
 .Fa search
 command in the configuration file.
 Another environment variable
 .Ev RES_OPTIONS
 can be set to override certain internal resolver options which are otherwise
 set by changing fields in the
 .Ft statp
+/
 .Ft _res
 structure or are inherited from the configuration file's
 .Fa options
 command.
 The syntax of the
 .Ev RES_OPTIONS
 environment variable is explained in
 .Xr resolv.conf 5 .
 Initialization normally occurs on the first call
 to one of the other resolver routines.
 .Pp
 The memory referred to by
 .Ft statp
 must be set to all zeros prior to the first call to
 .Fn res_ninit .
 .Fn res_ndestroy
 should be call to free memory allocated by
 .Fn res_ninit
 after last use.
 .Pp
 The
 .Fn res_nquery
+/
 .Fn res_query
 functions provides interfaces to the server query mechanism.
 They constructs a query, sends it to the local server,
 awaits a response, and makes preliminary checks on the reply.
 The query requests information of the specified
 .Fa type
 and
 .Fa class
 for the specified fully-qualified domain name
 .Fa dname .
 The reply message is left in the
 .Fa answer
 buffer with length
 .Fa anslen
 supplied by the caller.
 .Fn res_nquery
+/
 .Fn res_query
 return -1 on error or the length of the answer.
 .Pp
 The
 .Fn res_nsearch
+/
 .Fn res_search
 routines make a query and awaits a response like
 .Fn res_nquery
+/
 .Fn res_query ,
 but in addition, it implements the default and search rules
 controlled by the
 .Dv RES_DEFNAMES
 and
 .Dv RES_DNSRCH
 options.
 It returns the length of the first successful reply which is stored in
 .Ft answer
 or -1 on error.
 .Pp
 The remaining routines are lower-level routines used by
 .Fn res_nquery
+/
 .Fn res_query .
 The
 .Fn res_nmkquery
+/
 .Fn res_mkquery
 functions
 constructs a standard query message and places it in
 .Fa buf .
 It returns the size of the query, or \-1 if the query is
 larger than
 .Fa buflen .
 The query type
 .Fa op
 is usually
 .Dv QUERY ,
 but can be any of the query types defined in
 .Pa <arpa/nameser.h> .
 The domain name for the query is given by
 .Fa dname .
 .Fa newrr
 is currently unused but is intended for making update messages.
 .Pp
 The
 .Fn res_nsend
+/
 .Fn res_send
+/
 .Fn res_nsendsigned
 routines
 sends a pre-formatted query and returns an answer.
 It will call
 .Fn res_ninit
+/
 .Fn res_init
 if
 .Dv RES_INIT
 is not set, send the query to the local name server, and
 handle timeouts and retries.  Additionally,
 .Fn res_nsendsigned
 will use TSIG signatures to add authentication to the query and verify the
 response.  In this case, only one nameserver will be contacted.
 The length of the reply message is returned, or \-1 if there were errors.
 .Pp
 .Fn res_nquery
+/
 .Fn res_query ,
 .Fn res_nsearch
+/
 .Fn res_search
 and
 .Fn res_nsend
+/
 .Fn res_send
 return a length that may be bigger than
 .Fa anslen .
 In that case the query should be retried with a bigger buffer.
 NOTE the answer to the second query may be larger still so supplying
 a buffer that bigger that the answer returned by the previous
 query is recommended.
 .Pp
 .Fa answer
 MUST be big enough to receive a maximum UDP response from the server or
 parts of the answer will be silently discarded.
 The default maximum UDP response size is 512 bytes.
 .Pp
 The function
 .Fn res_ourserver_p
 returns true when
 .Fa inp
 is one of the servers in
 .Fa statp->nsaddr_list
+/
 .Fa _res.nsaddr_list .
 .Pp
 The functions
 .Fn fp_nquery
+/
 .Fn p_query
 print out the query and any answer in
 .Fa msg
 on
 .Fa fp .
 .Fn p_query
 is equivalent to
 .Fn fp_nquery
 with
 .Fa msglen
 set to 512.
 .Pp
 The function
 .Fn fp_resstat
 prints out the active flag bits in
 .Fa statp->options
 preceeded by the text ";; res options:" on
 .Fa file .
 .Pp
 The functions
 .Fn res_hostalias
+/
 .Fn hostalias
 lookup up name in the file referred to by the
 .Ev HOSTALIASES
 files return a fully qualified hostname if found or NULL if
 not found or an error occurred.
 .Fn res_hostalias
 uses
 .Fa buf
 to store the result in,
 .Fn hostalias
 uses a static buffer.
 .Pp
 The functions
 .Fn res_getservers
 and
 .Fn res_setservers
 are used to get and set the list of server to be queried.
 .Pp
 The functions
 .Fn res_nupdate
+/
 .Fn res_update
 take a list of ns_updrec
 .Fa rrecp_in .
 Identifies the containing zone for each record and groups the records
 according to containing zone maintaining in zone order then sends and update
 request to the servers for these zones.  The number of zones updated is
 returned or -1 on error.  Note that
 .Fn res_nupdate
 will perform TSIG authenticated dynamic update operations if the key is not
 NULL.
 .Pp
 The function
 .Fn res_findzonecut
 discovers the closest enclosing zone cut for a specified domain name,
 and finds the IP addresses of the zone's master servers.
 .Pp
 The functions
 .Fn res_nmkupdate
+/
 .Fn res_mkupdate
 take a linked list of ns_updrec
 .Fa rrecp_in
 and construct a UPDATE message in
 .Fa buf .
 .Fn res_nmkupdate
+/
 .Fn res_mkupdate
 return the length of the constructed message on no error or one of the
 following error values.
 .Bl -inset -width "-5"
 .It -1
 An error occurred parsing
 .Fa rrecp_in .
 .It -2
 The buffer
 .Fa buf
 was too small.
 .It -3
 The first record was not a zone section or there was a section order problem.
 The section order is S_ZONE, S_PREREQ and S_UPDATE.
 .It -4
 A number overflow occurred.
 .It -5
 Unknown operation or no records.
 .El
 .Pp
 The functions
 .Fn res_nclose
+/
 .Fn res_close
 close any open files referenced through
 .Fa statp
+/
 .Fa _res .
 .Pp
 The function
 .Fn res_ndestroy
 calls
 .Fn res_nclose
 then frees any memory allocated by
 .Fn res_ninit .
 .Pp
 The
 .Fn dn_comp
 function
 compresses the domain name
 .Fa exp_dn
 and stores it in
 .Fa comp_dn .
 The size of the compressed name is returned or \-1 if there were errors.
 The size of the array pointed to by
 .Fa comp_dn
 is given by
 .Fa length .
 The compression uses
 an array of pointers
 .Fa dnptrs
 to previously-compressed names in the current message.
 The first pointer points to
 the beginning of the message and the list ends with
 .Dv NULL .
 The limit to the array is specified by
 .Fa lastdnptr .
 A side effect of
 .Fn dn_comp
 is to update the list of pointers for labels inserted into the message
 as the name is compressed.  If
 .Fa dnptr
 is
 .Dv NULL ,
 names are not compressed.  If
 .Fa lastdnptr
 is
 .Dv NULL ,
 the list of labels is not updated.
 .Pp
 The
 .Fn dn_expand
 entry expands the compressed domain name
 .Fa comp_dn
 to a full domain name.
 The compressed name is contained in a query or reply message;
 .Fa msg
 is a pointer to the beginning of the message.
 .Fa eomorig
 is a pointer to the first location after the message.
 The uncompressed name is placed in the buffer indicated by
 .Fa exp_dn
 which is of size
 .Fa length .
 The size of compressed name is returned or \-1 if there was an error.
 .Pp
 The variables
 .Ft statp->res_h_errno
+/
 .Ft _res.res_h_errno
 and external variable
 .Ft h_errno
 is set whenever an error occurs during resolver operation.  The following
 definitions are given in
 .Pa <netdb.h> :
 .Bd -literal
 #define NETDB_INTERNAL -1
 /* see errno */
 #define NETDB_SUCCESS  0
 /* no problem */
 #define HOST_NOT_FOUND 1
 /* Authoritative Answer Host not found */
 #define TRY_AGAIN      2
 /* Non-Authoritative not found, or SERVFAIL */
 #define NO_RECOVERY    3
 /* Non-Recoverable: FORMERR, REFUSED, NOTIMP */
 #define NO_DATA        4
 /* Valid name, no data for requested type */
 .Ed
 .\" .Pp
 .\" The
 .\" .Fn herror
 .\" function writes a message to the diagnostic output consisting of the string
 .\" parameter
 .\" .Fa s ,
 .\" the constant string ": ", and a message corresponding to the value of
 .\" .Ft h_errno .
 .\" .Pp
 .\" The
 .\" .Fn hstrerror
 .\" function returns a string which is the message text corresponding to the
 .\" value of the
 .\" .Fa err
 .\" parameter.
 .Sh FILES
 .Bl -tag -width "/etc/resolv.conf    "
 .It Pa
 /etc/resolv.conf
 The configuration file, see
 .Xr resolv.conf 5 .
 .El
 .Sh SEE ALSO
 .Xr gethostbyname 3 ,
 .Xr hostname 7 ,
 .Xr resolv.conf 5 ,
 .Xr named 8
 .Pp
 .%T RFC 974 ,
 .%T RFC 1032 ,
 .%T RFC 1033 ,
 .%T RFC 1034 ,
 .%T RFC 1035 ,
 .%T RFC 1535
 .Rs
 .%T "Name Server Operations Guide for BIND"
 .Re
 .Sh HISTORY
 The
 .Nm
 function appeared in
 .Bx 4.3 .