/usr/src/lib/libc/asr/getaddrinfo_async.c

Bug Summary

File:	src/lib/libc/asr/getaddrinfo_async.c
Warning:	line 642, column 18 The right operand of '!=' is a garbage value

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name getaddrinfo_async.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/lib/libc/obj -resource-dir /usr/local/lib/clang/13.0.0 -include namespace.h -I /usr/src/lib/libc/include -I /usr/src/lib/libc/hidden -D __LIBC__ -D APIWARN -D YP -I /usr/src/lib/libc/yp -I /usr/src/lib/libc -I /usr/src/lib/libc/gdtoa -I /usr/src/lib/libc/arch/amd64/gdtoa -D INFNAN_CHECK -D MULTIPLE_THREADS -D NO_FENV_H -D USE_LOCALE -I /usr/src/lib/libc -I /usr/src/lib/libc/citrus -D RESOLVSORT -D FLOATING_POINT -D PRINTF_WIDE_CHAR -D SCANF_WIDE_CHAR -D FUTEX -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/lib/libc/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/lib/libc/asr/getaddrinfo_async.c

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

18#include <sys/types.h>
19#include <sys/socket.h>
20#include <sys/uio.h>
21#include <netinet/in.h>
22#include <arpa/nameser.h>
23#include <net/if.h>
24#include <netdb.h>

26#include <asr.h>
27#include <errno(*__errno()).h>
28#include <ifaddrs.h>
29#include <resolv.h>
30#include <stdlib.h>
31#include <string.h>
32#include <unistd.h>
33#include <limits.h>

35#include "asr_private.h"

37struct match {
int family;
int socktype;
int protocol;
41};

43static int getaddrinfo_async_run(struct asr_query *, struct asr_result *);
44static int get_port(const char *, const char *, int);
45static int iter_family(struct asr_query *, int);
46static int addrinfo_add(struct asr_query *, const struct sockaddr *, const char *);
47static int addrinfo_from_file(struct asr_query *, int,  FILE *);
48static int addrinfo_from_pkt(struct asr_query *, char *, size_t);
49static int addrconfig_setup(struct asr_query *);

51static const struct match matches[] = {
{ PF_INET2,	SOCK_DGRAM2,	IPPROTO_UDP17	},
{ PF_INET2,	SOCK_STREAM1,	IPPROTO_TCP6	},
{ PF_INET2,	SOCK_RAW3,	0		},
{ PF_INET624,	SOCK_DGRAM2,	IPPROTO_UDP17	},
{ PF_INET624,	SOCK_STREAM1,	IPPROTO_TCP6	},
{ PF_INET624,	SOCK_RAW3,	0		},
{ -1,		0,		0,		},
59};

61#define MATCH_FAMILY(a, b)((a) == matches[(b)].family || (a) == 0) ((a) == matches[(b)].family || (a) == PF_UNSPEC0)
62#define MATCH_PROTO(a, b)((a) == matches[(b)].protocol || (a) == 0 || matches[(b)].protocol
 == 0) ((a) == matches[(b)].protocol || (a) == 0 || matches[(b)].protocol == 0)
63/* Do not match SOCK_RAW unless explicitly specified */
64#define MATCH_SOCKTYPE(a, b)((a) == matches[(b)].socktype || ((a) == 0 && matches
[(b)].socktype != 3)) ((a) == matches[(b)].socktype || ((a) == 0 && \
		matches[(b)].socktype != SOCK_RAW3))

67enum {
DOM_INIT,
DOM_DOMAIN,
DOM_DONE
71};

73struct asr_query *
74getaddrinfo_async(const char *hostname, const char *servname,
const struct addrinfo *hints, void *asr)
76{
struct asr_ctx		*ac;
struct asr_query	*as;

if (hints == NULL((void *)0) || (hints->ai_flags & AI_NUMERICHOST4) == 0)
ac = _asr_use_resolver(asr);
else
ac = _asr_no_resolver();
if ((as = _asr_async_new(ac, ASR_GETADDRINFO)) == NULL((void *)0))
goto abort; /* errno set */
as->as_run = getaddrinfo_async_run;

if (hostname) {
if ((as->as.ai.hostname = strdup(hostname)) == NULL((void *)0))
	goto abort; /* errno set */
}
if (servname && (as->as.ai.servname = strdup(servname)) == NULL((void *)0))
goto abort; /* errno set */
if (hints)
memmove(&as->as.ai.hints, hints, sizeof *hints);
else {
memset(&as->as.ai.hints, 0, sizeof as->as.ai.hints);
as->as.ai.hints.ai_family = PF_UNSPEC0;
as->as.ai.hints.ai_flags = AI_ADDRCONFIG64;
}

_asr_ctx_unref(ac);
return (as);
  abort:
if (as)
_asr_async_free(as);
_asr_ctx_unref(ac);
return (NULL((void *)0));
109}
110DEF_WEAK(getaddrinfo_async)__asm__(".weak " "getaddrinfo_async" " ; " "getaddrinfo_async"
 " = " "_libc_getaddrinfo_async");

112static int
113getaddrinfo_async_run(struct asr_query *as, struct asr_result *ar)
114{
char		 fqdn[MAXDNAME1025];
const char	*str;
struct addrinfo	*ai;
int		 i, family, r;
FILE		*f;
union {
struct sockaddr		sa;
struct sockaddr_in	sain;
struct sockaddr_in6	sain6;
} sa;

  next:
switch (as->as_state) {
1
Control jumps to 'case ASR_STATE_SUBQUERY:'  at line 409→

case ASR_STATE_INIT:

/*
 * First, make sure the parameters are valid.
 */

as->as_count = 0;

if (as->as.ai.hostname == NULL((void *)0) &&
    as->as.ai.servname == NULL((void *)0)) {
	ar->ar_gai_errno = EAI_NONAME-2;
	async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0);
	break;
}

if (as->as.ai.hostname && as->as.ai.hostname[0] == '\0') {
	ar->ar_gai_errno = EAI_NODATA-5;
	async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0);
	break;
}

ai = &as->as.ai.hints;

if (ai->ai_addrlen ||
    ai->ai_canonname ||
    ai->ai_addr ||
    ai->ai_next) {
	ar->ar_gai_errno = EAI_BADHINTS-12;
	async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0);
	break;
}

if (ai->ai_flags & ~AI_MASK(1 | 2 | 4 | 16 | 32 | 64) ||
    (ai->ai_flags & AI_CANONNAME2 && ai->ai_flags & AI_FQDN32)) {
	ar->ar_gai_errno = EAI_BADFLAGS-1;
	async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0);
	break;
}

if (ai->ai_family != PF_UNSPEC0 &&
    ai->ai_family != PF_INET2 &&
    ai->ai_family != PF_INET624) {
	ar->ar_gai_errno = EAI_FAMILY-6;
	async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0);
	break;
}

if (ai->ai_socktype &&
    ai->ai_socktype != SOCK_DGRAM2  &&
    ai->ai_socktype != SOCK_STREAM1 &&
    ai->ai_socktype != SOCK_RAW3) {
	ar->ar_gai_errno = EAI_SOCKTYPE-7;
	async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0);
	break;
}

if (ai->ai_socktype == SOCK_RAW3 &&
    get_port(as->as.ai.servname, NULL((void *)0), 1) != 0) {
	ar->ar_gai_errno = EAI_SERVICE-8;
	async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0);
	break;
}

/* Restrict result set to configured address families */
if (ai->ai_flags & AI_ADDRCONFIG64) {
	if (addrconfig_setup(as) == -1) {
		ar->ar_errno = errno(*__errno());
		ar->ar_gai_errno = EAI_SYSTEM-11;
		async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0);
		break;
	}
}

/* Make sure there is at least a valid combination */
for (i = 0; matches[i].family != -1; i++)
	if (MATCH_FAMILY(ai->ai_family, i)((ai->ai_family) == matches[(i)].family || (ai->ai_family
) == 0) &&
	    MATCH_SOCKTYPE(ai->ai_socktype, i)((ai->ai_socktype) == matches[(i)].socktype || ((ai->ai_socktype
) == 0 && matches[(i)].socktype != 3)) &&
	    MATCH_PROTO(ai->ai_protocol, i)((ai->ai_protocol) == matches[(i)].protocol || (ai->ai_protocol
) == 0 || matches[(i)].protocol == 0))
		break;
if (matches[i].family == -1) {
	ar->ar_gai_errno = EAI_BADHINTS-12;
	async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0);
	break;
}

if (ai->ai_protocol == 0 || ai->ai_protocol == IPPROTO_UDP17)
	as->as.ai.port_udp = get_port(as->as.ai.servname, "udp",
	    as->as.ai.hints.ai_flags & AI_NUMERICSERV16);
if (ai->ai_protocol == 0 || ai->ai_protocol == IPPROTO_TCP6)
	as->as.ai.port_tcp = get_port(as->as.ai.servname, "tcp",
	    as->as.ai.hints.ai_flags & AI_NUMERICSERV16);
if (as->as.ai.port_tcp == -2 || as->as.ai.port_udp == -2 ||
    (as->as.ai.port_tcp == -1 && as->as.ai.port_udp == -1) ||
    (ai->ai_protocol && (as->as.ai.port_udp == -1 ||
			 as->as.ai.port_tcp == -1))) {
	ar->ar_gai_errno = EAI_SERVICE-8;
	async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0);
	break;
}

ar->ar_gai_errno = 0;

/* If hostname is NULL, use local address */
if (as->as.ai.hostname == NULL((void *)0)) {
	for (family = iter_family(as, 1);
	    family != -1;
	    family = iter_family(as, 0)) {
		/*
		 * We could use statically built sockaddrs for
		 * those, rather than parsing over and over.
		 */
		if (family == PF_INET2)
			str = (ai->ai_flags & AI_PASSIVE1) ? \
				"0.0.0.0" : "127.0.0.1";
		else /* PF_INET6 */
			str = (ai->ai_flags & AI_PASSIVE1) ? \
				"::" : "::1";
		 /* This can't fail */
		_asr_sockaddr_from_str(&sa.sa, family, str);
		if ((r = addrinfo_add(as, &sa.sa, NULL((void *)0)))) {
			ar->ar_gai_errno = r;
			break;
		}
	}
	if (ar->ar_gai_errno == 0 && as->as_count == 0) {
		ar->ar_gai_errno = EAI_NODATA-5;
	}
	async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0);
	break;
}

/* Try numeric addresses first */
for (family = iter_family(as, 1);
    family != -1;
    family = iter_family(as, 0)) {

	if (_asr_sockaddr_from_str(&sa.sa, family,
	    as->as.ai.hostname) == -1)
		continue;

	if ((r = addrinfo_add(as, &sa.sa, NULL((void *)0))))
		ar->ar_gai_errno = r;
	break;
}
if (ar->ar_gai_errno || as->as_count) {
	async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0);
	break;
}

if (ai->ai_flags & AI_NUMERICHOST4) {
	ar->ar_gai_errno = EAI_NONAME-2;
	async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0);
	break;
}

async_set_state(as, ASR_STATE_NEXT_DB)do { ; (as)->as_state = (ASR_STATE_NEXT_DB); } while (0);
break;

case ASR_STATE_NEXT_DB:
if (_asr_iter_db(as) == -1) {
	async_set_state(as, ASR_STATE_NOT_FOUND)do { ; (as)->as_state = (ASR_STATE_NOT_FOUND); } while (0);
	break;
}
as->as_family_idx = 0;
async_set_state(as, ASR_STATE_SAME_DB)do { ; (as)->as_state = (ASR_STATE_SAME_DB); } while (0);
break;

case ASR_STATE_NEXT_FAMILY:
as->as_family_idx += 1;
if (as->as.ai.hints.ai_family != AF_UNSPEC0 ||
    AS_FAMILY(as)((as)->as_ctx->ac_family[(as)->as_family_idx]) == -1) {
	/* The family was specified, or we have tried all
	 * families with this DB.
	 */
	if (as->as_count) {
		ar->ar_gai_errno = 0;
		async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0);
	} else
		async_set_state(as, ASR_STATE_NEXT_DOMAIN)do { ; (as)->as_state = (ASR_STATE_NEXT_DOMAIN); } while (
0);
	break;
}
async_set_state(as, ASR_STATE_SAME_DB)do { ; (as)->as_state = (ASR_STATE_SAME_DB); } while (0);
break;

case ASR_STATE_NEXT_DOMAIN:
/* domain search is only for dns */
if (AS_DB(as)((as)->as_ctx->ac_db[(as)->as_db_idx - 1]) != ASR_DB_DNS'b') {
	async_set_state(as, ASR_STATE_NEXT_DB)do { ; (as)->as_state = (ASR_STATE_NEXT_DB); } while (0);
	break;
}
as->as_family_idx = 0;

free(as->as.ai.fqdn);
as->as.ai.fqdn = NULL((void *)0);
r = _asr_iter_domain(as, as->as.ai.hostname, fqdn, sizeof(fqdn));
if (r == -1) {
	async_set_state(as, ASR_STATE_NEXT_DB)do { ; (as)->as_state = (ASR_STATE_NEXT_DB); } while (0);
	break;
}
if (r == 0) {
	ar->ar_gai_errno = EAI_FAIL-4;
	async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0);
	break;
}
as->as.ai.fqdn = strdup(fqdn);
if (as->as.ai.fqdn == NULL((void *)0)) {
	ar->ar_gai_errno = EAI_MEMORY-10;
	async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0);
	break;
}

async_set_state(as, ASR_STATE_SAME_DB)do { ; (as)->as_state = (ASR_STATE_SAME_DB); } while (0);
break;

case ASR_STATE_SAME_DB:
/* query the current DB again */
switch (AS_DB(as)((as)->as_ctx->ac_db[(as)->as_db_idx - 1])) {
case ASR_DB_DNS'b':
	if (as->as.ai.fqdn == NULL((void *)0)) {
		/* First try, initialize domain iteration */
		as->as_dom_flags = 0;
		as->as_dom_step = DOM_INIT;
		async_set_state(as, ASR_STATE_NEXT_DOMAIN)do { ; (as)->as_state = (ASR_STATE_NEXT_DOMAIN); } while (
0);
		break;
	}

	family = (as->as.ai.hints.ai_family == AF_UNSPEC0) ?
	    AS_FAMILY(as)((as)->as_ctx->ac_family[(as)->as_family_idx]) : as->as.ai.hints.ai_family;

	if (family == AF_INET2 &&
	    as->as_flags & ASYNC_NO_INET0x00010000) {
		async_set_state(as, ASR_STATE_NEXT_FAMILY)do { ; (as)->as_state = (ASR_STATE_NEXT_FAMILY); } while (
0);
		break;
	} else if (family == AF_INET624 &&
	    as->as_flags & ASYNC_NO_INET60x00020000) {
		async_set_state(as, ASR_STATE_NEXT_FAMILY)do { ; (as)->as_state = (ASR_STATE_NEXT_FAMILY); } while (
0);
		break;
	}

	as->as_subq = _res_query_async_ctx(as->as.ai.fqdn,
	    C_IN1, (family == AF_INET624) ? T_AAAA28 : T_A1,
	    as->as_ctx);

	if (as->as_subq == NULL((void *)0)) {
		if (errno(*__errno()) == ENOMEM12)
			ar->ar_gai_errno = EAI_MEMORY-10;
		else
			ar->ar_gai_errno = EAI_FAIL-4;
		async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0);
		break;
	}
	async_set_state(as, ASR_STATE_SUBQUERY)do { ; (as)->as_state = (ASR_STATE_SUBQUERY); } while (0);
	break;

case ASR_DB_FILE'f':
	f = fopen(_PATH_HOSTS"/etc/hosts", "re");
	if (f == NULL((void *)0)) {
		async_set_state(as, ASR_STATE_NEXT_DB)do { ; (as)->as_state = (ASR_STATE_NEXT_DB); } while (0);
		break;
	}
	family = (as->as.ai.hints.ai_family == AF_UNSPEC0) ?
	    AS_FAMILY(as)((as)->as_ctx->ac_family[(as)->as_family_idx]) : as->as.ai.hints.ai_family;

	r = addrinfo_from_file(as, family, f);
	if (r == -1) {
		if (errno(*__errno()) == ENOMEM12)
			ar->ar_gai_errno = EAI_MEMORY-10;
		else
			ar->ar_gai_errno = EAI_FAIL-4;
		async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0);
	} else
		async_set_state(as, ASR_STATE_NEXT_FAMILY)do { ; (as)->as_state = (ASR_STATE_NEXT_FAMILY); } while (
0);
	fclose(f);
	break;

default:
	async_set_state(as, ASR_STATE_NEXT_DB)do { ; (as)->as_state = (ASR_STATE_NEXT_DB); } while (0);
}
break;

case ASR_STATE_SUBQUERY:
if ((r = asr_run(as->as_subq, ar)) == ASYNC_COND0)
2
←
Assuming the condition is false→
3
←
Taking false branch→
	return (ASYNC_COND0);

as->as_subq = NULL((void *)0);

if (ar->ar_datalen == -1) {
4
←
Assuming the condition is false→
5
←
Taking false branch→
	async_set_state(as, ASR_STATE_NEXT_FAMILY)do { ; (as)->as_state = (ASR_STATE_NEXT_FAMILY); } while (
0);
	break;
}

r = addrinfo_from_pkt(as, ar->ar_data, ar->ar_datalen);
6
←
Calling 'addrinfo_from_pkt'→
if (r == -1) {
	if (errno(*__errno()) == ENOMEM12)
		ar->ar_gai_errno = EAI_MEMORY-10;
	else
		ar->ar_gai_errno = EAI_FAIL-4;
	async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0);
} else
	async_set_state(as, ASR_STATE_NEXT_FAMILY)do { ; (as)->as_state = (ASR_STATE_NEXT_FAMILY); } while (
0);
free(ar->ar_data);
break;

case ASR_STATE_NOT_FOUND:
/* No result found. Maybe we can try again. */
if (as->as_flags & ASYNC_AGAIN0x00000200)
	ar->ar_gai_errno = EAI_AGAIN-3;
else
	ar->ar_gai_errno = EAI_NODATA-5;
async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0);
break;

case ASR_STATE_HALT:
if (ar->ar_gai_errno == 0) {
	ar->ar_count = as->as_count;
	ar->ar_addrinfo = as->as.ai.aifirst;
	as->as.ai.aifirst = NULL((void *)0);
} else {
	ar->ar_count = 0;
	ar->ar_addrinfo = NULL((void *)0);
}
return (ASYNC_DONE1);

default:
ar->ar_errno = EOPNOTSUPP45;
ar->ar_gai_errno = EAI_SYSTEM-11;
async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0);
break;
}
goto next;
459}

461/*
* Retreive the port number for the service name "servname" and
* the protocol "proto".
*/
465static int
466get_port(const char *servname, const char *proto, int numonly)
467{
struct servent		se;
struct servent_data	sed;
int			port;
const char		*e;

if (servname == NULL((void *)0))
return (0);

e = NULL((void *)0);
port = strtonum(servname, 0, USHRT_MAX(32767 *2 +1), &e);
if (e == NULL((void *)0))
return (port);
if (errno(*__errno()) == ERANGE34)
return (-2); /* invalid */
if (numonly)
return (-2);

port = -1;
memset(&sed, 0, sizeof(sed));
if (getservbyname_r(servname, proto, &se, &sed) != -1)
port = ntohs(se.s_port)(__uint16_t)(__builtin_constant_p(se.s_port) ? (__uint16_t)((
(__uint16_t)(se.s_port) & 0xffU) << 8 | ((__uint16_t
)(se.s_port) & 0xff00U) >> 8) : __swap16md(se.s_port
));
endservent_r(&sed);

return (port);
492}

494/*
* Iterate over the address families that are to be queried. Use the
* list on the async context, unless a specific family was given in hints.
*/
498static int
499iter_family(struct asr_query *as, int first)
500{
if (first) {
as->as_family_idx = 0;
if (as->as.ai.hints.ai_family != PF_UNSPEC0)
	return as->as.ai.hints.ai_family;
return AS_FAMILY(as)((as)->as_ctx->ac_family[(as)->as_family_idx]);
}

if (as->as.ai.hints.ai_family != PF_UNSPEC0)
return (-1);

as->as_family_idx++;

return AS_FAMILY(as)((as)->as_ctx->ac_family[(as)->as_family_idx]);
514}

516/*
* Use the sockaddr at "sa" to extend the result list on the "as" context,
* with the specified canonical name "cname". This function adds one
* entry per protocol/socktype match.
*/
521static int
522addrinfo_add(struct asr_query *as, const struct sockaddr *sa, const char *cname)
523{
struct addrinfo		*ai;
int			 i, port, proto;

for (i = 0; matches[i].family != -1; i++) {
if (matches[i].family != sa->sa_family ||
    !MATCH_SOCKTYPE(as->as.ai.hints.ai_socktype, i)((as->as.ai.hints.ai_socktype) == matches[(i)].socktype ||
 ((as->as.ai.hints.ai_socktype) == 0 && matches[(i
)].socktype != 3)) ||
    !MATCH_PROTO(as->as.ai.hints.ai_protocol, i)((as->as.ai.hints.ai_protocol) == matches[(i)].protocol ||
 (as->as.ai.hints.ai_protocol) == 0 || matches[(i)].protocol
 == 0))
	continue;

proto = as->as.ai.hints.ai_protocol;
if (!proto)
	proto = matches[i].protocol;

if (proto == IPPROTO_TCP6)
	port = as->as.ai.port_tcp;
else if (proto == IPPROTO_UDP17)
	port = as->as.ai.port_udp;
else
	port = 0;

/* servname specified, but not defined for this protocol */
if (port == -1)
	continue;

ai = calloc(1, sizeof(*ai) + sa->sa_len);
if (ai == NULL((void *)0))
	return (EAI_MEMORY-10);
ai->ai_family = sa->sa_family;
ai->ai_socktype = matches[i].socktype;
ai->ai_protocol = proto;
ai->ai_flags = as->as.ai.hints.ai_flags;
ai->ai_addrlen = sa->sa_len;
ai->ai_addr = (void *)(ai + 1);
if (cname &&
    as->as.ai.hints.ai_flags & (AI_CANONNAME2 | AI_FQDN32)) {
	if ((ai->ai_canonname = strdup(cname)) == NULL((void *)0)) {
		free(ai);
		return (EAI_MEMORY-10);
	}
}
memmove(ai->ai_addr, sa, sa->sa_len);
if (sa->sa_family == PF_INET2)
	((struct sockaddr_in *)ai->ai_addr)->sin_port =
	    htons(port)(__uint16_t)(__builtin_constant_p(port) ? (__uint16_t)(((__uint16_t
)(port) & 0xffU) << 8 | ((__uint16_t)(port) & 0xff00U
) >> 8) : __swap16md(port));
else if (sa->sa_family == PF_INET624)
	((struct sockaddr_in6 *)ai->ai_addr)->sin6_port =
	    htons(port)(__uint16_t)(__builtin_constant_p(port) ? (__uint16_t)(((__uint16_t
)(port) & 0xffU) << 8 | ((__uint16_t)(port) & 0xff00U
) >> 8) : __swap16md(port));

if (as->as.ai.aifirst == NULL((void *)0))
	as->as.ai.aifirst = ai;
if (as->as.ai.ailast)
	as->as.ai.ailast->ai_next = ai;
as->as.ai.ailast = ai;
as->as_count += 1;
}

return (0);
581}

583static int
584addrinfo_from_file(struct asr_query *as, int family, FILE *f)
585{
char		*tokens[MAXTOKEN10], *c, buf[BUFSIZ1024 + 1];
int		 n, i;
union {
struct sockaddr		sa;
struct sockaddr_in	sain;
struct sockaddr_in6	sain6;
} u;

for (;;) {
n = _asr_parse_namedb_line(f, tokens, MAXTOKEN10, buf, sizeof(buf));
if (n == -1)
	break; /* ignore errors reading the file */

for (i = 1; i < n; i++) {
	if (strcasecmp(as->as.ai.hostname, tokens[i]))
		continue;
	if (_asr_sockaddr_from_str(&u.sa, family, tokens[0]) == -1)
		continue;
	break;
}
if (i == n)
	continue;

if (as->as.ai.hints.ai_flags & (AI_CANONNAME2 | AI_FQDN32))
	c = tokens[1];
else
	c = NULL((void *)0);

if (addrinfo_add(as, &u.sa, c))
	return (-1); /* errno set */
}
return (0);
618}

620static int
621addrinfo_from_pkt(struct asr_query *as, char *pkt, size_t pktlen)
622{
struct asr_unpack	 p;
struct asr_dns_header	 h;
struct asr_dns_query	 q;
struct asr_dns_rr	 rr;
int			 i;
union {
struct sockaddr		sa;
struct sockaddr_in	sain;
struct sockaddr_in6	sain6;
} u;
char		 buf[MAXDNAME1025], *c;

_asr_unpack_init(&p, pkt, pktlen);
_asr_unpack_header(&p, &h);
for (; h.qdcount; h.qdcount--)
7
←
Loop condition is false. Execution continues on line 640→
_asr_unpack_query(&p, &q);

for (i = 0; i < h.ancount; i++) {
8
←
Assuming 'i' is < field 'ancount'→
9
←
Loop condition is true.  Entering loop body→
_asr_unpack_rr(&p, &rr);
if (rr.rr_type != q.q_type ||
10
←
The right operand of '!=' is a garbage value
    rr.rr_class != q.q_class)
	continue;

memset(&u, 0, sizeof u);
if (rr.rr_type == T_A1) {
	u.sain.sin_len = sizeof u.sain;
	u.sain.sin_family = AF_INET2;
	u.sain.sin_addr = rr.rr.in_a.addr;
	u.sain.sin_port = 0;
} else if (rr.rr_type == T_AAAA28) {
	u.sain6.sin6_len = sizeof u.sain6;
	u.sain6.sin6_family = AF_INET624;
	u.sain6.sin6_addr = rr.rr.in_aaaa.addr6;
	u.sain6.sin6_port = 0;
} else
	continue;

if (as->as.ai.hints.ai_flags & AI_CANONNAME2) {
	_asr_strdname(rr.rr_dname, buf, sizeof buf);
	buf[strlen(buf) - 1] = '\0';
	c = res_hnok__res_hnok(buf) ? buf : NULL((void *)0);
} else if (as->as.ai.hints.ai_flags & AI_FQDN32)
	c = as->as.ai.fqdn;
else
	c = NULL((void *)0);

if (addrinfo_add(as, &u.sa, c))
	return (-1); /* errno set */
}
return (0);
673}

675static int
676addrconfig_setup(struct asr_query *as)
677{
struct ifaddrs		*ifa, *ifa0;
struct if_data		*ifa_data;
struct sockaddr_in	*sinp;
struct sockaddr_in6	*sin6p;
int			 rtable, ifa_rtable = -1;

if (getifaddrs(&ifa0) == -1)
return (-1);

rtable = getrtable();

as->as_flags |= ASYNC_NO_INET0x00010000 | ASYNC_NO_INET60x00020000;

for (ifa = ifa0; ifa != NULL((void *)0); ifa = ifa->ifa_next) {
if (ifa->ifa_addr == NULL((void *)0))
	continue;

switch (ifa->ifa_addr->sa_family) {
case PF_LINK18:
	/* AF_LINK comes before inet / inet6 on an interface */
	ifa_data = (struct if_data *)ifa->ifa_data;
	ifa_rtable = ifa_data->ifi_rdomain;
	break;
case PF_INET2:
	if (ifa_rtable != rtable)
		continue;

	sinp = (struct sockaddr_in *)ifa->ifa_addr;

	if (sinp->sin_addr.s_addr == htonl(INADDR_LOOPBACK)(__uint32_t)(__builtin_constant_p(((u_int32_t)(0x7f000001))) ?
 (__uint32_t)(((__uint32_t)(((u_int32_t)(0x7f000001))) & 0xff
) << 24 | ((__uint32_t)(((u_int32_t)(0x7f000001))) &
 0xff00) << 8 | ((__uint32_t)(((u_int32_t)(0x7f000001))
) & 0xff0000) >> 8 | ((__uint32_t)(((u_int32_t)(0x7f000001
))) & 0xff000000) >> 24) : __swap32md(((u_int32_t)(
0x7f000001)))))
		continue;

	as->as_flags &= ~ASYNC_NO_INET0x00010000;
	break;
case PF_INET624:
	if (ifa_rtable != rtable)
		continue;

	sin6p = (struct sockaddr_in6 *)ifa->ifa_addr;

	if (IN6_IS_ADDR_LOOPBACK(&sin6p->sin6_addr)((*(const u_int32_t *)(const void *)(&(&sin6p->sin6_addr
)->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t
 *)(const void *)(&(&sin6p->sin6_addr)->__u6_addr
.__u6_addr8[4]) == 0) && (*(const u_int32_t *)(const void
 *)(&(&sin6p->sin6_addr)->__u6_addr.__u6_addr8[
8]) == 0) && (*(const u_int32_t *)(const void *)(&
(&sin6p->sin6_addr)->__u6_addr.__u6_addr8[12]) == (
__uint32_t)(__builtin_constant_p(1) ? (__uint32_t)(((__uint32_t
)(1) & 0xff) << 24 | ((__uint32_t)(1) & 0xff00)
 << 8 | ((__uint32_t)(1) & 0xff0000) >> 8 | (
(__uint32_t)(1) & 0xff000000) >> 24) : __swap32md(1
)))))
		continue;

	if (IN6_IS_ADDR_LINKLOCAL(&sin6p->sin6_addr)(((&sin6p->sin6_addr)->__u6_addr.__u6_addr8[0] == 0xfe
) && (((&sin6p->sin6_addr)->__u6_addr.__u6_addr8
[1] & 0xc0) == 0x80)))
		continue;

	as->as_flags &= ~ASYNC_NO_INET60x00020000;
	break;
}
}

freeifaddrs(ifa0);

return (0);
732}